@snaptrude/plugin-core 0.5.0 → 0.6.0

package/dist/index.js

@@ -27,6 +27,9 @@ var ContourHandle = handleSchema("contour");
 var MassHandle = handleSchema("mass");
 var ComponentHandle = z.string().min(1).transform((s) => s);
 var MaterialHandle = z.string().min(1).transform((s) => s);
+var UnderlayHandle = z.string().min(1).transform((s) => s);
+var TerrainHandle = z.string().min(1).transform((s) => s);
+var ImportJobHandle = z.string().min(1).transform((s) => s);
 var Vec3Handle = handleSchema("vec3");
 var QuatHandle = handleSchema("quat");
 var LineHandle = handleSchema("line");
@@ -1040,6 +1043,128 @@ var PluginCoreTagsUnassignArgs = z24.object({
 });
 var PluginCoreTagsUnassignResult = PluginCoreAssignOutcome;
 
+// src/api/core/io/import/index.ts
+import * as z25 from "zod";
+var ImportSource = z25.string().min(1).refine((s) => s.startsWith("https://") || s.startsWith("data:"), {
+  message: "source must be an https:// URL or a data: URL"
+});
+var PluginCoreIoImportApi = class {
+  constructor() {
+  }
+};
+var ModelFormat = z25.enum(["skp", "fbx", "obj", "3ds", "zip"]);
+var CadJsonInput = z25.object({
+  unit: z25.string().optional(),
+  geometry: z25.array(z25.record(z25.string(), z25.unknown())).optional()
+}).passthrough();
+var PluginImportImageArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  scale: z25.number().positive().optional(),
+  opacity: z25.number().min(0).max(1).optional(),
+  label: z25.string().optional()
+});
+var PluginImportPdfArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  page: z25.number().int().positive().optional(),
+  scale: z25.string().optional(),
+  opacity: z25.number().min(0).max(1).optional()
+});
+var PluginImportDwgArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional()
+});
+var PluginImportCadJsonArgs = z25.object({
+  cad: CadJsonInput,
+  storey: z25.number().int().optional()
+});
+var PluginImportModelArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  format: ModelFormat.optional(),
+  position: Vec3Handle.optional(),
+  label: z25.string().optional()
+});
+var PluginImportTerrainArgs = z25.object({
+  lat: z25.number().min(-90).max(90),
+  lng: z25.number().min(-180).max(180),
+  width: z25.number().positive().finite(),
+  length: z25.number().positive().finite(),
+  elevation: z25.boolean().optional(),
+  satellite: z25.boolean().optional(),
+  neighborhood: z25.boolean().optional(),
+  parcels: z25.boolean().optional()
+});
+
+// src/api/core/io/job/index.ts
+import * as z26 from "zod";
+var PluginCoreIoJobApi = class {
+  constructor() {
+  }
+};
+var ImportJobStatus = z26.enum(["pending", "processing", "complete", "failed"]);
+var PluginImportJobArgs = z26.object({
+  job: ImportJobHandle
+});
+
+// src/api/core/io/underlay/index.ts
+import * as z27 from "zod";
+var PluginCoreIoUnderlayApi = class {
+  constructor() {
+  }
+};
+var PluginUnderlayListArgs = z27.object({
+  storey: z27.number().int().optional()
+});
+var PluginUnderlayPlanSize = z27.object({
+  planSize: z27.number().positive()
+});
+var PluginUnderlaySetScaleValue = z27.union([
+  z27.number().positive(),
+  PluginUnderlayPlanSize
+]);
+var PluginUnderlaySetScaleArgs = z27.object({
+  underlay: UnderlayHandle,
+  scale: PluginUnderlaySetScaleValue
+});
+var PluginUnderlaySetOpacityArgs = z27.object({
+  underlay: UnderlayHandle,
+  opacity: z27.number().min(0).max(1)
+});
+var PluginUnderlayRefArgs = z27.object({
+  underlay: UnderlayHandle
+});
+
+// src/api/core/io/terrain/index.ts
+import * as z28 from "zod";
+var PluginCoreIoTerrainApi = class {
+  constructor() {
+  }
+};
+var TerrainReport = z28.object({
+  cutVolume: z28.number(),
+  fillVolume: z28.number(),
+  netVolume: z28.number()
+});
+var PluginTerrainSetDatumArgs = z28.object({ offset: z28.number().finite() });
+var PluginTerrainSetOpacityArgs = z28.object({ opacity: z28.number().min(0).max(1) });
+
+// src/api/core/io/query/index.ts
+import * as z29 from "zod";
+var PluginCoreIoQueryApi = class {
+  constructor() {
+  }
+};
+var PluginQueryPdfPageCountArgs = z29.object({ source: z29.string().min(1) });
+var PluginQueryCadLayersArgs = z29.object({ cad: CadJsonInput });
+
+// src/api/core/io/index.ts
+var PluginCoreIoApi = class {
+  constructor() {
+  }
+};
+
 // src/api/core/index.ts
 var PluginCoreApi = class {
   constructor() {
@@ -1047,39 +1172,39 @@ var PluginCoreApi = class {
 };
 
 // src/api/design/create/index.ts
-import * as z26 from "zod";
+import * as z31 from "zod";
 
 // src/api/entity/space.ts
-import * as z25 from "zod";
-var PluginSpaceCreateRectangularArgs = z25.object({
+import * as z30 from "zod";
+var PluginSpaceCreateRectangularArgs = z30.object({
   position: Vec3Handle,
-  dimensions: z25.object({
-    width: z25.number(),
-    height: z25.number(),
-    depth: z25.number()
+  dimensions: z30.object({
+    width: z30.number(),
+    height: z30.number(),
+    depth: z30.number()
   })
 });
-var PluginSpaceCreateRectangularResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceCreateRectangularResult = z30.object({
+  spaceId: z30.string()
 });
-var PluginSpaceCreateFromProfileArgs = z25.object({
+var PluginSpaceCreateFromProfileArgs = z30.object({
   profile: ProfileHandle,
-  innerProfiles: z25.array(ProfileHandle).optional(),
-  extrudeHeight: z25.number(),
+  innerProfiles: z30.array(ProfileHandle).optional(),
+  extrudeHeight: z30.number(),
   position: Vec3Handle
 });
-var PluginSpaceCreateFromProfileResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceCreateFromProfileResult = z30.object({
+  spaceId: z30.string()
 });
-var PluginSpaceUpdateGeometryFromProfileArgs = z25.object({
-  spaceId: z25.string(),
+var PluginSpaceUpdateGeometryFromProfileArgs = z30.object({
+  spaceId: z30.string(),
   profile: ProfileHandle,
-  extrudeHeight: z25.number()
+  extrudeHeight: z30.number()
 });
-var PluginSpaceUpdateGeometryFromProfileResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceUpdateGeometryFromProfileResult = z30.object({
+  spaceId: z30.string()
 });
-var PluginSpaceGetProperty = z25.enum([
+var PluginSpaceGetProperty = z30.enum([
   // Basic
   "id",
   "type",
@@ -1110,11 +1235,11 @@ var PluginSpaceGetProperty = z25.enum([
   // Derived from adjacency manager
   "adjacency"
 ]);
-var PluginSpaceGetArgs = z25.object({
-  spaceId: z25.string(),
-  properties: z25.array(PluginSpaceGetProperty)
+var PluginSpaceGetArgs = z30.object({
+  spaceId: z30.string(),
+  properties: z30.array(PluginSpaceGetProperty)
 });
-var PluginSpaceType = z25.enum([
+var PluginSpaceType = z30.enum([
   "Room",
   "Program Block",
   "Balcony",
@@ -1126,51 +1251,51 @@ var PluginSpaceType = z25.enum([
   "Envelope",
   "Parking"
 ]);
-var PluginAreaClass = z25.enum(["NET", "GROSS", "EXCLUDED"]);
-var PluginSpaceGetResult = z25.object({
+var PluginAreaClass = z30.enum(["NET", "GROSS", "EXCLUDED"]);
+var PluginSpaceGetResult = z30.object({
   // Basic
-  id: z25.string(),
-  type: z25.string(),
-  room_type: z25.string(),
-  name: z25.string(),
+  id: z30.string(),
+  type: z30.string(),
+  room_type: z30.string(),
+  name: z30.string(),
   // Derived from parametric data
-  area: z25.number(),
-  breadth: z25.number(),
-  depth: z25.number(),
-  height: z25.number(),
-  massType: z25.string().nullable(),
+  area: z30.number(),
+  breadth: z30.number(),
+  depth: z30.number(),
+  height: z30.number(),
+  massType: z30.string().nullable(),
   spaceType: PluginSpaceType.nullable(),
   areaClass: PluginAreaClass,
-  storey: z25.number().nullable(),
-  departmentId: z25.string().nullable(),
-  departmentName: z25.string(),
-  departmentColor: z25.string(),
+  storey: z30.number().nullable(),
+  departmentId: z30.string().nullable(),
+  departmentName: z30.string(),
+  departmentColor: z30.string(),
   // Derived from mesh
   position: Vec3Components,
   absolutePosition: Vec3Components,
   rotation: Vec3Components,
   rotationQuaternion: QuatComponents.nullable(),
   // Derived from brep
-  planPoints: z25.array(Vec3Components),
-  profile: z25.array(CurveHandle),
-  innerProfiles: z25.array(z25.array(CurveHandle)),
-  innerPlanPoints: z25.array(z25.array(Vec3Components)),
+  planPoints: z30.array(Vec3Components),
+  profile: z30.array(CurveHandle),
+  innerProfiles: z30.array(z30.array(CurveHandle)),
+  innerPlanPoints: z30.array(z30.array(Vec3Components)),
   // Derived from adjacency manager.
   // value: 2 = Direct (required), 1 = Indirect or physical contact, -1 = Restricted;
   // 0 (no relationship) entries are filtered out. Empty array when adjacency has
   // never been computed — run program.adjacency.compute() first for fresh data.
-  adjacency: z25.array(z25.object({
-    spaceId: z25.string(),
-    value: z25.number()
+  adjacency: z30.array(z30.object({
+    spaceId: z30.string(),
+    value: z30.number()
   }))
 }).partial();
-var PluginSpaceGetAllResult = z25.object({
-  spacesIds: z25.array(z25.string())
+var PluginSpaceGetAllResult = z30.object({
+  spacesIds: z30.array(z30.string())
 });
-var PluginSpaceDeleteArgs = z25.object({
-  spaceId: z25.string()
+var PluginSpaceDeleteArgs = z30.object({
+  spaceId: z30.string()
 });
-var PluginMassType = z25.enum([
+var PluginMassType = z30.enum([
   "Plinth",
   "Void",
   "Pergola",
@@ -1184,89 +1309,89 @@ var PluginMassType = z25.enum([
   "Mass",
   "Site"
 ]);
-var PluginWellKnownDepartmentId = z25.enum([
+var PluginWellKnownDepartmentId = z30.enum([
   "DEFAULT",
   "SITE",
   "ENVELOPE",
   "CORE"
 ]);
-var PluginDepartmentId = z25.union([
+var PluginDepartmentId = z30.union([
   PluginWellKnownDepartmentId,
-  z25.uuid()
+  z30.uuid()
 ]);
-var PluginSpaceUpdateArgs = z25.object({
-  spaceId: z25.string(),
-  properties: z25.object({
-    room_type: z25.string().optional(),
+var PluginSpaceUpdateArgs = z30.object({
+  spaceId: z30.string(),
+  properties: z30.object({
+    room_type: z30.string().optional(),
     massType: PluginMassType.optional(),
     spaceType: PluginSpaceType.optional(),
     areaClass: PluginAreaClass.optional(),
     departmentId: PluginDepartmentId.optional()
   })
 });
-var PluginSpaceUpdateResult = z25.object({
-  spaceId: z25.string(),
-  room_type: z25.string().optional(),
-  massType: z25.string().optional(),
-  spaceType: z25.string().optional(),
+var PluginSpaceUpdateResult = z30.object({
+  spaceId: z30.string(),
+  room_type: z30.string().optional(),
+  massType: z30.string().optional(),
+  spaceType: z30.string().optional(),
   areaClass: PluginAreaClass.optional(),
-  departmentId: z25.string().nullable().optional()
+  departmentId: z30.string().nullable().optional()
 });
-var PluginSpaceBulkCreateItem = z25.discriminatedUnion("kind", [
-  z25.object({
-    kind: z25.literal("rectangular"),
+var PluginSpaceBulkCreateItem = z30.discriminatedUnion("kind", [
+  z30.object({
+    kind: z30.literal("rectangular"),
     position: Vec3Handle,
-    dimensions: z25.object({
-      width: z25.number(),
-      height: z25.number(),
-      depth: z25.number()
+    dimensions: z30.object({
+      width: z30.number(),
+      height: z30.number(),
+      depth: z30.number()
     }),
-    room_type: z25.string().optional(),
+    room_type: z30.string().optional(),
     spaceType: PluginSpaceType.optional(),
     massType: PluginMassType.optional(),
     departmentId: PluginDepartmentId.optional()
   }),
-  z25.object({
-    kind: z25.literal("profile"),
+  z30.object({
+    kind: z30.literal("profile"),
     profile: ProfileHandle,
-    innerProfiles: z25.array(ProfileHandle).optional(),
-    extrudeHeight: z25.number(),
+    innerProfiles: z30.array(ProfileHandle).optional(),
+    extrudeHeight: z30.number(),
     position: Vec3Handle,
-    room_type: z25.string().optional(),
+    room_type: z30.string().optional(),
     spaceType: PluginSpaceType.optional(),
     massType: PluginMassType.optional(),
     departmentId: PluginDepartmentId.optional()
   })
 ]);
-var PluginSpaceBulkCreateArgs = z25.object({
-  items: z25.array(PluginSpaceBulkCreateItem)
+var PluginSpaceBulkCreateArgs = z30.object({
+  items: z30.array(PluginSpaceBulkCreateItem)
 });
-var PluginSpaceBulkCreateResult = z25.object({
-  spaceIds: z25.array(z25.string())
+var PluginSpaceBulkCreateResult = z30.object({
+  spaceIds: z30.array(z30.string())
 });
-var PluginSpaceBulkUpdateItem = z25.object({
-  spaceId: z25.string(),
+var PluginSpaceBulkUpdateItem = z30.object({
+  spaceId: z30.string(),
   profile: ProfileHandle.optional(),
-  extrudeHeight: z25.number().optional(),
-  properties: z25.object({
-    room_type: z25.string().optional(),
+  extrudeHeight: z30.number().optional(),
+  properties: z30.object({
+    room_type: z30.string().optional(),
     massType: PluginMassType.optional(),
     spaceType: PluginSpaceType.optional(),
     areaClass: PluginAreaClass.optional(),
     departmentId: PluginDepartmentId.optional()
   }).optional()
 });
-var PluginSpaceBulkUpdateArgs = z25.object({
-  items: z25.array(PluginSpaceBulkUpdateItem)
+var PluginSpaceBulkUpdateArgs = z30.object({
+  items: z30.array(PluginSpaceBulkUpdateItem)
 });
-var PluginSpaceBulkUpdateResult = z25.object({
-  spaces: z25.array(PluginSpaceUpdateResult)
+var PluginSpaceBulkUpdateResult = z30.object({
+  spaces: z30.array(PluginSpaceUpdateResult)
 });
-var PluginSpaceBulkDeleteArgs = z25.object({
-  spaceIds: z25.array(z25.string())
+var PluginSpaceBulkDeleteArgs = z30.object({
+  spaceIds: z30.array(z30.string())
 });
-var PluginSpaceBulkDeleteResult = z25.object({
-  deletedSpaceIds: z25.array(z25.string())
+var PluginSpaceBulkDeleteResult = z30.object({
+  deletedSpaceIds: z30.array(z30.string())
 });
 
 // src/api/design/create/index.ts
@@ -1274,14 +1399,14 @@ var PluginDesignCreateApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineStyle = z26.enum(["SOLID", "DASHED", "DOT_DASH"]);
-var PluginSlabType = z26.enum([
+var PluginReferenceLineStyle = z31.enum(["SOLID", "DASHED", "DOT_DASH"]);
+var PluginSlabType = z31.enum([
   "Intermediate Slab",
   "Basement Slab",
   "Plinth",
   "Roof"
 ]);
-var PluginStaircasePreset = z26.enum([
+var PluginStaircasePreset = z31.enum([
   "straight",
   "straightWoLanding",
   "straightFlightWoMidLanding",
@@ -1299,89 +1424,89 @@ var PluginStaircasePreset = z26.enum([
   "mezzanineFloorLShaped",
   "custom"
 ]);
-var PluginDesignCreateSpaceArgs = z26.object({
+var PluginDesignCreateSpaceArgs = z31.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z31.number(),
+  label: z31.string().optional(),
   position: Vec3Handle.optional(),
   spaceType: PluginSpaceType.optional(),
   massType: PluginMassType.optional(),
   departmentId: PluginDepartmentId.optional()
 });
-var PluginDesignCreateMassArgs = z26.object({
+var PluginDesignCreateMassArgs = z31.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z31.number(),
+  label: z31.string().optional(),
   position: Vec3Handle.optional(),
   massType: PluginMassType.optional()
 });
-var PluginDesignCreateSlabArgs = z26.object({
+var PluginDesignCreateSlabArgs = z31.object({
   contour: ContourHandle,
-  thickness: z26.number(),
-  direction: z26.enum(["up", "down"]).optional(),
+  thickness: z31.number(),
+  direction: z31.enum(["up", "down"]).optional(),
   slabType: PluginSlabType.optional()
 });
-var PluginDesignCreateFloorArgs = z26.object({
+var PluginDesignCreateFloorArgs = z31.object({
   contour: ContourHandle,
-  thickness: z26.number(),
+  thickness: z31.number(),
   position: Vec3Handle.optional()
 });
-var PluginDesignCreateRoofArgs = z26.object({
+var PluginDesignCreateRoofArgs = z31.object({
   contour: ContourHandle,
-  thickness: z26.number()
+  thickness: z31.number()
 });
-var PluginDesignCreateCeilingArgs = z26.object({
+var PluginDesignCreateCeilingArgs = z31.object({
   contour: ContourHandle,
-  thickness: z26.number(),
-  heightFromFloor: z26.number().optional()
+  thickness: z31.number(),
+  heightFromFloor: z31.number().optional()
 });
-var PluginDesignCreateColumnArgs = z26.object({
+var PluginDesignCreateColumnArgs = z31.object({
   position: Vec3Handle,
   crossSection: ContourHandle,
-  height: z26.number(),
+  height: z31.number(),
   directionUp: Vec3Handle.optional()
 });
-var PluginDesignCreateBeamArgs = z26.object({
+var PluginDesignCreateBeamArgs = z31.object({
   section: ContourHandle,
-  length: z26.number(),
+  length: z31.number(),
   direction: Vec3Handle.optional()
 });
-var PluginDesignCreateWallsArgs = z26.object({
+var PluginDesignCreateWallsArgs = z31.object({
   profile: ProfileHandle,
-  height: z26.number().optional(),
-  thickness: z26.number().optional()
+  height: z31.number().optional(),
+  thickness: z31.number().optional()
 });
-var PluginDesignCreateStaircaseArgs = z26.object({
+var PluginDesignCreateStaircaseArgs = z31.object({
   preset: PluginStaircasePreset,
   position: Vec3Handle,
-  label: z26.string().optional(),
-  structureId: z26.string().optional(),
-  level: z26.string().optional()
+  label: z31.string().optional(),
+  structureId: z31.string().optional(),
+  level: z31.string().optional()
 });
-var PluginDesignCreateFurnitureArgs = z26.object({
-  catalogId: z26.string().min(1),
+var PluginDesignCreateFurnitureArgs = z31.object({
+  catalogId: z31.string().min(1),
   position: Vec3Handle,
-  label: z26.string().optional(),
-  createNewSourceMesh: z26.boolean().optional()
+  label: z31.string().optional(),
+  createNewSourceMesh: z31.boolean().optional()
 });
-var PluginDesignCreateReferenceLinesArgs = z26.object({
+var PluginDesignCreateReferenceLinesArgs = z31.object({
   profile: ProfileHandle,
-  color: z26.string().optional(),
-  thickness: z26.number().optional(),
+  color: z31.string().optional(),
+  thickness: z31.number().optional(),
   style: PluginReferenceLineStyle.optional(),
-  gridTag: z26.string().optional()
+  gridTag: z31.string().optional()
 });
-var PluginCopyMode = z26.enum(["instance", "unique"]);
-var PluginDesignCreateCopyArgs = z26.object({
-  components: z26.array(ComponentHandle).min(1),
+var PluginCopyMode = z31.enum(["instance", "unique"]);
+var PluginDesignCreateCopyArgs = z31.object({
+  components: z31.array(ComponentHandle).min(1),
   displacement: Vec3Handle,
-  count: z26.number().int().positive().optional(),
+  count: z31.number().int().positive().optional(),
   mode: PluginCopyMode.optional()
 });
-var PluginCreateSpaceItem = z26.object({
+var PluginCreateSpaceItem = z31.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z31.number(),
+  label: z31.string().optional(),
   position: Vec3Handle.optional(),
   spaceType: PluginSpaceType.optional(),
   massType: PluginMassType.optional(),
@@ -1389,44 +1514,44 @@ var PluginCreateSpaceItem = z26.object({
 });
 
 // src/api/design/query/index.ts
-import * as z29 from "zod";
+import * as z34 from "zod";
 
 // src/api/design/query/geometry/index.ts
-import * as z27 from "zod";
+import * as z32 from "zod";
 var PluginDesignQueryGeometryApi = class {
   constructor() {
   }
 };
-var PluginDesignQueryGeometryGetBrepArgs = z27.object({
+var PluginDesignQueryGeometryGetBrepArgs = z32.object({
   component: ComponentHandle
 });
-var PluginDesignQueryGeometryGetBottomContourArgs = z27.object({
+var PluginDesignQueryGeometryGetBottomContourArgs = z32.object({
   component: ComponentHandle
 });
-var PluginDesignQueryGeometryGetCenterlineArgs = z27.object({
+var PluginDesignQueryGeometryGetCenterlineArgs = z32.object({
   component: ComponentHandle
 });
 
 // src/api/design/query/spaces.ts
-import * as z28 from "zod";
+import * as z33 from "zod";
 var PluginDesignQuerySpacesApi = class {
   constructor() {
   }
 };
-var PluginDesignQueryGetFootprintArgs = z28.object({
+var PluginDesignQueryGetFootprintArgs = z33.object({
   space: ComponentHandle
 });
 var PluginDesignQuerySpacesGetProperty = PluginSpaceGetProperty.exclude(["adjacency"]);
-var PluginDesignQuerySpacesGetArgs = z28.object({
+var PluginDesignQuerySpacesGetArgs = z33.object({
   space: ComponentHandle,
-  properties: z28.array(PluginDesignQuerySpacesGetProperty)
+  properties: z33.array(PluginDesignQuerySpacesGetProperty)
 });
 var PluginDesignQuerySpacesGetResult = PluginSpaceGetResult.omit({
   adjacency: true
 });
 
 // src/api/design/query/index.ts
-var PluginEntityType = z29.enum([
+var PluginEntityType = z34.enum([
   "wall",
   "space",
   "mass",
@@ -1445,55 +1570,55 @@ var PluginEntityType = z29.enum([
   "mullion",
   "panel"
 ]);
-var PluginEntityFilter = z29.object({
-  types: z29.array(PluginEntityType).optional(),
-  storeys: z29.array(z29.number()).optional(),
-  buildingIds: z29.array(z29.string()).optional(),
-  structureIds: z29.array(z29.string()).optional(),
-  label: z29.string().optional(),
-  massTypes: z29.array(PluginMassType).optional(),
-  spaceTypes: z29.array(PluginSpaceType).optional(),
+var PluginEntityFilter = z34.object({
+  types: z34.array(PluginEntityType).optional(),
+  storeys: z34.array(z34.number()).optional(),
+  buildingIds: z34.array(z34.string()).optional(),
+  structureIds: z34.array(z34.string()).optional(),
+  label: z34.string().optional(),
+  massTypes: z34.array(PluginMassType).optional(),
+  spaceTypes: z34.array(PluginSpaceType).optional(),
   departmentId: PluginDepartmentId.optional(),
-  isSelected: z29.boolean().optional(),
-  isLocked: z29.boolean().optional(),
-  isHidden: z29.boolean().optional(),
+  isSelected: z34.boolean().optional(),
+  isLocked: z34.boolean().optional(),
+  isHidden: z34.boolean().optional(),
   within: BBoxComponents.optional(),
   overlaps: ComponentHandle.optional(),
-  ids: z29.array(ComponentHandle).optional()
+  ids: z34.array(ComponentHandle).optional()
 });
 var PluginDesignQueryListByTypeArgs = PluginEntityFilter.extend({
   type: PluginEntityType
 });
-var PluginDesignQueryComponentArgs = z29.object({
+var PluginDesignQueryComponentArgs = z34.object({
   component: ComponentHandle
 });
-var PluginDesignQueryIdArgs = z29.object({
+var PluginDesignQueryIdArgs = z34.object({
   id: ComponentHandle
 });
-var PluginDesignQueryComponentsArgs = z29.object({
-  components: z29.array(ComponentHandle)
+var PluginDesignQueryComponentsArgs = z34.object({
+  components: z34.array(ComponentHandle)
 });
-var PluginEntityProperties = z29.object({
-  id: z29.string(),
+var PluginEntityProperties = z34.object({
+  id: z34.string(),
   type: PluginEntityType,
-  label: z29.string(),
-  storey: z29.number(),
-  buildingId: z29.string(),
-  structureId: z29.string(),
-  massType: z29.string(),
+  label: z34.string(),
+  storey: z34.number(),
+  buildingId: z34.string(),
+  structureId: z34.string(),
+  massType: z34.string(),
   spaceType: PluginSpaceType,
   areaClass: PluginAreaClass,
-  departmentId: z29.string(),
-  isLocked: z29.boolean(),
-  isHidden: z29.boolean(),
-  isSelected: z29.boolean(),
+  departmentId: z34.string(),
+  isLocked: z34.boolean(),
+  isHidden: z34.boolean(),
+  isSelected: z34.boolean(),
   boundingBox: BBoxComponents,
-  adjacency: z29.array(z29.object({ spaceId: z29.string(), value: z29.number() }))
+  adjacency: z34.array(z34.object({ spaceId: z34.string(), value: z34.number() }))
 }).partial();
-var PluginEntityMeasurements = z29.object({
-  area: z29.number().optional(),
-  volume: z29.number().optional(),
-  length: z29.number().optional(),
+var PluginEntityMeasurements = z34.object({
+  area: z34.number().optional(),
+  volume: z34.number().optional(),
+  length: z34.number().optional(),
   boundingBox: BBoxComponents
 });
 var PluginDesignQueryApi = class {
@@ -1502,170 +1627,202 @@ var PluginDesignQueryApi = class {
 };
 
 // src/api/design/selection/index.ts
-import * as z30 from "zod";
+import * as z35 from "zod";
+var PluginSelectionEntityType = z35.enum([
+  "wall",
+  "slab",
+  "floor",
+  "door",
+  "window",
+  "beam",
+  "column",
+  "ceiling",
+  "roof",
+  "staircase",
+  "furniture",
+  "pergola",
+  "sunshade",
+  "referenceLine",
+  "space",
+  "site",
+  "terrain",
+  "cad",
+  "pdf",
+  "image",
+  "dimensionLine",
+  "model3d",
+  "neighborhoodBuilding",
+  "programBlock"
+]);
+var PluginSelectionFilter = z35.object({
+  storeys: z35.array(z35.number()).optional(),
+  types: z35.array(PluginSelectionEntityType).optional()
+}).refine((f) => (f.storeys?.length ?? 0) + (f.types?.length ?? 0) > 0, {
+  message: "PluginSelectionFilter requires at least one non-empty field (storeys or types); use design.selection.clear() to deselect everything"
+});
 var PluginDesignSelectionApi = class {
   constructor() {
   }
 };
-var PluginDesignSelectionSetArgs = z30.object({
-  components: z30.array(ComponentHandle)
+var PluginDesignSelectionSetArgs = z35.object({
+  components: z35.array(ComponentHandle)
 });
 var PluginDesignSelectionAddArgs = PluginDesignSelectionSetArgs;
 var PluginDesignSelectionRemoveArgs = PluginDesignSelectionSetArgs;
 
 // src/api/design/doors/index.ts
-import * as z31 from "zod";
+import * as z36 from "zod";
 var PluginDesignDoorsApi = class {
   constructor() {
   }
 };
-var PluginDesignDoorArgs = z31.object({
+var PluginDesignDoorArgs = z36.object({
   door: ComponentHandle
 });
-var PluginMirrorAxis = z31.enum(["x", "y", "z"]);
-var PluginDesignDoorMirrorArgs = z31.object({
+var PluginMirrorAxis = z36.enum(["x", "y", "z"]);
+var PluginDesignDoorMirrorArgs = z36.object({
   door: ComponentHandle,
   axis: PluginMirrorAxis.optional()
 });
-var PluginDesignDoorSetWidthArgs = z31.object({
-  doors: z31.array(ComponentHandle),
-  width: z31.number()
+var PluginDesignDoorSetWidthArgs = z36.object({
+  doors: z36.array(ComponentHandle),
+  width: z36.number()
 });
-var PluginDesignDoorSetHeightArgs = z31.object({
-  doors: z31.array(ComponentHandle),
-  height: z31.number()
+var PluginDesignDoorSetHeightArgs = z36.object({
+  doors: z36.array(ComponentHandle),
+  height: z36.number()
 });
 
 // src/api/design/windows/index.ts
-import * as z32 from "zod";
+import * as z37 from "zod";
 var PluginDesignWindowsApi = class {
   constructor() {
   }
 };
-var PluginDesignWindowArgs = z32.object({
+var PluginDesignWindowArgs = z37.object({
   window: ComponentHandle
 });
-var PluginWindowDimensions = z32.object({
-  width: z32.number(),
-  height: z32.number(),
-  thickness: z32.number()
+var PluginWindowDimensions = z37.object({
+  width: z37.number(),
+  height: z37.number(),
+  thickness: z37.number()
 });
-var PluginDesignWindowSetWidthArgs = z32.object({
+var PluginDesignWindowSetWidthArgs = z37.object({
   window: ComponentHandle,
-  width: z32.number()
+  width: z37.number()
 });
-var PluginDesignWindowSetHeightArgs = z32.object({
+var PluginDesignWindowSetHeightArgs = z37.object({
   window: ComponentHandle,
-  height: z32.number()
+  height: z37.number()
 });
 
 // src/api/design/furniture/index.ts
-import * as z33 from "zod";
+import * as z38 from "zod";
 var PluginDesignFurnitureApi = class {
   constructor() {
   }
 };
-var PluginFurnitureCatalogItem = z33.object({
-  id: z33.string(),
-  name: z33.string(),
-  source: z33.enum(["team", "general"]),
-  subType: z33.string().optional(),
-  cost: z33.number().optional(),
-  familyName: z33.string().optional()
+var PluginFurnitureCatalogItem = z38.object({
+  id: z38.string(),
+  name: z38.string(),
+  source: z38.enum(["team", "general"]),
+  subType: z38.string().optional(),
+  cost: z38.number().optional(),
+  familyName: z38.string().optional()
 });
-var PluginDesignFurnitureListCatalogArgs = z33.object({
-  source: z33.enum(["team", "general"]).optional()
+var PluginDesignFurnitureListCatalogArgs = z38.object({
+  source: z38.enum(["team", "general"]).optional()
 });
-var PluginDesignFurnitureGetCatalogItemArgs = z33.object({
-  id: z33.string()
+var PluginDesignFurnitureGetCatalogItemArgs = z38.object({
+  id: z38.string()
 });
 var PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs;
 
 // src/api/design/materials/index.ts
-import * as z34 from "zod";
+import * as z39 from "zod";
 var PluginDesignMaterialsApi = class {
   constructor() {
   }
 };
-var PluginMaterialInfo = z34.object({
-  name: z34.string(),
-  id: z34.string(),
-  colorHex: z34.string(),
-  alpha: z34.number(),
-  materialType: z34.string().optional(),
-  textureUrl: z34.string().optional()
-});
-var PluginMaterialSpec = z34.object({
-  name: z34.string().optional(),
-  color: z34.string().optional(),
-  textureUrl: z34.string().optional(),
-  alpha: z34.number().optional(),
-  materialType: z34.string().optional()
-});
-var PluginMaterialResult = z34.object({ count: z34.number() });
-var PluginDesignMaterialsListArgs = z34.object({
-  scope: z34.enum(["project", "preset"]).optional()
-});
-var PluginDesignMaterialsGetInfoArgs = z34.object({ material: MaterialHandle });
-var PluginDesignMaterialsComponentArgs = z34.object({ component: ComponentHandle });
-var PluginDesignMaterialsApplyArgs = z34.object({
-  targets: z34.array(ComponentHandle),
-  material: z34.union([MaterialHandle, PluginMaterialSpec]),
-  save: z34.boolean().optional()
-});
-var PluginDesignMaterialsResetArgs = z34.object({
-  components: z34.array(ComponentHandle),
-  save: z34.boolean().optional()
-});
-var PluginDesignMaterialsCreateArgs = z34.object({ spec: PluginMaterialSpec });
+var PluginMaterialInfo = z39.object({
+  name: z39.string(),
+  id: z39.string(),
+  colorHex: z39.string(),
+  alpha: z39.number(),
+  materialType: z39.string().optional(),
+  textureUrl: z39.string().optional()
+});
+var PluginMaterialSpec = z39.object({
+  name: z39.string().optional(),
+  color: z39.string().optional(),
+  textureUrl: z39.string().optional(),
+  alpha: z39.number().optional(),
+  materialType: z39.string().optional()
+});
+var PluginMaterialResult = z39.object({ count: z39.number() });
+var PluginDesignMaterialsListArgs = z39.object({
+  scope: z39.enum(["project", "preset"]).optional()
+});
+var PluginDesignMaterialsGetInfoArgs = z39.object({ material: MaterialHandle });
+var PluginDesignMaterialsComponentArgs = z39.object({ component: ComponentHandle });
+var PluginDesignMaterialsApplyArgs = z39.object({
+  targets: z39.array(ComponentHandle),
+  material: z39.union([MaterialHandle, PluginMaterialSpec]),
+  save: z39.boolean().optional()
+});
+var PluginDesignMaterialsResetArgs = z39.object({
+  components: z39.array(ComponentHandle),
+  save: z39.boolean().optional()
+});
+var PluginDesignMaterialsCreateArgs = z39.object({ spec: PluginMaterialSpec });
 
 // src/api/design/lock.ts
-import * as z35 from "zod";
-var PluginDesignChangeResult = z35.object({
-  affected: z35.array(ComponentHandle)
+import * as z40 from "zod";
+var PluginDesignChangeResult = z40.object({
+  affected: z40.array(ComponentHandle)
 });
-var PluginDesignLockArgs = z35.object({
-  components: z35.array(ComponentHandle)
+var PluginDesignLockArgs = z40.object({
+  components: z40.array(ComponentHandle)
 });
 var PluginDesignUnlockArgs = PluginDesignLockArgs;
-var PluginDesignIsLockedArgs = z35.object({
+var PluginDesignIsLockedArgs = z40.object({
   component: ComponentHandle,
-  includeInherited: z35.boolean().optional()
+  includeInherited: z40.boolean().optional()
 });
 
 // src/api/design/erase/index.ts
-import * as z36 from "zod";
-var EraseStrategy = z36.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
+import * as z41 from "zod";
+var EraseStrategy = z41.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
 var DEFAULT_ERASE_STRATEGIES = ["DirectDelete", "DirectUnion"];
-var ErasableEdgeRef = z36.object({
+var ErasableEdgeRef = z41.object({
   /** Opaque bottom-graph edge id (engine form `"e-<n>"`). Do not mutate. Pass verbatim to {@linkcode PluginDesignEraseApi.edge}. */
-  id: z36.string().min(1),
+  id: z41.string().min(1),
   /** What erasing this edge would do: `DirectDelete` drops a mass; `DirectUnion` merges two adjacent masses. */
   strategy: EraseStrategy,
   /** Bottom-graph edge weight: `1` = external boundary edge, `>=2` = internal edge shared between components. */
-  edgeWeight: z36.number(),
-  /** The components this edge is incident to — one for external (DirectDelete), two for internal (DirectUnion). */
-  components: z36.array(ComponentHandle),
+  edgeWeight: z41.number(),
+  /** The components this edge is incident to — one for external (DirectDelete); two or more for internal (DirectUnion; 3+ at T-junctions where several masses share the edge). */
+  components: z41.array(ComponentHandle),
   /** A representative point on the edge (its head endpoint). Diagnostic only. */
   snapPoint: Vec3Handle
 });
-var PluginDesignListErasableEdgesArgs = z36.object({
-  components: z36.array(ComponentHandle).optional(),
-  strategies: z36.array(EraseStrategy).optional()
+var PluginDesignListErasableEdgesArgs = z41.object({
+  components: z41.array(ComponentHandle).optional(),
+  strategies: z41.array(EraseStrategy).optional()
 });
-var PluginDesignEraseEdgeArgs = z36.object({
+var PluginDesignEraseEdgeArgs = z41.object({
   edge: ErasableEdgeRef
 });
-var PluginDesignEraseEdgeResult = z36.object({ ok: z36.literal(true) });
+var PluginDesignEraseEdgeResult = z41.object({ ok: z41.literal(true) });
 var PluginDesignEraseApi = class {
   constructor() {
   }
 };
 
 // src/api/design/delete/index.ts
-import * as z37 from "zod";
-var PluginDesignDeleteEntitiesArgs = z37.object({
-  components: z37.array(ComponentHandle).min(1)
+import * as z42 from "zod";
+var PluginDesignDeleteEntitiesArgs = z42.object({
+  components: z42.array(ComponentHandle).min(1)
 });
 var PluginDesignDeleteApi = class {
   constructor() {
@@ -1673,85 +1830,85 @@ var PluginDesignDeleteApi = class {
 };
 
 // src/api/design/shared.ts
-import * as z38 from "zod";
-var BooleanOutcome = z38.object({
-  created: z38.array(ComponentHandle),
-  deleted: z38.array(ComponentHandle)
+import * as z43 from "zod";
+var BooleanOutcome = z43.object({
+  created: z43.array(ComponentHandle),
+  deleted: z43.array(ComponentHandle)
 });
-var OffsetSplitOutcome = z38.object({
-  createdIds: z38.array(ComponentHandle),
-  deletedIds: z38.array(ComponentHandle),
-  offsetValue: z38.number()
+var OffsetSplitOutcome = z43.object({
+  createdIds: z43.array(ComponentHandle),
+  deletedIds: z43.array(ComponentHandle),
+  offsetValue: z43.number()
 });
 
 // src/api/design/boolean/index.ts
-import * as z39 from "zod";
+import * as z44 from "zod";
 var PluginDesignBooleanApi = class {
   constructor() {
   }
 };
-var BooleanOptions = z39.object({
+var BooleanOptions = z44.object({
   offset: Vec3Handle.optional()
 });
-var PluginDesignBooleanUnionArgs = z39.object({
-  components: z39.array(ComponentHandle).min(2),
+var PluginDesignBooleanUnionArgs = z44.object({
+  components: z44.array(ComponentHandle).min(2),
   options: BooleanOptions.optional()
 });
-var PluginDesignBooleanSubtractArgs = z39.object({
+var PluginDesignBooleanSubtractArgs = z44.object({
   target: ComponentHandle,
-  tools: z39.array(ComponentHandle).min(1),
+  tools: z44.array(ComponentHandle).min(1),
   options: BooleanOptions.optional()
 });
-var PluginDesignBooleanIntersectArgs = z39.object({
-  components: z39.array(ComponentHandle).length(2),
+var PluginDesignBooleanIntersectArgs = z44.object({
+  components: z44.array(ComponentHandle).length(2),
   options: BooleanOptions.optional()
 });
 
 // src/api/design/transform/index.ts
-import * as z40 from "zod";
+import * as z45 from "zod";
 var PluginDesignTransformApi = class {
   constructor() {
   }
 };
-var PluginDesignMoveArgs = z40.object({
-  components: z40.array(ComponentHandle).min(1),
+var PluginDesignMoveArgs = z45.object({
+  components: z45.array(ComponentHandle).min(1),
   displacement: Vec3Handle,
-  is2D: z40.boolean().optional(),
-  trackParentChange: z40.boolean().optional()
+  is2D: z45.boolean().optional(),
+  trackParentChange: z45.boolean().optional()
 });
-var PluginDesignRotateArgs = z40.object({
-  components: z40.array(ComponentHandle).min(1),
-  angleInDegrees: z40.number(),
+var PluginDesignRotateArgs = z45.object({
+  components: z45.array(ComponentHandle).min(1),
+  angleInDegrees: z45.number(),
   axis: Vec3Handle.optional(),
-  is2D: z40.boolean().optional()
+  is2D: z45.boolean().optional()
 });
 
 // src/api/design/edit/index.ts
-import * as z41 from "zod";
+import * as z46 from "zod";
 var PluginDesignEditApi = class {
   constructor() {
   }
 };
-var PluginDesignOffsetSplitArgs = z41.object({
+var PluginDesignOffsetSplitArgs = z46.object({
   component: ComponentHandle,
-  offsetDistance: z41.number(),
+  offsetDistance: z46.number(),
   profilePickPoint: Vec3Handle.optional()
 });
 
 // src/api/design/update/index.ts
-import * as z42 from "zod";
-var PluginSpacePropertyUpdates = z42.object({
-  room_type: z42.string().optional(),
+import * as z47 from "zod";
+var PluginSpacePropertyUpdates = z47.object({
+  room_type: z47.string().optional(),
   massType: PluginMassType.optional(),
   spaceType: PluginSpaceType.optional(),
   areaClass: PluginAreaClass.optional(),
   departmentId: PluginDepartmentId.optional()
 });
-var PluginSpaceGeometryUpdate = z42.object({
+var PluginSpaceGeometryUpdate = z47.object({
   profile: ProfileHandle,
-  extrudeHeight: z42.number()
+  extrudeHeight: z47.number()
 });
-var PluginUpdateSpaceItem = z42.object({
+var PluginUpdateSpaceItem = z47.object({
   space: ComponentHandle,
   properties: PluginSpacePropertyUpdates.optional(),
   geometry: PluginSpaceGeometryUpdate.optional()
@@ -1768,37 +1925,37 @@ var PluginDesignApi = class {
 };
 
 // src/api/entity/buildableEnvelope.ts
-import * as z43 from "zod";
+import * as z48 from "zod";
 var PluginBuildableEnvelopeApi = class {
   constructor() {
   }
 };
-var PluginBuildableEnvelopePolygonVertex = z43.union([
-  z43.object({ x: z43.number().finite(), z: z43.number().finite() }).strict(),
-  z43.tuple([z43.number().finite(), z43.number().finite()])
+var PluginBuildableEnvelopePolygonVertex = z48.union([
+  z48.object({ x: z48.number().finite(), z: z48.number().finite() }).strict(),
+  z48.tuple([z48.number().finite(), z48.number().finite()])
 ]);
-var PluginBuildableEnvelopeVerticalCap = z43.discriminatedUnion("kind", [
-  z43.object({
-    kind: z43.literal("max_height"),
-    maxHeight: z43.number().finite().positive()
+var PluginBuildableEnvelopeVerticalCap = z48.discriminatedUnion("kind", [
+  z48.object({
+    kind: z48.literal("max_height"),
+    maxHeight: z48.number().finite().positive()
   }).strict(),
-  z43.object({
-    kind: z43.literal("max_floors"),
-    maxFloors: z43.number().finite().int().positive()
+  z48.object({
+    kind: z48.literal("max_floors"),
+    maxFloors: z48.number().finite().int().positive()
   }).strict()
 ]);
-var PluginBuildableEnvelopeSetbackTier = z43.object({
-  aboveHeight: z43.number().finite().nonnegative(),
-  front: z43.number().finite().nonnegative(),
-  side: z43.number().finite().nonnegative(),
-  rear: z43.number().finite().nonnegative()
+var PluginBuildableEnvelopeSetbackTier = z48.object({
+  aboveHeight: z48.number().finite().nonnegative(),
+  front: z48.number().finite().nonnegative(),
+  side: z48.number().finite().nonnegative(),
+  rear: z48.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: z43.ZodIssueCode.custom,
+      code: z48.ZodIssueCode.custom,
       path: ["setbacks", 0, "aboveHeight"],
       message: "Ground tier required: setbacks[0].aboveHeight must be 0."
     });
@@ -1806,75 +1963,75 @@ function refineSetbackTiers(args, ctx) {
   for (let i = 1; i < tiers.length; i++) {
     if (!(tiers[i].aboveHeight > tiers[i - 1].aboveHeight)) {
       ctx.addIssue({
-        code: z43.ZodIssueCode.custom,
+        code: z48.ZodIssueCode.custom,
         path: ["setbacks", i, "aboveHeight"],
         message: "Setback tiers must be ordered by strictly increasing aboveHeight."
       });
     }
   }
 }
-var PluginBuildableEnvelopeCreateArgs = z43.object({
-  sitePolygon: z43.array(PluginBuildableEnvelopePolygonVertex).min(3),
-  lengthUnit: z43.union([z43.literal("ft"), z43.literal("m")]),
-  setbacks: z43.array(PluginBuildableEnvelopeSetbackTier).min(1),
+var PluginBuildableEnvelopeCreateArgs = z48.object({
+  sitePolygon: z48.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z48.union([z48.literal("ft"), z48.literal("m")]),
+  setbacks: z48.array(PluginBuildableEnvelopeSetbackTier).min(1),
   verticalCap: PluginBuildableEnvelopeVerticalCap,
-  floorToFloor: z43.number().finite().positive(),
-  farRatio: z43.number().finite().positive().optional(),
-  lotCoverageMaxPct: z43.number().finite().min(0).max(100).optional()
+  floorToFloor: z48.number().finite().positive(),
+  farRatio: z48.number().finite().positive().optional(),
+  lotCoverageMaxPct: z48.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeCreateResult = z43.object({
-  buildableEnvelopeId: z43.string().min(1)
+var PluginBuildableEnvelopeCreateResult = z48.object({
+  buildableEnvelopeId: z48.string().min(1)
 }).strict();
-var PluginBuildableEnvelopeUpdateArgs = z43.object({
-  buildableEnvelopeId: z43.string().min(1),
-  sitePolygon: z43.array(PluginBuildableEnvelopePolygonVertex).min(3),
-  lengthUnit: z43.union([z43.literal("ft"), z43.literal("m")]),
-  setbacks: z43.array(PluginBuildableEnvelopeSetbackTier).min(1),
+var PluginBuildableEnvelopeUpdateArgs = z48.object({
+  buildableEnvelopeId: z48.string().min(1),
+  sitePolygon: z48.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z48.union([z48.literal("ft"), z48.literal("m")]),
+  setbacks: z48.array(PluginBuildableEnvelopeSetbackTier).min(1),
   verticalCap: PluginBuildableEnvelopeVerticalCap,
-  floorToFloor: z43.number().finite().positive(),
-  farRatio: z43.number().finite().positive().optional(),
-  lotCoverageMaxPct: z43.number().finite().min(0).max(100).optional()
+  floorToFloor: z48.number().finite().positive(),
+  farRatio: z48.number().finite().positive().optional(),
+  lotCoverageMaxPct: z48.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeUpdateResult = z43.object({
-  buildableEnvelopeId: z43.string().min(1)
+var PluginBuildableEnvelopeUpdateResult = z48.object({
+  buildableEnvelopeId: z48.string().min(1)
 }).strict();
 
 // src/api/entity/referenceLine.ts
-import * as z44 from "zod";
+import * as z49 from "zod";
 var PluginReferenceLineApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineCreateMultiArgs = z44.object({
+var PluginReferenceLineCreateMultiArgs = z49.object({
   profile: ProfileHandle
 });
-var PluginReferenceLineCreateMultiResult = z44.object({
-  referenceLineIds: z44.array(z44.string())
+var PluginReferenceLineCreateMultiResult = z49.object({
+  referenceLineIds: z49.array(z49.string())
 });
-var PluginReferenceLineGetProperty = z44.enum([
+var PluginReferenceLineGetProperty = z49.enum([
   "curve"
 ]);
-var PluginReferenceLineGetArgs = z44.object({
-  referenceLineId: z44.string(),
-  properties: z44.array(PluginReferenceLineGetProperty)
+var PluginReferenceLineGetArgs = z49.object({
+  referenceLineId: z49.string(),
+  properties: z49.array(PluginReferenceLineGetProperty)
 });
-var PluginReferenceLineGetResult = z44.object({
+var PluginReferenceLineGetResult = z49.object({
   curve: CurveHandle
 }).partial();
-var PluginReferenceLineGetAllResult = z44.object({
-  referenceLineIds: z44.array(z44.string())
+var PluginReferenceLineGetAllResult = z49.object({
+  referenceLineIds: z49.array(z49.string())
 });
-var PluginReferenceLineDeleteArgs = z44.object({
-  referenceLineId: z44.string()
+var PluginReferenceLineDeleteArgs = z49.object({
+  referenceLineId: z49.string()
 });
 
 // src/api/entity/story.ts
-import * as z45 from "zod";
+import * as z50 from "zod";
 var PluginStoryApi = class {
   constructor() {
   }
 };
-var PluginStoryGetProperty = z45.enum([
+var PluginStoryGetProperty = z50.enum([
   "value",
   "id",
   "name",
@@ -1884,44 +2041,44 @@ var PluginStoryGetProperty = z45.enum([
   "spacesCount",
   "totalArea"
 ]);
-var PluginStoryGetArgs = z45.object({
-  storyValue: z45.number().int(),
-  properties: z45.array(PluginStoryGetProperty)
-});
-var PluginStoryGetResult = z45.object({
-  value: z45.number(),
-  id: z45.string(),
-  name: z45.string(),
-  height: z45.number(),
-  base: z45.number(),
-  hidden: z45.boolean(),
-  spacesCount: z45.number(),
-  totalArea: z45.number()
+var PluginStoryGetArgs = z50.object({
+  storyValue: z50.number().int(),
+  properties: z50.array(PluginStoryGetProperty)
+});
+var PluginStoryGetResult = z50.object({
+  value: z50.number(),
+  id: z50.string(),
+  name: z50.string(),
+  height: z50.number(),
+  base: z50.number(),
+  hidden: z50.boolean(),
+  spacesCount: z50.number(),
+  totalArea: z50.number()
 }).partial();
-var PluginStoryGetAllResult = z45.object({
-  stories: z45.array(
-    z45.object({
-      value: z45.number(),
-      id: z45.string(),
-      name: z45.string()
+var PluginStoryGetAllResult = z50.object({
+  stories: z50.array(
+    z50.object({
+      value: z50.number(),
+      id: z50.string(),
+      name: z50.string()
     })
   )
 });
-var PluginStoryCreateArgs = z45.object({
-  storyValue: z45.number().int(),
-  height: z45.number().optional()
+var PluginStoryCreateArgs = z50.object({
+  storyValue: z50.number().int(),
+  height: z50.number().optional()
 });
-var PluginStoryCreateResult = z45.object({
-  storyId: z45.string(),
-  storyValue: z45.number()
+var PluginStoryCreateResult = z50.object({
+  storyId: z50.string(),
+  storyValue: z50.number()
 });
-var PluginStoryUpdateArgs = z45.object({
-  storyValue: z45.number().int(),
-  height: z45.number()
+var PluginStoryUpdateArgs = z50.object({
+  storyValue: z50.number().int(),
+  height: z50.number()
 });
-var PluginStoryUpdateResult = z45.object({
-  storyValue: z45.number(),
-  height: z45.number()
+var PluginStoryUpdateResult = z50.object({
+  storyValue: z50.number(),
+  height: z50.number()
 });
 
 // src/api/entity/index.ts
@@ -1931,27 +2088,27 @@ var PluginEntityApi = class {
 };
 
 // src/api/program/departments.ts
-import * as z47 from "zod";
+import * as z52 from "zod";
 
 // src/api/program/metrics.ts
-import * as z46 from "zod";
+import * as z51 from "zod";
 var PluginProgramMetricsApi = class {
   constructor() {
   }
 };
-var PluginAreaUnit = z46.enum(["ft2", "m2"]);
-var PluginProgramDepartmentMetric = z46.object({
-  departmentId: z46.string(),
-  name: z46.string(),
-  targetArea: z46.number().nullable(),
-  allocatedArea: z46.number()
+var PluginAreaUnit = z51.enum(["ft2", "m2"]);
+var PluginProgramDepartmentMetric = z51.object({
+  departmentId: z51.string(),
+  name: z51.string(),
+  targetArea: z51.number().nullable(),
+  allocatedArea: z51.number()
 });
-var PluginProgramMetricsSummary = z46.object({
+var PluginProgramMetricsSummary = z51.object({
   units: PluginAreaUnit,
-  totalTargetArea: z46.number(),
-  totalAllocatedArea: z46.number(),
-  unassignedArea: z46.number(),
-  departments: z46.array(PluginProgramDepartmentMetric)
+  totalTargetArea: z51.number(),
+  totalAllocatedArea: z51.number(),
+  unassignedArea: z51.number(),
+  departments: z51.array(PluginProgramDepartmentMetric)
 }).refine(
   (s) => {
     const summed = s.unassignedArea + s.departments.reduce((acc, d) => acc + d.allocatedArea, 0);
@@ -1968,18 +2125,18 @@ var PluginProgramDepartmentsApi = class {
   constructor() {
   }
 };
-var PluginProgramDepartment = z47.object({
-  id: z47.string(),
-  name: z47.string(),
-  color: z47.string(),
-  targetArea: z47.number().nullable()
+var PluginProgramDepartment = z52.object({
+  id: z52.string(),
+  name: z52.string(),
+  color: z52.string(),
+  targetArea: z52.number().nullable()
 });
-var PluginProgramDepartmentsListResult = z47.object({
+var PluginProgramDepartmentsListResult = z52.object({
   units: PluginAreaUnit,
-  departments: z47.array(PluginProgramDepartment)
+  departments: z52.array(PluginProgramDepartment)
 });
-var PluginProgramDepartmentsGetArgs = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsGetArgs = z52.object({
+  departmentId: z52.string()
 });
 var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
   {
@@ -1989,81 +2146,81 @@ var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
 var PluginProgramDepartmentRecord = PluginProgramDepartment.extend({
   units: PluginAreaUnit
 });
-var PluginProgramDepartmentsCreateArgs = z47.object({
-  name: z47.string(),
-  color: z47.string()
+var PluginProgramDepartmentsCreateArgs = z52.object({
+  name: z52.string(),
+  color: z52.string()
 });
-var PluginProgramDepartmentsCreateResult = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsCreateResult = z52.object({
+  departmentId: z52.string()
 });
-var PluginProgramDepartmentsUpdateArgs = z47.object({
-  departmentId: z47.string(),
-  name: z47.string().optional(),
-  color: z47.string().optional()
+var PluginProgramDepartmentsUpdateArgs = z52.object({
+  departmentId: z52.string(),
+  name: z52.string().optional(),
+  color: z52.string().optional()
 });
 var PluginProgramDepartmentsUpdateResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsAssignArgs = z47.object({
-  departmentId: z47.string(),
-  spaceIds: z47.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsAssignArgs = z52.object({
+  departmentId: z52.string(),
+  spaceIds: z52.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsAssignResult = z47.object({
-  departmentId: z47.string(),
-  spaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsAssignResult = z52.object({
+  departmentId: z52.string(),
+  spaceIds: z52.array(ComponentHandle)
 });
-var PluginProgramDepartmentsUnassignArgs = z47.object({
-  spaceIds: z47.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsUnassignArgs = z52.object({
+  spaceIds: z52.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsUnassignResult = z47.object({
-  spaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsUnassignResult = z52.object({
+  spaceIds: z52.array(ComponentHandle)
 });
-var PluginProgramDepartmentsSetTargetAreaArgs = z47.object({
-  departmentId: z47.string(),
-  targetArea: z47.number(),
+var PluginProgramDepartmentsSetTargetAreaArgs = z52.object({
+  departmentId: z52.string(),
+  targetArea: z52.number(),
   units: PluginAreaUnit.optional()
 });
 var PluginProgramDepartmentsSetTargetAreaResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsDeleteArgs = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsDeleteArgs = z52.object({
+  departmentId: z52.string()
 });
-var PluginProgramDepartmentsDeleteResult = z47.object({
-  departmentId: z47.string(),
-  reassignedSpaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsDeleteResult = z52.object({
+  departmentId: z52.string(),
+  reassignedSpaceIds: z52.array(ComponentHandle)
 });
 
 // src/api/program/adjacency.ts
-import * as z48 from "zod";
+import * as z53 from "zod";
 var PluginProgramAdjacencyApi = class {
   constructor() {
   }
 };
-var PluginAdjacencyLevel = z48.enum(["department", "space"]);
-var PluginProgramAdjacencyGetMatrixArgs = z48.object({
+var PluginAdjacencyLevel = z53.enum(["department", "space"]);
+var PluginProgramAdjacencyGetMatrixArgs = z53.object({
   level: PluginAdjacencyLevel,
-  ids: z48.array(z48.string()).optional()
+  ids: z53.array(z53.string()).optional()
 });
-var PluginProgramAdjacencyGetMatrixResult = z48.object({
-  ids: z48.array(z48.string()),
-  departmentIds: z48.array(z48.string().nullable()).optional(),
-  matrix: z48.array(z48.array(z48.number()))
+var PluginProgramAdjacencyGetMatrixResult = z53.object({
+  ids: z53.array(z53.string()),
+  departmentIds: z53.array(z53.string().nullable()).optional(),
+  matrix: z53.array(z53.array(z53.number()))
 });
-var PluginProgramAdjacencyComputeResult = z48.object({
-  success: z48.boolean(),
-  error: z48.string().optional()
+var PluginProgramAdjacencyComputeResult = z53.object({
+  success: z53.boolean(),
+  error: z53.string().optional()
 });
 
 // src/api/program/layout.ts
-import * as z49 from "zod";
+import * as z54 from "zod";
 var PluginProgramLayoutApi = class {
   constructor() {
   }
 };
-var PluginProgramLayoutRunResult = z49.object({
-  success: z49.boolean(),
-  error: z49.string().optional()
+var PluginProgramLayoutRunResult = z54.object({
+  success: z54.boolean(),
+  error: z54.string().optional()
 });
 
 // src/api/program/spreadsheet.ts
-import * as z50 from "zod";
+import * as z55 from "zod";
 var PluginProgramSpreadsheetApi = class {
   constructor() {
   }
@@ -2076,84 +2233,84 @@ var PluginProgramSpreadsheetBindingsApi = class {
   constructor() {
   }
 };
-var PluginSpreadsheetCell = z50.union([
-  z50.string(),
-  z50.number(),
-  z50.boolean(),
-  z50.null()
+var PluginSpreadsheetCell = z55.union([
+  z55.string(),
+  z55.number(),
+  z55.boolean(),
+  z55.null()
 ]);
-var PluginSpreadsheetAlign = z50.enum(["left", "center", "right"]);
-var PluginSpreadsheetColumn = z50.object({
-  key: z50.string(),
-  header: z50.string(),
-  width: z50.number().optional(),
-  format: z50.string().optional(),
+var PluginSpreadsheetAlign = z55.enum(["left", "center", "right"]);
+var PluginSpreadsheetColumn = z55.object({
+  key: z55.string(),
+  header: z55.string(),
+  width: z55.number().optional(),
+  format: z55.string().optional(),
   align: PluginSpreadsheetAlign.optional()
 });
-var PluginSpreadsheetTotal = z50.object({
-  column: z50.string(),
-  fn: z50.enum(["sum", "avg", "count", "min", "max"]),
-  label: z50.string().optional()
-});
-var PluginProgramSpreadsheetRenderArgs = z50.object({
-  sheetName: z50.string(),
-  columns: z50.array(PluginSpreadsheetColumn),
-  rows: z50.array(z50.record(z50.string(), PluginSpreadsheetCell)),
-  title: z50.string().optional(),
-  startCell: z50.string().optional(),
-  whenExists: z50.enum(["replace", "error"]).optional(),
-  asTable: z50.boolean().optional(),
-  freezeHeader: z50.boolean().optional(),
-  totals: z50.array(PluginSpreadsheetTotal).optional()
-});
-var PluginProgramSpreadsheetRenderResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
-  headerRange: z50.string(),
-  rowCount: z50.number(),
-  colCount: z50.number(),
-  tableName: z50.string().nullable(),
-  replaced: z50.boolean()
-});
-var PluginProgramSpreadsheetRenderDatasetArgs = z50.object({
-  sheetName: z50.string().optional(),
-  title: z50.string().optional(),
-  filter: z50.string().optional()
-});
-var PluginSpreadsheetExportFormat = z50.enum(["xlsx", "pdf", "csv"]);
-var PluginProgramSpreadsheetExportArgs = z50.object({
+var PluginSpreadsheetTotal = z55.object({
+  column: z55.string(),
+  fn: z55.enum(["sum", "avg", "count", "min", "max"]),
+  label: z55.string().optional()
+});
+var PluginProgramSpreadsheetRenderArgs = z55.object({
+  sheetName: z55.string(),
+  columns: z55.array(PluginSpreadsheetColumn),
+  rows: z55.array(z55.record(z55.string(), PluginSpreadsheetCell)),
+  title: z55.string().optional(),
+  startCell: z55.string().optional(),
+  whenExists: z55.enum(["replace", "error"]).optional(),
+  asTable: z55.boolean().optional(),
+  freezeHeader: z55.boolean().optional(),
+  totals: z55.array(PluginSpreadsheetTotal).optional()
+});
+var PluginProgramSpreadsheetRenderResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  headerRange: z55.string(),
+  rowCount: z55.number(),
+  colCount: z55.number(),
+  tableName: z55.string().nullable(),
+  replaced: z55.boolean()
+});
+var PluginProgramSpreadsheetRenderDatasetArgs = z55.object({
+  sheetName: z55.string().optional(),
+  title: z55.string().optional(),
+  filter: z55.string().optional()
+});
+var PluginSpreadsheetExportFormat = z55.enum(["xlsx", "pdf", "csv"]);
+var PluginProgramSpreadsheetExportArgs = z55.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z50.string().optional()
+  fileName: z55.string().optional()
 });
-var PluginProgramSpreadsheetExportResult = z50.object({
+var PluginProgramSpreadsheetExportResult = z55.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z50.string(),
-  mimeType: z50.string(),
-  dataBase64: z50.string()
+  fileName: z55.string(),
+  mimeType: z55.string(),
+  dataBase64: z55.string()
 });
-var PluginSpreadsheetSheetInfo = z50.object({
-  name: z50.string(),
-  index: z50.number(),
-  visible: z50.boolean(),
-  rowCount: z50.number(),
-  colCount: z50.number()
-});
-var PluginProgramSpreadsheetListSheetsResult = z50.object({
-  sheets: z50.array(PluginSpreadsheetSheetInfo),
-  activeSheet: z50.string().nullable()
-});
-var PluginProgramSpreadsheetGetSheetDataArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string().optional(),
-  header: z50.boolean().optional()
-});
-var PluginProgramSpreadsheetGetSheetDataResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
-  values: z50.array(z50.array(PluginSpreadsheetCell)),
-  records: z50.array(z50.record(z50.string(), PluginSpreadsheetCell)).optional()
-});
-var PluginSpreadsheetChartType = z50.enum([
+var PluginSpreadsheetSheetInfo = z55.object({
+  name: z55.string(),
+  index: z55.number(),
+  visible: z55.boolean(),
+  rowCount: z55.number(),
+  colCount: z55.number()
+});
+var PluginProgramSpreadsheetListSheetsResult = z55.object({
+  sheets: z55.array(PluginSpreadsheetSheetInfo),
+  activeSheet: z55.string().nullable()
+});
+var PluginProgramSpreadsheetGetSheetDataArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string().optional(),
+  header: z55.boolean().optional()
+});
+var PluginProgramSpreadsheetGetSheetDataResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  values: z55.array(z55.array(PluginSpreadsheetCell)),
+  records: z55.array(z55.record(z55.string(), PluginSpreadsheetCell)).optional()
+});
+var PluginSpreadsheetChartType = z55.enum([
   "column",
   "bar",
   "line",
@@ -2161,249 +2318,249 @@ var PluginSpreadsheetChartType = z50.enum([
   "area",
   "scatter"
 ]);
-var PluginProgramSpreadsheetAddChartArgs = z50.object({
-  sheetName: z50.string(),
+var PluginProgramSpreadsheetAddChartArgs = z55.object({
+  sheetName: z55.string(),
   chartType: PluginSpreadsheetChartType,
-  dataRange: z50.string(),
-  title: z50.string().optional(),
-  position: z50.object({ x: z50.number(), y: z50.number() }).optional(),
-  size: z50.object({ width: z50.number(), height: z50.number() }).optional()
-});
-var PluginProgramSpreadsheetAddChartResult = z50.object({
-  chartId: z50.string()
-});
-var PluginProgramSpreadsheetHighlightCellsArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
-  color: z50.string().optional(),
-  bold: z50.boolean().optional()
-});
-var PluginProgramSpreadsheetHighlightCellsResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string()
-});
-var PluginSpreadsheetProgramRow = z50.object({
-  departmentId: z50.string(),
-  name: z50.string(),
-  targetArea: z50.number().nullable(),
-  allocatedArea: z50.number(),
-  variance: z50.number().nullable()
+  dataRange: z55.string(),
+  title: z55.string().optional(),
+  position: z55.object({ x: z55.number(), y: z55.number() }).optional(),
+  size: z55.object({ width: z55.number(), height: z55.number() }).optional()
+});
+var PluginProgramSpreadsheetAddChartResult = z55.object({
+  chartId: z55.string()
+});
+var PluginProgramSpreadsheetHighlightCellsArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  color: z55.string().optional(),
+  bold: z55.boolean().optional()
+});
+var PluginProgramSpreadsheetHighlightCellsResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string()
+});
+var PluginSpreadsheetProgramRow = z55.object({
+  departmentId: z55.string(),
+  name: z55.string(),
+  targetArea: z55.number().nullable(),
+  allocatedArea: z55.number(),
+  variance: z55.number().nullable()
 });
-var PluginProgramSpreadsheetGetProgramResult = z50.object({
+var PluginProgramSpreadsheetGetProgramResult = z55.object({
   units: PluginAreaUnit,
-  rows: z50.array(PluginSpreadsheetProgramRow),
-  totalTargetArea: z50.number(),
-  totalAllocatedArea: z50.number(),
-  generatedAt: z50.string()
-});
-var PluginSpreadsheetTakeoffRow = z50.object({
-  objectType: z50.string(),
-  category: z50.string(),
-  family: z50.string(),
-  quantity: z50.number(),
-  unit: z50.string()
-});
-var PluginProgramSpreadsheetGetTakeoffResult = z50.object({
-  rows: z50.array(PluginSpreadsheetTakeoffRow),
-  rowCount: z50.number(),
-  generatedAt: z50.string()
-});
-var PluginSpreadsheetWhenExists = z50.enum(["reuse", "replace", "error"]);
-var PluginProgramSpreadsheetCreateSheetArgs = z50.object({
-  name: z50.string(),
+  rows: z55.array(PluginSpreadsheetProgramRow),
+  totalTargetArea: z55.number(),
+  totalAllocatedArea: z55.number(),
+  generatedAt: z55.string()
+});
+var PluginSpreadsheetTakeoffRow = z55.object({
+  objectType: z55.string(),
+  category: z55.string(),
+  family: z55.string(),
+  quantity: z55.number(),
+  unit: z55.string()
+});
+var PluginProgramSpreadsheetGetTakeoffResult = z55.object({
+  rows: z55.array(PluginSpreadsheetTakeoffRow),
+  rowCount: z55.number(),
+  generatedAt: z55.string()
+});
+var PluginSpreadsheetWhenExists = z55.enum(["reuse", "replace", "error"]);
+var PluginProgramSpreadsheetCreateSheetArgs = z55.object({
+  name: z55.string(),
   whenExists: PluginSpreadsheetWhenExists.optional()
 });
-var PluginProgramSpreadsheetCreateSheetResult = z50.object({
-  sheetName: z50.string(),
-  replaced: z50.boolean(),
-  sheetIndex: z50.number().nullable()
-});
-var PluginProgramSpreadsheetSetValuesArgs = z50.object({
-  sheetName: z50.string(),
-  values: z50.array(z50.array(PluginSpreadsheetCell)),
-  startCell: z50.string().optional()
-});
-var PluginProgramSpreadsheetSetValuesResult = z50.object({
-  sheetName: z50.string(),
-  startCell: z50.string(),
-  rowCount: z50.number(),
-  colCount: z50.number()
-});
-var PluginSpreadsheetFormula = z50.object({
-  cell: z50.string(),
-  formula: z50.string()
-});
-var PluginProgramSpreadsheetSetFormulasArgs = z50.object({
-  sheetName: z50.string(),
-  formulas: z50.array(PluginSpreadsheetFormula)
-});
-var PluginProgramSpreadsheetSetFormulasResult = z50.object({
-  sheetName: z50.string(),
-  count: z50.number()
-});
-var PluginSpreadsheetFontWeight = z50.enum(["normal", "bold"]);
-var PluginSpreadsheetFontStyle = z50.enum(["normal", "italic"]);
-var PluginSpreadsheetHorizontalAlign = z50.enum([
+var PluginProgramSpreadsheetCreateSheetResult = z55.object({
+  sheetName: z55.string(),
+  replaced: z55.boolean(),
+  sheetIndex: z55.number().nullable()
+});
+var PluginProgramSpreadsheetSetValuesArgs = z55.object({
+  sheetName: z55.string(),
+  values: z55.array(z55.array(PluginSpreadsheetCell)),
+  startCell: z55.string().optional()
+});
+var PluginProgramSpreadsheetSetValuesResult = z55.object({
+  sheetName: z55.string(),
+  startCell: z55.string(),
+  rowCount: z55.number(),
+  colCount: z55.number()
+});
+var PluginSpreadsheetFormula = z55.object({
+  cell: z55.string(),
+  formula: z55.string()
+});
+var PluginProgramSpreadsheetSetFormulasArgs = z55.object({
+  sheetName: z55.string(),
+  formulas: z55.array(PluginSpreadsheetFormula)
+});
+var PluginProgramSpreadsheetSetFormulasResult = z55.object({
+  sheetName: z55.string(),
+  count: z55.number()
+});
+var PluginSpreadsheetFontWeight = z55.enum(["normal", "bold"]);
+var PluginSpreadsheetFontStyle = z55.enum(["normal", "italic"]);
+var PluginSpreadsheetHorizontalAlign = z55.enum([
   "left",
   "center",
   "right",
   "general"
 ]);
-var PluginSpreadsheetVerticalAlign = z50.enum([
+var PluginSpreadsheetVerticalAlign = z55.enum([
   "top",
   "center",
   "bottom"
 ]);
-var PluginSpreadsheetCellStyle = z50.object({
-  backColor: z50.string().optional(),
-  foreColor: z50.string().optional(),
-  font: z50.string().optional(),
-  fontFamily: z50.string().optional(),
-  fontSize: z50.number().optional(),
+var PluginSpreadsheetCellStyle = z55.object({
+  backColor: z55.string().optional(),
+  foreColor: z55.string().optional(),
+  font: z55.string().optional(),
+  fontFamily: z55.string().optional(),
+  fontSize: z55.number().optional(),
   fontWeight: PluginSpreadsheetFontWeight.optional(),
   fontStyle: PluginSpreadsheetFontStyle.optional(),
-  formatter: z50.string().optional(),
+  formatter: z55.string().optional(),
   horizontalAlign: PluginSpreadsheetHorizontalAlign.optional(),
   verticalAlign: PluginSpreadsheetVerticalAlign.optional()
 });
-var PluginSpreadsheetRangeStyle = z50.object({
-  range: z50.string(),
+var PluginSpreadsheetRangeStyle = z55.object({
+  range: z55.string(),
   style: PluginSpreadsheetCellStyle
 });
-var PluginProgramSpreadsheetSetStylesArgs = z50.object({
-  sheetName: z50.string(),
-  ranges: z50.array(PluginSpreadsheetRangeStyle)
+var PluginProgramSpreadsheetSetStylesArgs = z55.object({
+  sheetName: z55.string(),
+  ranges: z55.array(PluginSpreadsheetRangeStyle)
 });
-var PluginProgramSpreadsheetSetStylesResult = z50.object({
-  sheetName: z50.string(),
-  count: z50.number()
+var PluginProgramSpreadsheetSetStylesResult = z55.object({
+  sheetName: z55.string(),
+  count: z55.number()
 });
-var PluginProgramSpreadsheetMergeCellsArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
+var PluginProgramSpreadsheetMergeCellsArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
   value: PluginSpreadsheetCell.optional()
 });
-var PluginProgramSpreadsheetMergeCellsResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string()
+var PluginProgramSpreadsheetMergeCellsResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string()
 });
-var PluginSpreadsheetConditionalRuleType = z50.enum(["dataBar"]);
-var PluginSpreadsheetConditionalRule = z50.object({
+var PluginSpreadsheetConditionalRuleType = z55.enum(["dataBar"]);
+var PluginSpreadsheetConditionalRule = z55.object({
   type: PluginSpreadsheetConditionalRuleType,
-  color: z50.string().optional()
+  color: z55.string().optional()
 });
-var PluginProgramSpreadsheetAddConditionalFormattingArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
+var PluginProgramSpreadsheetAddConditionalFormattingArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
   rule: PluginSpreadsheetConditionalRule
 });
-var PluginProgramSpreadsheetAddConditionalFormattingResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
-  created: z50.boolean()
+var PluginProgramSpreadsheetAddConditionalFormattingResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  created: z55.boolean()
 });
-var PluginProgramSpreadsheetRecalculateArgs = z50.object({
-  sheetName: z50.string().optional()
+var PluginProgramSpreadsheetRecalculateArgs = z55.object({
+  sheetName: z55.string().optional()
 });
-var PluginProgramSpreadsheetRecalculateResult = z50.object({
-  scope: z50.enum(["sheet", "workbook"]),
-  sheetName: z50.string().nullable()
+var PluginProgramSpreadsheetRecalculateResult = z55.object({
+  scope: z55.enum(["sheet", "workbook"]),
+  sheetName: z55.string().nullable()
 });
-var PluginSpreadsheetTransactionMethod = z50.enum([
+var PluginSpreadsheetTransactionMethod = z55.enum([
   "createSheet",
   "setValues",
   "setFormulas",
   "setStyles",
   "mergeCells"
 ]);
-var PluginSpreadsheetTransactionOp = z50.object({
+var PluginSpreadsheetTransactionOp = z55.object({
   method: PluginSpreadsheetTransactionMethod,
-  args: z50.unknown()
+  args: z55.unknown()
 });
-var PluginProgramSpreadsheetTransactionArgs = z50.object({
-  operations: z50.array(PluginSpreadsheetTransactionOp),
-  label: z50.string().optional()
+var PluginProgramSpreadsheetTransactionArgs = z55.object({
+  operations: z55.array(PluginSpreadsheetTransactionOp),
+  label: z55.string().optional()
 });
-var PluginProgramSpreadsheetTransactionResult = z50.object({
-  label: z50.string(),
-  operationCount: z50.number(),
-  results: z50.array(z50.unknown())
+var PluginProgramSpreadsheetTransactionResult = z55.object({
+  label: z55.string(),
+  operationCount: z55.number(),
+  results: z55.array(z55.unknown())
 });
-var PluginProgramSpreadsheetRunScriptArgs = z50.object({
-  script: z50.string()
+var PluginProgramSpreadsheetRunScriptArgs = z55.object({
+  script: z55.string()
 });
-var PluginProgramSpreadsheetRunScriptResult = z50.object({
-  result: z50.unknown()
+var PluginProgramSpreadsheetRunScriptResult = z55.object({
+  result: z55.unknown()
 });
-var PluginSpreadsheetAuditStatus = z50.enum(["success", "error"]);
-var PluginSpreadsheetAuditEntry = z50.object({
-  id: z50.string(),
-  pluginId: z50.string(),
-  method: z50.string(),
-  label: z50.string().optional(),
-  sheetName: z50.string().optional(),
-  timestamp: z50.string(),
+var PluginSpreadsheetAuditStatus = z55.enum(["success", "error"]);
+var PluginSpreadsheetAuditEntry = z55.object({
+  id: z55.string(),
+  pluginId: z55.string(),
+  method: z55.string(),
+  label: z55.string().optional(),
+  sheetName: z55.string().optional(),
+  timestamp: z55.string(),
   status: PluginSpreadsheetAuditStatus,
-  summary: z50.string().optional()
+  summary: z55.string().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogArgs = z50.object({
-  limit: z50.number().optional()
+var PluginProgramSpreadsheetGetAuditLogArgs = z55.object({
+  limit: z55.number().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogResult = z50.object({
-  entries: z50.array(PluginSpreadsheetAuditEntry)
+var PluginProgramSpreadsheetGetAuditLogResult = z55.object({
+  entries: z55.array(PluginSpreadsheetAuditEntry)
 });
-var PluginProgramSpreadsheetPingResult = z50.object({
-  pong: z50.boolean()
+var PluginProgramSpreadsheetPingResult = z55.object({
+  pong: z55.boolean()
 });
-var PluginSpreadsheetTemplateScope = z50.enum(["project", "global"]);
-var PluginProgramSpreadsheetTemplatesCreateArgs = z50.object({
-  name: z50.string(),
-  sheetName: z50.string(),
+var PluginSpreadsheetTemplateScope = z55.enum(["project", "global"]);
+var PluginProgramSpreadsheetTemplatesCreateArgs = z55.object({
+  name: z55.string(),
+  sheetName: z55.string(),
   scope: PluginSpreadsheetTemplateScope.optional()
 });
-var PluginProgramSpreadsheetTemplatesCreateResult = z50.object({
-  id: z50.string(),
-  name: z50.string(),
+var PluginProgramSpreadsheetTemplatesCreateResult = z55.object({
+  id: z55.string(),
+  name: z55.string(),
   scope: PluginSpreadsheetTemplateScope,
-  sheetName: z50.string()
+  sheetName: z55.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyArgs = z50.object({
-  name: z50.string(),
-  targetSheetName: z50.string()
+var PluginProgramSpreadsheetTemplatesApplyArgs = z55.object({
+  name: z55.string(),
+  targetSheetName: z55.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyResult = z50.object({
-  name: z50.string(),
-  targetSheetName: z50.string()
+var PluginProgramSpreadsheetTemplatesApplyResult = z55.object({
+  name: z55.string(),
+  targetSheetName: z55.string()
 });
-var PluginSpreadsheetBindingSource = z50.object({
-  dataset: z50.enum(["takeoff"])
+var PluginSpreadsheetBindingSource = z55.object({
+  dataset: z55.enum(["takeoff"])
 });
-var PluginSpreadsheetBindingMode = z50.enum(["replaceRange"]);
-var PluginSpreadsheetBindingTarget = z50.object({
-  sheetName: z50.string(),
-  startCell: z50.string().optional()
+var PluginSpreadsheetBindingMode = z55.enum(["replaceRange"]);
+var PluginSpreadsheetBindingTarget = z55.object({
+  sheetName: z55.string(),
+  startCell: z55.string().optional()
 });
-var PluginSpreadsheetBinding = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  pluginId: z50.string(),
+var PluginSpreadsheetBinding = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  pluginId: z55.string(),
   source: PluginSpreadsheetBindingSource,
-  target: z50.object({
-    sheetName: z50.string(),
-    startCell: z50.string()
+  target: z55.object({
+    sheetName: z55.string(),
+    startCell: z55.string()
   }),
   mode: PluginSpreadsheetBindingMode,
-  createdAt: z50.string(),
-  updatedAt: z50.string()
+  createdAt: z55.string(),
+  updatedAt: z55.string()
 });
-var PluginSpreadsheetBindingRefresh = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  sheetName: z50.string(),
-  rowCount: z50.number()
+var PluginSpreadsheetBindingRefresh = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  sheetName: z55.string(),
+  rowCount: z55.number()
 });
-var PluginProgramSpreadsheetBindingsCreateArgs = z50.object({
-  name: z50.string(),
+var PluginProgramSpreadsheetBindingsCreateArgs = z55.object({
+  name: z55.string(),
   source: PluginSpreadsheetBindingSource,
   target: PluginSpreadsheetBindingTarget,
   mode: PluginSpreadsheetBindingMode.optional()
@@ -2411,179 +2568,185 @@ var PluginProgramSpreadsheetBindingsCreateArgs = z50.object({
 var PluginProgramSpreadsheetBindingsCreateResult = PluginSpreadsheetBinding.extend({
   refresh: PluginSpreadsheetBindingRefresh
 });
-var PluginProgramSpreadsheetBindingsRefreshArgs = z50.object({
-  name: z50.string().optional()
+var PluginProgramSpreadsheetBindingsRefreshArgs = z55.object({
+  name: z55.string().optional()
 });
-var PluginProgramSpreadsheetBindingsRefreshResult = z50.object({
-  refreshed: z50.array(PluginSpreadsheetBindingRefresh)
+var PluginProgramSpreadsheetBindingsRefreshResult = z55.object({
+  refreshed: z55.array(PluginSpreadsheetBindingRefresh)
 });
-var PluginProgramSpreadsheetBindingsListResult = z50.object({
-  bindings: z50.array(PluginSpreadsheetBinding)
+var PluginProgramSpreadsheetBindingsListResult = z55.object({
+  bindings: z55.array(PluginSpreadsheetBinding)
 });
 
 // src/api/program/site.ts
-import * as z51 from "zod";
+import * as z56 from "zod";
 var PluginProgramSiteApi = class {
   constructor() {
   }
 };
-var PluginSiteFootprintPoint = z51.object({
-  x: z51.number(),
-  z: z51.number()
+var PluginSiteFootprintPoint = z56.object({
+  x: z56.number(),
+  z: z56.number()
 });
-var PluginSiteGeoPoint = z51.object({
-  lat: z51.number(),
-  lng: z51.number(),
-  alt: z51.number()
+var PluginSiteGeoPoint = z56.object({
+  lat: z56.number(),
+  lng: z56.number(),
+  alt: z56.number()
 });
-var PluginSitePolygon = z51.object({
-  id: z51.string(),
-  area: z51.number(),
-  label: z51.string(),
-  footprint: z51.array(PluginSiteFootprintPoint)
+var PluginSitePolygon = z56.object({
+  id: z56.string(),
+  area: z56.number(),
+  label: z56.string(),
+  footprint: z56.array(PluginSiteFootprintPoint)
 });
-var PluginProgramSiteSnapshot = z51.object({
+var PluginProgramSiteSnapshot = z56.object({
   units: PluginAreaUnit,
-  totalArea: z51.number(),
-  polygonCount: z51.number(),
-  polygons: z51.array(PluginSitePolygon)
+  totalArea: z56.number(),
+  polygonCount: z56.number(),
+  polygons: z56.array(PluginSitePolygon)
 });
-var PluginProgramSiteAreaResult = z51.object({
+var PluginProgramSiteAreaResult = z56.object({
   units: PluginAreaUnit,
-  area: z51.number()
+  area: z56.number()
 });
-var PluginProgramSiteListPolygonsResult = z51.object({
+var PluginProgramSiteListPolygonsResult = z56.object({
   units: PluginAreaUnit,
-  polygons: z51.array(PluginSitePolygon)
+  polygons: z56.array(PluginSitePolygon)
 });
-var PluginProgramSiteListGeoPolygonsResult = z51.object({
-  polygons: z51.array(z51.array(PluginSiteGeoPoint))
+var PluginProgramSiteListGeoPolygonsResult = z56.object({
+  polygons: z56.array(z56.array(PluginSiteGeoPoint))
 });
-var PluginSiteLatLng = z51.object({
-  lat: z51.number(),
-  lng: z51.number()
+var PluginSiteLatLng = z56.object({
+  lat: z56.number(),
+  lng: z56.number()
 });
-var PluginSiteBounds = z51.object({
-  north: z51.number(),
-  south: z51.number(),
-  east: z51.number(),
-  west: z51.number()
+var PluginSiteBounds = z56.object({
+  north: z56.number(),
+  south: z56.number(),
+  east: z56.number(),
+  west: z56.number()
 });
-var PluginSiteContextParcel = z51.object({
-  footprint: z51.array(PluginSiteLatLng),
-  area: z51.number()
+var PluginSiteContextParcel = z56.object({
+  footprint: z56.array(PluginSiteLatLng),
+  area: z56.number()
 });
-var PluginProgramSiteContext = z51.object({
+var PluginProgramSiteContext = z56.object({
   center: PluginSiteLatLng,
   bounds: PluginSiteBounds,
-  widthInM: z51.number(),
-  heightInM: z51.number(),
-  zoom: z51.number(),
-  parcels: z51.array(PluginSiteContextParcel)
+  widthInM: z56.number(),
+  heightInM: z56.number(),
+  zoom: z56.number(),
+  parcels: z56.array(PluginSiteContextParcel)
 });
 var PluginProgramSiteContextResult = PluginProgramSiteContext.nullable();
+var PluginProgramSiteLocation = z56.object({
+  latitude: z56.number(),
+  longitude: z56.number()
+});
+var PluginProgramSiteLocationResult = PluginProgramSiteLocation.nullable();
+var PluginProgramSiteNorthAngleResult = z56.number().nullable();
 
 // src/api/program/cores.ts
-import * as z52 from "zod";
+import * as z57 from "zod";
 var PluginProgramCoresApi = class {
   constructor() {
   }
 };
-var PluginProgramCore = z52.object({
-  id: z52.string(),
-  groupId: z52.string(),
-  storey: z52.number()
+var PluginProgramCore = z57.object({
+  id: z57.string(),
+  groupId: z57.string(),
+  storey: z57.number()
 });
-var PluginProgramCoresListResult = z52.object({
-  cores: z52.array(PluginProgramCore)
+var PluginProgramCoresListResult = z57.object({
+  cores: z57.array(PluginProgramCore)
 });
-var PluginProgramCoresIsCoreArgs = z52.object({
-  id: z52.string()
+var PluginProgramCoresIsCoreArgs = z57.object({
+  id: z57.string()
 });
-var PluginProgramCoreSpec = z52.object({
-  type: z52.string().optional(),
-  position: z52.object({ x: z52.number(), y: z52.number(), z: z52.number() }),
-  width: z52.number(),
-  depth: z52.number(),
-  fromStorey: z52.number().optional(),
-  toStorey: z52.number().optional()
+var PluginProgramCoreSpec = z57.object({
+  type: z57.string().optional(),
+  position: z57.object({ x: z57.number(), y: z57.number(), z: z57.number() }),
+  width: z57.number(),
+  depth: z57.number(),
+  fromStorey: z57.number().optional(),
+  toStorey: z57.number().optional()
 });
-var PluginProgramCoresCreateArgs = z52.object({
-  cores: z52.array(PluginProgramCoreSpec),
-  lengthUnit: z52.enum(["mm", "m", "ft"]).optional()
+var PluginProgramCoresCreateArgs = z57.object({
+  cores: z57.array(PluginProgramCoreSpec),
+  lengthUnit: z57.enum(["mm", "m", "ft"]).optional()
 });
-var PluginProgramCoresCreateResult = z52.object({
-  createdCount: z52.number()
+var PluginProgramCoresCreateResult = z57.object({
+  createdCount: z57.number()
 });
 
 // src/api/program/classification.ts
-import * as z53 from "zod";
+import * as z58 from "zod";
 var PluginProgramClassificationApi = class {
   constructor() {
   }
 };
-var PluginClassificationOption = z53.object({
-  value: z53.string(),
-  label: z53.string()
+var PluginClassificationOption = z58.object({
+  value: z58.string(),
+  label: z58.string()
 });
-var PluginProgramClassificationTypesResult = z53.object({
-  spaceTypes: z53.array(PluginClassificationOption),
-  areaClasses: z53.array(PluginClassificationOption),
-  massTypes: z53.array(PluginClassificationOption)
+var PluginProgramClassificationTypesResult = z58.object({
+  spaceTypes: z58.array(PluginClassificationOption),
+  areaClasses: z58.array(PluginClassificationOption),
+  massTypes: z58.array(PluginClassificationOption)
 });
-var PluginProgramClassificationListTagsArgs = z53.object({
-  id: z53.string()
+var PluginProgramClassificationListTagsArgs = z58.object({
+  id: z58.string()
 });
-var PluginSpaceTag = z53.object({
-  tagId: z53.string(),
-  tagName: z53.string(),
-  color: z53.string(),
-  categoryId: z53.string()
+var PluginSpaceTag = z58.object({
+  tagId: z58.string(),
+  tagName: z58.string(),
+  color: z58.string(),
+  categoryId: z58.string()
 });
-var PluginProgramClassificationTagsResult = z53.object({
-  tagIds: z53.array(z53.string()),
-  tagsByCategory: z53.record(z53.string(), PluginSpaceTag)
+var PluginProgramClassificationTagsResult = z58.object({
+  tagIds: z58.array(z58.string()),
+  tagsByCategory: z58.record(z58.string(), PluginSpaceTag)
 });
 
 // src/api/program/areas.ts
-import * as z54 from "zod";
+import * as z59 from "zod";
 var PluginProgramAreasApi = class {
   constructor() {
   }
 };
-var PluginProgramAreaSummary = z54.object({
-  count: z54.number().int(),
-  hiddenCount: z54.number().int(),
-  carpet: z54.number(),
-  builtUp: z54.number(),
-  excluded: z54.number(),
-  farBuiltUp: z54.number(),
-  siteArea: z54.number(),
-  achievedFar: z54.number().nullable(),
-  targetFar: z54.number(),
-  deviation: z54.number(),
+var PluginProgramAreaSummary = z59.object({
+  count: z59.number().int(),
+  hiddenCount: z59.number().int(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  farBuiltUp: z59.number(),
+  siteArea: z59.number(),
+  achievedFar: z59.number().nullable(),
+  targetFar: z59.number(),
+  deviation: z59.number(),
   areaUnit: PluginAreaUnit
 });
-var PluginProgramAreaGroup = z54.object({
-  groupId: z54.string(),
-  name: z54.string(),
-  color: z54.string(),
-  carpet: z54.number(),
-  builtUp: z54.number(),
-  excluded: z54.number(),
-  count: z54.number().int(),
-  targetArea: z54.number(),
+var PluginProgramAreaGroup = z59.object({
+  groupId: z59.string(),
+  name: z59.string(),
+  color: z59.string(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  count: z59.number().int(),
+  targetArea: z59.number(),
   targetUnit: PluginAreaUnit
 });
-var PluginProgramAreaMember = z54.object({
+var PluginProgramAreaMember = z59.object({
   id: ComponentHandle,
-  label: z54.string(),
-  carpet: z54.number(),
-  builtUp: z54.number(),
-  excluded: z54.number(),
-  isVisible: z54.boolean()
+  label: z59.string(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  isVisible: z59.boolean()
 });
-var PluginProgramAreaGroupBy = z54.enum([
+var PluginProgramAreaGroupBy = z59.enum([
   "labels",
   "storeys",
   "buildings",
@@ -2591,29 +2754,29 @@ var PluginProgramAreaGroupBy = z54.enum([
   "tagCategories"
 ]);
 var PluginProgramAreasGetResult = PluginProgramAreaSummary;
-var PluginProgramAreasListArgs = z54.object({
+var PluginProgramAreasListArgs = z59.object({
   groupBy: PluginProgramAreaGroupBy,
-  categoryId: z54.string().optional()
+  categoryId: z59.string().optional()
 }).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
   message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginProgramAreasListResult = z54.object({
-  groups: z54.array(PluginProgramAreaGroup)
+var PluginProgramAreasListResult = z59.object({
+  groups: z59.array(PluginProgramAreaGroup)
 });
-var PluginProgramAreasListMembersArgs = z54.object({
+var PluginProgramAreasListMembersArgs = z59.object({
   groupBy: PluginProgramAreaGroupBy,
-  groupId: z54.string(),
-  categoryId: z54.string().optional()
+  groupId: z59.string(),
+  categoryId: z59.string().optional()
 }).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
   message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginProgramAreasListMembersResult = z54.object({
-  members: z54.array(PluginProgramAreaMember)
+var PluginProgramAreasListMembersResult = z59.object({
+  members: z59.array(PluginProgramAreaMember)
 });
-var PluginProgramAreasUpdateArgs = z54.object({
-  targetFar: z54.number().min(0).optional(),
-  siteArea: z54.number().positive().optional(),
-  deviation: z54.number().min(0).max(100).optional()
+var PluginProgramAreasUpdateArgs = z59.object({
+  targetFar: z59.number().min(0).optional(),
+  siteArea: z59.number().positive().optional(),
+  deviation: z59.number().min(0).max(100).optional()
 });
 var PluginProgramAreasUpdateResult = PluginProgramAreaSummary;
 
@@ -2624,257 +2787,257 @@ var PluginProgramApi = class {
 };
 
 // src/api/presentation/views.ts
-import * as z55 from "zod";
+import * as z60 from "zod";
 var PluginPresentationViewsApi = class {
   constructor() {
   }
 };
-var PluginPresentationViewType = z55.enum(["2d", "3d"]);
-var PluginPresentationView = z55.object({
-  id: z55.string(),
-  name: z55.string(),
+var PluginPresentationViewType = z60.enum(["2d", "3d"]);
+var PluginPresentationView = z60.object({
+  id: z60.string(),
+  name: z60.string(),
   type: PluginPresentationViewType,
-  isActive: z55.boolean()
+  isActive: z60.boolean()
 });
-var PluginPresentationViewsListResult = z55.object({
-  views: z55.array(PluginPresentationView)
+var PluginPresentationViewsListResult = z60.object({
+  views: z60.array(PluginPresentationView)
 });
-var PluginPresentationViewsGetArgs = z55.object({
-  id: z55.string()
+var PluginPresentationViewsGetArgs = z60.object({
+  id: z60.string()
 });
 var PluginPresentationViewsGetResult = PluginPresentationView.nullable();
-var PluginPresentationImageFormat = z55.enum(["png", "jpeg"]);
-var PluginPresentationViewsCaptureArgs = z55.object({
-  viewId: z55.string().optional(),
+var PluginPresentationImageFormat = z60.enum(["png", "jpeg"]);
+var PluginPresentationViewsCaptureArgs = z60.object({
+  viewId: z60.string().optional(),
   format: PluginPresentationImageFormat.optional(),
-  resolution: z55.string().optional()
+  resolution: z60.string().optional()
 });
-var PluginPresentationViewsCaptureResult = z55.object({
-  image: z55.string()
+var PluginPresentationViewsCaptureResult = z60.object({
+  image: z60.string()
 });
-var PluginPresentationViewsSetActiveArgs = z55.object({
-  id: z55.string()
+var PluginPresentationViewsSetActiveArgs = z60.object({
+  id: z60.string()
 });
-var PluginPresentationViewsSetActiveResult = z55.object({
-  id: z55.string()
+var PluginPresentationViewsSetActiveResult = z60.object({
+  id: z60.string()
 });
-var PluginPresentationViewsCreateArgs = z55.object({
-  name: z55.string().optional(),
-  kind: z55.enum(["view", "sitePlan"]).optional()
+var PluginPresentationViewsCreateArgs = z60.object({
+  name: z60.string().optional(),
+  kind: z60.enum(["view", "sitePlan"]).optional()
 });
 var PluginPresentationViewsCreateResult = PluginPresentationView;
 
 // src/api/presentation/sheets.ts
-import * as z56 from "zod";
+import * as z61 from "zod";
 var PluginPresentationSheetsApi = class {
   constructor() {
   }
 };
-var PluginPresentationSheet = z56.object({
-  id: z56.string(),
-  name: z56.string()
+var PluginPresentationSheet = z61.object({
+  id: z61.string(),
+  name: z61.string()
 });
-var PluginSheetPosition = z56.object({
-  x: z56.number(),
-  y: z56.number()
+var PluginSheetPosition = z61.object({
+  x: z61.number(),
+  y: z61.number()
 });
-var PluginPresentationSheetsListResult = z56.object({
-  sheets: z56.array(PluginPresentationSheet)
+var PluginPresentationSheetsListResult = z61.object({
+  sheets: z61.array(PluginPresentationSheet)
 });
-var PluginPresentationSheetsGetArgs = z56.object({
-  id: z56.string()
+var PluginPresentationSheetsGetArgs = z61.object({
+  id: z61.string()
 });
 var PluginPresentationSheetsGetResult = PluginPresentationSheet.nullable();
-var PluginPresentationSheetsCreateArgs = z56.object({
-  name: z56.string().optional()
+var PluginPresentationSheetsCreateArgs = z61.object({
+  name: z61.string().optional()
 });
-var PluginPresentationSheetsPlaceArgs = z56.object({
-  sheetId: z56.string(),
-  viewId: z56.string(),
+var PluginPresentationSheetsPlaceArgs = z61.object({
+  sheetId: z61.string(),
+  viewId: z61.string(),
   position: PluginSheetPosition.optional()
 });
-var PluginPresentationSheetsPlaceResult = z56.object({
-  shapeId: z56.string()
+var PluginPresentationSheetsPlaceResult = z61.object({
+  shapeId: z61.string()
 });
 
 // src/api/presentation/diagrams.ts
-import * as z57 from "zod";
+import * as z62 from "zod";
 var PluginPresentationDiagramsApi = class {
   constructor() {
   }
 };
-var PluginPresentationDiagramsPlaceArgs = z57.object({
-  sheetId: z57.string(),
-  urls: z57.array(z57.string()),
-  position: z57.object({ x: z57.number(), y: z57.number() }).optional()
+var PluginPresentationDiagramsPlaceArgs = z62.object({
+  sheetId: z62.string(),
+  urls: z62.array(z62.string()),
+  position: z62.object({ x: z62.number(), y: z62.number() }).optional()
 });
-var PluginPresentationDiagramsPlaceResult = z57.object({
-  shapeIds: z57.array(z57.string())
+var PluginPresentationDiagramsPlaceResult = z62.object({
+  shapeIds: z62.array(z62.string())
 });
 
 // src/api/presentation/import.ts
-import * as z58 from "zod";
+import * as z63 from "zod";
 var PluginPresentationImportApi = class {
   constructor() {
   }
 };
-var PluginPresentationImportArgs = z58.object({
-  url: z58.string().optional(),
-  dataUrl: z58.string().optional(),
-  position: z58.object({ x: z58.number(), y: z58.number() }).optional()
+var PluginPresentationImportArgs = z63.object({
+  url: z63.string().optional(),
+  dataUrl: z63.string().optional(),
+  position: z63.object({ x: z63.number(), y: z63.number() }).optional()
 }).refine((a) => Boolean(a.url) || Boolean(a.dataUrl), {
   message: "Provide a url or a dataUrl"
 });
-var PluginPresentationImportResult = z58.object({
-  shapeIds: z58.array(z58.string())
+var PluginPresentationImportResult = z63.object({
+  shapeIds: z63.array(z63.string())
 });
 
 // src/api/presentation/aiInspiration.ts
-import * as z59 from "zod";
-var JsonPrimitive = z59.union([z59.string(), z59.number(), z59.boolean(), z59.null()]);
-var JsonValue = z59.lazy(
-  () => z59.union([JsonPrimitive, z59.array(JsonValue), z59.record(z59.string(), JsonValue)])
+import * as z64 from "zod";
+var JsonPrimitive = z64.union([z64.string(), z64.number(), z64.boolean(), z64.null()]);
+var JsonValue = z64.lazy(
+  () => z64.union([JsonPrimitive, z64.array(JsonValue), z64.record(z64.string(), JsonValue)])
 );
-var PluginAIInspirationOutputKind = z59.enum([
+var PluginAIInspirationOutputKind = z64.enum([
   "source",
   "image",
   "video"
 ]);
-var PluginAIInspirationModelOutput = z59.enum(["image", "video"]);
-var PluginAIInspirationShapeKind = z59.enum(["image", "view", "video"]);
-var PluginAIInspirationVideoMode = z59.enum([
+var PluginAIInspirationModelOutput = z64.enum(["image", "video"]);
+var PluginAIInspirationShapeKind = z64.enum(["image", "view", "video"]);
+var PluginAIInspirationVideoMode = z64.enum([
   "animate",
   "references",
   "keyframes"
 ]);
-var PluginAIInspirationVideoMotion = z59.enum([
+var PluginAIInspirationVideoMotion = z64.enum([
   "auto",
   "slow-dolly",
   "subtle-orbit",
   "reveal"
 ]);
-var PluginAIInspirationVideoDuration = z59.enum(["4s", "6s", "8s"]);
-var PluginAIInspirationRegionHint = z59.object({
-  x: z59.number().finite(),
-  y: z59.number().finite(),
-  w: z59.number().finite().positive(),
-  h: z59.number().finite().positive()
-});
-var PluginAIInspirationPoint = z59.object({
-  x: z59.number().finite(),
-  y: z59.number().finite()
-});
-var PluginAIInspirationTextAnnotation = z59.object({
-  text: z59.string().min(1),
-  x: z59.number().finite().optional(),
-  y: z59.number().finite().optional()
-});
-var PluginAIInspirationSketchGuidance = z59.object({
-  visualShapeIds: z59.array(z59.string()).optional(),
-  textAnnotations: z59.array(PluginAIInspirationTextAnnotation).optional()
-});
-var PluginAIInspirationSiteOptions = z59.object({
-  includeSatellite: z59.boolean().optional(),
-  includeStreetView: z59.boolean().optional(),
-  includeAerial: z59.boolean().optional(),
-  aerialBearing: z59.number().finite().optional(),
-  aerialPitch: z59.number().finite().optional(),
-  selectedDiagramIds: z59.array(z59.string()).optional(),
-  location: z59.object({
-    lat: z59.number().finite(),
-    lng: z59.number().finite()
+var PluginAIInspirationVideoDuration = z64.enum(["4s", "6s", "8s"]);
+var PluginAIInspirationRegionHint = z64.object({
+  x: z64.number().finite(),
+  y: z64.number().finite(),
+  w: z64.number().finite().positive(),
+  h: z64.number().finite().positive()
+});
+var PluginAIInspirationPoint = z64.object({
+  x: z64.number().finite(),
+  y: z64.number().finite()
+});
+var PluginAIInspirationTextAnnotation = z64.object({
+  text: z64.string().min(1),
+  x: z64.number().finite().optional(),
+  y: z64.number().finite().optional()
+});
+var PluginAIInspirationSketchGuidance = z64.object({
+  visualShapeIds: z64.array(z64.string()).optional(),
+  textAnnotations: z64.array(PluginAIInspirationTextAnnotation).optional()
+});
+var PluginAIInspirationSiteOptions = z64.object({
+  includeSatellite: z64.boolean().optional(),
+  includeStreetView: z64.boolean().optional(),
+  includeAerial: z64.boolean().optional(),
+  aerialBearing: z64.number().finite().optional(),
+  aerialPitch: z64.number().finite().optional(),
+  selectedDiagramIds: z64.array(z64.string()).optional(),
+  location: z64.object({
+    lat: z64.number().finite(),
+    lng: z64.number().finite()
   }).optional()
 });
-var PluginAIInspirationAppliedPreset = z59.object({
-  source: z59.enum(["curated", "user"]),
-  presetId: z59.string().min(1),
-  name: z59.string().min(1),
-  savedPresetKind: z59.enum(["prompt", "style"]).optional(),
-  stylePrompt: z59.string().optional(),
-  modelId: z59.string().optional(),
-  referenceImages: z59.array(
-    z59.object({
-      url: z59.string().min(1),
-      label: z59.string().optional(),
-      weight: z59.number().finite().optional()
+var PluginAIInspirationAppliedPreset = z64.object({
+  source: z64.enum(["curated", "user"]),
+  presetId: z64.string().min(1),
+  name: z64.string().min(1),
+  savedPresetKind: z64.enum(["prompt", "style"]).optional(),
+  stylePrompt: z64.string().optional(),
+  modelId: z64.string().optional(),
+  referenceImages: z64.array(
+    z64.object({
+      url: z64.string().min(1),
+      label: z64.string().optional(),
+      weight: z64.number().finite().optional()
     })
   ).optional(),
-  siteDefaults: z59.object({
-    includeSatellite: z59.boolean().optional(),
-    includeStreetView: z59.boolean().optional(),
-    includeAerial: z59.boolean().optional()
+  siteDefaults: z64.object({
+    includeSatellite: z64.boolean().optional(),
+    includeStreetView: z64.boolean().optional(),
+    includeAerial: z64.boolean().optional()
   }).optional()
 });
-var PluginAIInspirationVideoOptions = z59.object({
+var PluginAIInspirationVideoOptions = z64.object({
   mode: PluginAIInspirationVideoMode.optional(),
-  endFrameShapeId: z59.string().optional(),
+  endFrameShapeId: z64.string().optional(),
   motion: PluginAIInspirationVideoMotion.optional(),
   duration: PluginAIInspirationVideoDuration.optional()
 });
-var PluginAIInspirationModel = z59.object({
-  id: z59.string(),
-  label: z59.string(),
-  supportsMultiImage: z59.boolean(),
+var PluginAIInspirationModel = z64.object({
+  id: z64.string(),
+  label: z64.string(),
+  supportsMultiImage: z64.boolean(),
   output: PluginAIInspirationModelOutput,
-  isDefault: z59.boolean().optional()
+  isDefault: z64.boolean().optional()
 });
-var PluginAIInspirationListModelsResult = z59.object({
-  defaultModelId: z59.string(),
-  models: z59.array(PluginAIInspirationModel)
+var PluginAIInspirationListModelsResult = z64.object({
+  defaultModelId: z64.string(),
+  models: z64.array(PluginAIInspirationModel)
 });
-var PluginAIInspirationShapeRef = z59.object({
-  shapeId: z59.string(),
-  assetId: z59.string().optional(),
+var PluginAIInspirationShapeRef = z64.object({
+  shapeId: z64.string(),
+  assetId: z64.string().optional(),
   kind: PluginAIInspirationShapeKind,
-  name: z59.string().optional(),
-  width: z59.number().finite().optional(),
-  height: z59.number().finite().optional(),
+  name: z64.string().optional(),
+  width: z64.number().finite().optional(),
+  height: z64.number().finite().optional(),
   outputType: PluginAIInspirationOutputKind.optional(),
-  sourceUrl: z59.string().optional()
+  sourceUrl: z64.string().optional()
 });
-var PluginAIInspirationListSourcesArgs = z59.object({
-  includeGenerated: z59.boolean().optional(),
-  includeSourceUrl: z59.boolean().optional()
+var PluginAIInspirationListSourcesArgs = z64.object({
+  includeGenerated: z64.boolean().optional(),
+  includeSourceUrl: z64.boolean().optional()
 });
-var PluginAIInspirationListSourcesResult = z59.object({
-  sources: z59.array(PluginAIInspirationShapeRef)
+var PluginAIInspirationListSourcesResult = z64.object({
+  sources: z64.array(PluginAIInspirationShapeRef)
 });
-var PluginAIInspirationOutput = z59.object({
-  outputType: z59.enum(["image", "video"]),
-  shapeId: z59.string(),
-  assetId: z59.string(),
-  outputUrl: z59.string().optional(),
+var PluginAIInspirationOutput = z64.object({
+  outputType: z64.enum(["image", "video"]),
+  shapeId: z64.string(),
+  assetId: z64.string(),
+  outputUrl: z64.string().optional(),
   position: PluginAIInspirationPoint.optional()
 });
-var PluginAIInspirationDebugSummary = z59.record(z59.string(), JsonValue);
-var PluginAIInspirationRunMetadata = z59.object({
-  geometryFidelity: z59.string().optional(),
+var PluginAIInspirationDebugSummary = z64.record(z64.string(), JsonValue);
+var PluginAIInspirationRunMetadata = z64.object({
+  geometryFidelity: z64.string().optional(),
   debugSummary: PluginAIInspirationDebugSummary.optional(),
-  streetViewComposite: z59.object({
-    used: z59.boolean(),
-    renderMode: z59.enum(["prompt_refs_default", "masked_composite_pilot"]),
-    backgroundLabel: z59.string().optional()
+  streetViewComposite: z64.object({
+    used: z64.boolean(),
+    renderMode: z64.enum(["prompt_refs_default", "masked_composite_pilot"]),
+    backgroundLabel: z64.string().optional()
   }).optional()
 });
-var PluginAIInspirationGenerateArgs = z59.object({
-  sourceShapeId: z59.string().min(1),
-  prompt: z59.string().min(1).max(8e3),
-  modelId: z59.string().optional(),
-  referenceShapeIds: z59.array(z59.string()).max(12).optional(),
-  referenceStrength: z59.enum(["low", "medium", "high"]).optional(),
+var PluginAIInspirationGenerateArgs = z64.object({
+  sourceShapeId: z64.string().min(1),
+  prompt: z64.string().min(1).max(8e3),
+  modelId: z64.string().optional(),
+  referenceShapeIds: z64.array(z64.string()).max(12).optional(),
+  referenceStrength: z64.enum(["low", "medium", "high"]).optional(),
   appliedPreset: PluginAIInspirationAppliedPreset.optional(),
   site: PluginAIInspirationSiteOptions.optional(),
   regionHint: PluginAIInspirationRegionHint.optional(),
   sketchGuidance: PluginAIInspirationSketchGuidance.optional(),
   video: PluginAIInspirationVideoOptions.optional()
 });
-var PluginAIInspirationRunResult = z59.object({
-  outputs: z59.array(PluginAIInspirationOutput).min(1),
+var PluginAIInspirationRunResult = z64.object({
+  outputs: z64.array(PluginAIInspirationOutput).min(1),
   metadata: PluginAIInspirationRunMetadata.optional()
 });
-var PluginAIInspirationRefineArgs = z59.object({
-  sourceShapeId: z59.string().min(1),
-  upscaleFactor: z59.union([z59.literal(1.5), z59.literal(2), z59.literal(4)]).optional()
+var PluginAIInspirationRefineArgs = z64.object({
+  sourceShapeId: z64.string().min(1),
+  upscaleFactor: z64.union([z64.literal(1.5), z64.literal(2), z64.literal(4)]).optional()
 });
 var PluginPresentationAIInspirationApi = class {
   constructor() {
@@ -2887,6 +3050,85 @@ var PluginPresentationApi = class {
   }
 };
 
+// src/api/analysis/sunpath.ts
+var PluginAnalysisSunpathApi = class {
+  constructor() {
+  }
+};
+
+// src/api/analysis/shadows.ts
+import * as z65 from "zod";
+var PluginAnalysisShadowsApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisShadowsEnableOptions = z65.object({
+  dateTime: z65.string().optional()
+});
+var PluginAnalysisShadowsSetDateTimeArgs = z65.object({
+  dateTime: z65.string()
+});
+var PluginAnalysisShadowsDateTimeResult = z65.string();
+
+// src/api/analysis/sunlightHours.ts
+import * as z66 from "zod";
+var PluginAnalysisSunlightHoursApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisComputeResult = z66.object({
+  success: z66.boolean(),
+  error: z66.string().optional()
+});
+var PluginAnalysisJobStatus = z66.enum([
+  "running",
+  "active",
+  "inactive"
+]);
+var PluginAnalysisJobState = z66.object({
+  status: PluginAnalysisJobStatus,
+  startDate: z66.string(),
+  endDate: z66.string()
+});
+var PluginAnalysisJobStateResult = PluginAnalysisJobState.nullable();
+
+// src/api/analysis/illuminance.ts
+var PluginAnalysisIlluminanceApi = class {
+  constructor() {
+  }
+};
+
+// src/api/analysis/heatmaps.ts
+import * as z67 from "zod";
+var PluginAnalysisHeatmapsApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisHeatmapSpaceEntry = z67.object({
+  space: ComponentHandle,
+  value: z67.number().finite()
+});
+var PluginAnalysisHeatmapGridCell = z67.object({
+  position: Vec3Components,
+  value: z67.number().finite()
+});
+var PluginAnalysisHeatmapOptions = z67.object({
+  title: z67.string().optional(),
+  unit: z67.string().optional(),
+  min: z67.number().finite().optional(),
+  max: z67.number().finite().optional(),
+  colors: z67.array(z67.string().regex(/^#?[0-9a-fA-F]{6}$/, 'expected a 6-digit hex colour like "#0000ff"')).min(1).optional()
+});
+var PluginAnalysisHeatmapsRenderResult = z67.object({
+  success: z67.literal(true)
+});
+
+// src/api/analysis/index.ts
+var PluginAnalysisApi = class {
+  constructor() {
+  }
+};
+
 // src/api/index.ts
 var PluginApi = class {
   constructor() {
@@ -2898,6 +3140,7 @@ export {
   BooleanOptions,
   BooleanOutcome,
   BrepHandle,
+  CadJsonInput,
   CircleHandle,
   CommentHandle,
   ComponentHandle,
@@ -2909,9 +3152,13 @@ export {
   EraseStrategy,
   FaceHandle,
   HalfEdgeHandle,
+  ImportJobHandle,
+  ImportJobStatus,
+  ImportSource,
   LineHandle,
   MassHandle,
   MaterialHandle,
+  ModelFormat,
   OffsetSplitOutcome,
   PUnitType,
   PluginAIInspirationAppliedPreset,
@@ -2939,6 +3186,23 @@ export {
   PluginAIInspirationVideoMotion,
   PluginAIInspirationVideoOptions,
   PluginAdjacencyLevel,
+  PluginAnalysisApi,
+  PluginAnalysisComputeResult,
+  PluginAnalysisHeatmapGridCell,
+  PluginAnalysisHeatmapOptions,
+  PluginAnalysisHeatmapSpaceEntry,
+  PluginAnalysisHeatmapsApi,
+  PluginAnalysisHeatmapsRenderResult,
+  PluginAnalysisIlluminanceApi,
+  PluginAnalysisJobState,
+  PluginAnalysisJobStateResult,
+  PluginAnalysisJobStatus,
+  PluginAnalysisShadowsApi,
+  PluginAnalysisShadowsDateTimeResult,
+  PluginAnalysisShadowsEnableOptions,
+  PluginAnalysisShadowsSetDateTimeArgs,
+  PluginAnalysisSunlightHoursApi,
+  PluginAnalysisSunpathApi,
   PluginApi,
   PluginAreaClass,
   PluginAreaUnit,
@@ -2998,6 +3262,12 @@ export {
   PluginCoreGroupsListResult,
   PluginCoreGroupsUpdateArgs,
   PluginCoreGroupsUpdateResult,
+  PluginCoreIoApi,
+  PluginCoreIoImportApi,
+  PluginCoreIoJobApi,
+  PluginCoreIoQueryApi,
+  PluginCoreIoTerrainApi,
+  PluginCoreIoUnderlayApi,
   PluginCoreLayer,
   PluginCoreLayerType,
   PluginCoreLayersApi,
@@ -3301,6 +3571,13 @@ export {
   PluginHistoryApi,
   PluginHistoryStepArgs,
   PluginHistoryStepResult,
+  PluginImportCadJsonArgs,
+  PluginImportDwgArgs,
+  PluginImportImageArgs,
+  PluginImportJobArgs,
+  PluginImportModelArgs,
+  PluginImportPdfArgs,
+  PluginImportTerrainArgs,
   PluginMassType,
   PluginMaterialInfo,
   PluginMaterialResult,
@@ -3393,6 +3670,9 @@ export {
   PluginProgramSiteContextResult,
   PluginProgramSiteListGeoPolygonsResult,
   PluginProgramSiteListPolygonsResult,
+  PluginProgramSiteLocation,
+  PluginProgramSiteLocationResult,
+  PluginProgramSiteNorthAngleResult,
   PluginProgramSiteSnapshot,
   PluginProgramSpreadsheetAddChartArgs,
   PluginProgramSpreadsheetAddChartResult,
@@ -3444,6 +3724,8 @@ export {
   PluginProjectApi,
   PluginProjectSettingsApi,
   PluginQuatApi,
+  PluginQueryCadLayersArgs,
+  PluginQueryPdfPageCountArgs,
   PluginReferenceLineApi,
   PluginReferenceLineCreateMultiArgs,
   PluginReferenceLineCreateMultiResult,
@@ -3453,6 +3735,8 @@ export {
   PluginReferenceLineGetProperty,
   PluginReferenceLineGetResult,
   PluginReferenceLineStyle,
+  PluginSelectionEntityType,
+  PluginSelectionFilter,
   PluginSheetPosition,
   PluginSiteBounds,
   PluginSiteContextParcel,
@@ -3527,7 +3811,15 @@ export {
   PluginStoryGetResult,
   PluginStoryUpdateArgs,
   PluginStoryUpdateResult,
+  PluginTerrainSetDatumArgs,
+  PluginTerrainSetOpacityArgs,
   PluginToleranceArgs,
+  PluginUnderlayListArgs,
+  PluginUnderlayPlanSize,
+  PluginUnderlayRefArgs,
+  PluginUnderlaySetOpacityArgs,
+  PluginUnderlaySetScaleArgs,
+  PluginUnderlaySetScaleValue,
   PluginUnitsApi,
   PluginUnitsConvertArgs,
   PluginUnitsSetTypeArgs,
@@ -3539,6 +3831,9 @@ export {
   ProfileHandle,
   QuatComponents,
   QuatHandle,
+  TerrainHandle,
+  TerrainReport,
+  UnderlayHandle,
   Vec3Components,
   Vec3Handle,
   VertexHandle,