@snaptrude/plugin-core 0.5.0 → 0.7.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,189 @@ 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/proposals/index.ts
+import * as z30 from "zod";
+var PluginCoreProposalsApi = class {
+  constructor() {
+  }
+};
+var PluginCoreProposalRef = z30.object({
+  id: z30.string(),
+  name: z30.string(),
+  isActive: z30.boolean(),
+  defaultBucketId: z30.string(),
+  bucketIds: z30.array(z30.string()),
+  createdAt: z30.string(),
+  createdBy: z30.string()
+});
+var PluginCoreProposalsListResult = z30.object({
+  proposals: z30.array(PluginCoreProposalRef)
+});
+var PluginCoreProposalsGetArgs = z30.object({
+  proposalId: z30.string()
+});
+var PluginCoreProposalsGetResult = PluginCoreProposalRef.nullable();
+var PluginCoreProposalsGetActiveResult = PluginCoreProposalRef.nullable();
+var PluginCoreProposalsListForComponentArgs = z30.object({
+  component: ComponentHandle
+});
+var PluginCoreProposalsListForComponentResult = PluginCoreProposalsListResult;
+var PluginCoreProposalsIsActiveArgs = PluginCoreProposalsGetArgs;
+var PluginCoreProposalsCreateArgs = z30.object({
+  name: z30.string()
+});
+var PluginCoreProposalsCreateResult = z30.object({
+  id: z30.string()
+});
+var PluginCoreProposalsRenameArgs = z30.object({
+  proposalId: z30.string(),
+  name: z30.string()
+});
+var PluginCoreProposalsRenameResult = PluginCoreProposalRef;
+var PluginCoreProposalsSetActiveArgs = z30.object({
+  proposalId: z30.string()
+});
+var PluginCoreProposalsSetActiveResult = z30.object({
+  id: z30.string()
+});
+var PluginCoreProposalsDeleteArgs = z30.object({
+  proposalId: z30.string(),
+  deleteObjects: z30.boolean().optional(),
+  targetProposalId: z30.string().optional()
+}).refine((v) => v.deleteObjects === true !== (v.targetProposalId != null), {
+  message: "Provide exactly one disposition: deleteObjects: true (destroy exclusive-bucket geometry) or targetProposalId (transfer buckets, then delete)"
+}).refine(
+  (v) => v.targetProposalId == null || v.targetProposalId !== v.proposalId,
+  {
+    message: "targetProposalId must be a different proposal than proposalId"
+  }
+);
+var PluginCoreProposalsDeleteResult = z30.object({
+  deleted: z30.literal(true)
+});
+
 // src/api/core/index.ts
 var PluginCoreApi = class {
   constructor() {
@@ -1047,39 +1233,39 @@ var PluginCoreApi = class {
 };
 
 // src/api/design/create/index.ts
-import * as z26 from "zod";
+import * as z32 from "zod";
 
 // src/api/entity/space.ts
-import * as z25 from "zod";
-var PluginSpaceCreateRectangularArgs = z25.object({
+import * as z31 from "zod";
+var PluginSpaceCreateRectangularArgs = z31.object({
   position: Vec3Handle,
-  dimensions: z25.object({
-    width: z25.number(),
-    height: z25.number(),
-    depth: z25.number()
+  dimensions: z31.object({
+    width: z31.number(),
+    height: z31.number(),
+    depth: z31.number()
   })
 });
-var PluginSpaceCreateRectangularResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceCreateRectangularResult = z31.object({
+  spaceId: z31.string()
 });
-var PluginSpaceCreateFromProfileArgs = z25.object({
+var PluginSpaceCreateFromProfileArgs = z31.object({
   profile: ProfileHandle,
-  innerProfiles: z25.array(ProfileHandle).optional(),
-  extrudeHeight: z25.number(),
+  innerProfiles: z31.array(ProfileHandle).optional(),
+  extrudeHeight: z31.number(),
   position: Vec3Handle
 });
-var PluginSpaceCreateFromProfileResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceCreateFromProfileResult = z31.object({
+  spaceId: z31.string()
 });
-var PluginSpaceUpdateGeometryFromProfileArgs = z25.object({
-  spaceId: z25.string(),
+var PluginSpaceUpdateGeometryFromProfileArgs = z31.object({
+  spaceId: z31.string(),
   profile: ProfileHandle,
-  extrudeHeight: z25.number()
+  extrudeHeight: z31.number()
 });
-var PluginSpaceUpdateGeometryFromProfileResult = z25.object({
-  spaceId: z25.string()
+var PluginSpaceUpdateGeometryFromProfileResult = z31.object({
+  spaceId: z31.string()
 });
-var PluginSpaceGetProperty = z25.enum([
+var PluginSpaceGetProperty = z31.enum([
   // Basic
   "id",
   "type",
@@ -1110,11 +1296,11 @@ var PluginSpaceGetProperty = z25.enum([
   // Derived from adjacency manager
   "adjacency"
 ]);
-var PluginSpaceGetArgs = z25.object({
-  spaceId: z25.string(),
-  properties: z25.array(PluginSpaceGetProperty)
+var PluginSpaceGetArgs = z31.object({
+  spaceId: z31.string(),
+  properties: z31.array(PluginSpaceGetProperty)
 });
-var PluginSpaceType = z25.enum([
+var PluginSpaceType = z31.enum([
   "Room",
   "Program Block",
   "Balcony",
@@ -1126,51 +1312,51 @@ var PluginSpaceType = z25.enum([
   "Envelope",
   "Parking"
 ]);
-var PluginAreaClass = z25.enum(["NET", "GROSS", "EXCLUDED"]);
-var PluginSpaceGetResult = z25.object({
+var PluginAreaClass = z31.enum(["NET", "GROSS", "EXCLUDED"]);
+var PluginSpaceGetResult = z31.object({
   // Basic
-  id: z25.string(),
-  type: z25.string(),
-  room_type: z25.string(),
-  name: z25.string(),
+  id: z31.string(),
+  type: z31.string(),
+  room_type: z31.string(),
+  name: z31.string(),
   // Derived from parametric data
-  area: z25.number(),
-  breadth: z25.number(),
-  depth: z25.number(),
-  height: z25.number(),
-  massType: z25.string().nullable(),
+  area: z31.number(),
+  breadth: z31.number(),
+  depth: z31.number(),
+  height: z31.number(),
+  massType: z31.string().nullable(),
   spaceType: PluginSpaceType.nullable(),
   areaClass: PluginAreaClass,
-  storey: z25.number().nullable(),
-  departmentId: z25.string().nullable(),
-  departmentName: z25.string(),
-  departmentColor: z25.string(),
+  storey: z31.number().nullable(),
+  departmentId: z31.string().nullable(),
+  departmentName: z31.string(),
+  departmentColor: z31.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: z31.array(Vec3Components),
+  profile: z31.array(CurveHandle),
+  innerProfiles: z31.array(z31.array(CurveHandle)),
+  innerPlanPoints: z31.array(z31.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: z31.array(z31.object({
+    spaceId: z31.string(),
+    value: z31.number()
   }))
 }).partial();
-var PluginSpaceGetAllResult = z25.object({
-  spacesIds: z25.array(z25.string())
+var PluginSpaceGetAllResult = z31.object({
+  spacesIds: z31.array(z31.string())
 });
-var PluginSpaceDeleteArgs = z25.object({
-  spaceId: z25.string()
+var PluginSpaceDeleteArgs = z31.object({
+  spaceId: z31.string()
 });
-var PluginMassType = z25.enum([
+var PluginMassType = z31.enum([
   "Plinth",
   "Void",
   "Pergola",
@@ -1184,89 +1370,89 @@ var PluginMassType = z25.enum([
   "Mass",
   "Site"
 ]);
-var PluginWellKnownDepartmentId = z25.enum([
+var PluginWellKnownDepartmentId = z31.enum([
   "DEFAULT",
   "SITE",
   "ENVELOPE",
   "CORE"
 ]);
-var PluginDepartmentId = z25.union([
+var PluginDepartmentId = z31.union([
   PluginWellKnownDepartmentId,
-  z25.uuid()
+  z31.uuid()
 ]);
-var PluginSpaceUpdateArgs = z25.object({
-  spaceId: z25.string(),
-  properties: z25.object({
-    room_type: z25.string().optional(),
+var PluginSpaceUpdateArgs = z31.object({
+  spaceId: z31.string(),
+  properties: z31.object({
+    room_type: z31.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 = z31.object({
+  spaceId: z31.string(),
+  room_type: z31.string().optional(),
+  massType: z31.string().optional(),
+  spaceType: z31.string().optional(),
   areaClass: PluginAreaClass.optional(),
-  departmentId: z25.string().nullable().optional()
+  departmentId: z31.string().nullable().optional()
 });
-var PluginSpaceBulkCreateItem = z25.discriminatedUnion("kind", [
-  z25.object({
-    kind: z25.literal("rectangular"),
+var PluginSpaceBulkCreateItem = z31.discriminatedUnion("kind", [
+  z31.object({
+    kind: z31.literal("rectangular"),
     position: Vec3Handle,
-    dimensions: z25.object({
-      width: z25.number(),
-      height: z25.number(),
-      depth: z25.number()
+    dimensions: z31.object({
+      width: z31.number(),
+      height: z31.number(),
+      depth: z31.number()
     }),
-    room_type: z25.string().optional(),
+    room_type: z31.string().optional(),
     spaceType: PluginSpaceType.optional(),
     massType: PluginMassType.optional(),
     departmentId: PluginDepartmentId.optional()
   }),
-  z25.object({
-    kind: z25.literal("profile"),
+  z31.object({
+    kind: z31.literal("profile"),
     profile: ProfileHandle,
-    innerProfiles: z25.array(ProfileHandle).optional(),
-    extrudeHeight: z25.number(),
+    innerProfiles: z31.array(ProfileHandle).optional(),
+    extrudeHeight: z31.number(),
     position: Vec3Handle,
-    room_type: z25.string().optional(),
+    room_type: z31.string().optional(),
     spaceType: PluginSpaceType.optional(),
     massType: PluginMassType.optional(),
     departmentId: PluginDepartmentId.optional()
   })
 ]);
-var PluginSpaceBulkCreateArgs = z25.object({
-  items: z25.array(PluginSpaceBulkCreateItem)
+var PluginSpaceBulkCreateArgs = z31.object({
+  items: z31.array(PluginSpaceBulkCreateItem)
 });
-var PluginSpaceBulkCreateResult = z25.object({
-  spaceIds: z25.array(z25.string())
+var PluginSpaceBulkCreateResult = z31.object({
+  spaceIds: z31.array(z31.string())
 });
-var PluginSpaceBulkUpdateItem = z25.object({
-  spaceId: z25.string(),
+var PluginSpaceBulkUpdateItem = z31.object({
+  spaceId: z31.string(),
   profile: ProfileHandle.optional(),
-  extrudeHeight: z25.number().optional(),
-  properties: z25.object({
-    room_type: z25.string().optional(),
+  extrudeHeight: z31.number().optional(),
+  properties: z31.object({
+    room_type: z31.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 = z31.object({
+  items: z31.array(PluginSpaceBulkUpdateItem)
 });
-var PluginSpaceBulkUpdateResult = z25.object({
-  spaces: z25.array(PluginSpaceUpdateResult)
+var PluginSpaceBulkUpdateResult = z31.object({
+  spaces: z31.array(PluginSpaceUpdateResult)
 });
-var PluginSpaceBulkDeleteArgs = z25.object({
-  spaceIds: z25.array(z25.string())
+var PluginSpaceBulkDeleteArgs = z31.object({
+  spaceIds: z31.array(z31.string())
 });
-var PluginSpaceBulkDeleteResult = z25.object({
-  deletedSpaceIds: z25.array(z25.string())
+var PluginSpaceBulkDeleteResult = z31.object({
+  deletedSpaceIds: z31.array(z31.string())
 });
 
 // src/api/design/create/index.ts
@@ -1274,14 +1460,14 @@ var PluginDesignCreateApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineStyle = z26.enum(["SOLID", "DASHED", "DOT_DASH"]);
-var PluginSlabType = z26.enum([
+var PluginReferenceLineStyle = z32.enum(["SOLID", "DASHED", "DOT_DASH"]);
+var PluginSlabType = z32.enum([
   "Intermediate Slab",
   "Basement Slab",
   "Plinth",
   "Roof"
 ]);
-var PluginStaircasePreset = z26.enum([
+var PluginStaircasePreset = z32.enum([
   "straight",
   "straightWoLanding",
   "straightFlightWoMidLanding",
@@ -1299,89 +1485,122 @@ var PluginStaircasePreset = z26.enum([
   "mezzanineFloorLShaped",
   "custom"
 ]);
-var PluginDesignCreateSpaceArgs = z26.object({
+var PluginDesignCreateSpaceArgs = z32.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z32.number(),
+  label: z32.string().optional(),
   position: Vec3Handle.optional(),
   spaceType: PluginSpaceType.optional(),
   massType: PluginMassType.optional(),
   departmentId: PluginDepartmentId.optional()
 });
-var PluginDesignCreateMassArgs = z26.object({
+var PluginDesignCreateMassArgs = z32.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z32.number(),
+  label: z32.string().optional(),
   position: Vec3Handle.optional(),
   massType: PluginMassType.optional()
 });
-var PluginDesignCreateSlabArgs = z26.object({
+var PluginDesignCreateSlabArgs = z32.object({
   contour: ContourHandle,
-  thickness: z26.number(),
-  direction: z26.enum(["up", "down"]).optional(),
+  thickness: z32.number(),
+  direction: z32.enum(["up", "down"]).optional(),
   slabType: PluginSlabType.optional()
 });
-var PluginDesignCreateFloorArgs = z26.object({
+var PluginDesignCreateFloorArgs = z32.object({
   contour: ContourHandle,
-  thickness: z26.number(),
+  thickness: z32.number(),
   position: Vec3Handle.optional()
 });
-var PluginDesignCreateRoofArgs = z26.object({
+var PluginDesignCreateRoofArgs = z32.object({
   contour: ContourHandle,
-  thickness: z26.number()
+  thickness: z32.number()
 });
-var PluginDesignCreateCeilingArgs = z26.object({
+var PluginDesignCreateCeilingArgs = z32.object({
   contour: ContourHandle,
-  thickness: z26.number(),
-  heightFromFloor: z26.number().optional()
+  thickness: z32.number(),
+  heightFromFloor: z32.number().optional()
 });
-var PluginDesignCreateColumnArgs = z26.object({
+var PluginDesignCreateColumnArgs = z32.object({
   position: Vec3Handle,
   crossSection: ContourHandle,
-  height: z26.number(),
+  height: z32.number(),
   directionUp: Vec3Handle.optional()
 });
-var PluginDesignCreateBeamArgs = z26.object({
+var PluginDesignCreateBeamArgs = z32.object({
   section: ContourHandle,
-  length: z26.number(),
+  length: z32.number(),
   direction: Vec3Handle.optional()
 });
-var PluginDesignCreateWallsArgs = z26.object({
+var PluginDesignCreateWallsArgs = z32.object({
   profile: ProfileHandle,
-  height: z26.number().optional(),
-  thickness: z26.number().optional()
+  height: z32.number().optional(),
+  thickness: z32.number().optional()
 });
-var PluginDesignCreateStaircaseArgs = z26.object({
+var PluginDesignCreateStaircaseArgs = z32.object({
   preset: PluginStaircasePreset,
   position: Vec3Handle,
-  label: z26.string().optional(),
-  structureId: z26.string().optional(),
-  level: z26.string().optional()
+  label: z32.string().optional(),
+  structureId: z32.string().optional(),
+  level: z32.string().optional()
+});
+var PluginDesignCreateFurnitureArgs = z32.object({
+  catalogId: z32.string().min(1),
+  position: Vec3Handle,
+  label: z32.string().optional(),
+  createNewSourceMesh: z32.boolean().optional()
 });
-var PluginDesignCreateFurnitureArgs = z26.object({
-  catalogId: z26.string().min(1),
+var PluginDesignCreateDoorArgs = z32.object({
+  catalogId: z32.string().min(1),
+  hostWall: ComponentHandle,
   position: Vec3Handle,
-  label: z26.string().optional(),
-  createNewSourceMesh: z26.boolean().optional()
+  label: z32.string().optional()
+});
+var PluginDesignCreateWindowArgs = z32.object({
+  catalogId: z32.string().min(1),
+  hostWall: ComponentHandle,
+  position: Vec3Handle,
+  label: z32.string().optional()
+});
+var PluginSmartLayoutArgs = z32.object({
+  templateGroup: z32.string().min(1).optional(),
+  templateComponents: z32.array(ComponentHandle).optional(),
+  targets: z32.array(ComponentHandle).min(1),
+  hideTargets: z32.boolean().optional()
+}).refine(
+  (v) => v.templateGroup != null !== (v.templateComponents?.length ?? 0) > 0,
+  {
+    message: "Provide exactly one template source: templateGroup or a non-empty templateComponents"
+  }
+);
+var PluginSmartLayoutResult = z32.object({
+  created: z32.object({
+    walls: z32.array(ComponentHandle),
+    furniture: z32.array(ComponentHandle),
+    doors: z32.array(ComponentHandle),
+    windows: z32.array(ComponentHandle),
+    floors: z32.array(ComponentHandle)
+  }),
+  skippedWalls: z32.number()
 });
-var PluginDesignCreateReferenceLinesArgs = z26.object({
+var PluginDesignCreateReferenceLinesArgs = z32.object({
   profile: ProfileHandle,
-  color: z26.string().optional(),
-  thickness: z26.number().optional(),
+  color: z32.string().optional(),
+  thickness: z32.number().optional(),
   style: PluginReferenceLineStyle.optional(),
-  gridTag: z26.string().optional()
+  gridTag: z32.string().optional()
 });
-var PluginCopyMode = z26.enum(["instance", "unique"]);
-var PluginDesignCreateCopyArgs = z26.object({
-  components: z26.array(ComponentHandle).min(1),
+var PluginCopyMode = z32.enum(["instance", "unique"]);
+var PluginDesignCreateCopyArgs = z32.object({
+  components: z32.array(ComponentHandle).min(1),
   displacement: Vec3Handle,
-  count: z26.number().int().positive().optional(),
+  count: z32.number().int().positive().optional(),
   mode: PluginCopyMode.optional()
 });
-var PluginCreateSpaceItem = z26.object({
+var PluginCreateSpaceItem = z32.object({
   contour: ContourHandle,
-  height: z26.number(),
-  label: z26.string().optional(),
+  height: z32.number(),
+  label: z32.string().optional(),
   position: Vec3Handle.optional(),
   spaceType: PluginSpaceType.optional(),
   massType: PluginMassType.optional(),
@@ -1389,44 +1608,44 @@ var PluginCreateSpaceItem = z26.object({
 });
 
 // src/api/design/query/index.ts
-import * as z29 from "zod";
+import * as z35 from "zod";
 
 // src/api/design/query/geometry/index.ts
-import * as z27 from "zod";
+import * as z33 from "zod";
 var PluginDesignQueryGeometryApi = class {
   constructor() {
   }
 };
-var PluginDesignQueryGeometryGetBrepArgs = z27.object({
+var PluginDesignQueryGeometryGetBrepArgs = z33.object({
   component: ComponentHandle
 });
-var PluginDesignQueryGeometryGetBottomContourArgs = z27.object({
+var PluginDesignQueryGeometryGetBottomContourArgs = z33.object({
   component: ComponentHandle
 });
-var PluginDesignQueryGeometryGetCenterlineArgs = z27.object({
+var PluginDesignQueryGeometryGetCenterlineArgs = z33.object({
   component: ComponentHandle
 });
 
 // src/api/design/query/spaces.ts
-import * as z28 from "zod";
+import * as z34 from "zod";
 var PluginDesignQuerySpacesApi = class {
   constructor() {
   }
 };
-var PluginDesignQueryGetFootprintArgs = z28.object({
+var PluginDesignQueryGetFootprintArgs = z34.object({
   space: ComponentHandle
 });
 var PluginDesignQuerySpacesGetProperty = PluginSpaceGetProperty.exclude(["adjacency"]);
-var PluginDesignQuerySpacesGetArgs = z28.object({
+var PluginDesignQuerySpacesGetArgs = z34.object({
   space: ComponentHandle,
-  properties: z28.array(PluginDesignQuerySpacesGetProperty)
+  properties: z34.array(PluginDesignQuerySpacesGetProperty)
 });
 var PluginDesignQuerySpacesGetResult = PluginSpaceGetResult.omit({
   adjacency: true
 });
 
 // src/api/design/query/index.ts
-var PluginEntityType = z29.enum([
+var PluginEntityType = z35.enum([
   "wall",
   "space",
   "mass",
@@ -1445,227 +1664,335 @@ 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 = z35.object({
+  types: z35.array(PluginEntityType).optional(),
+  storeys: z35.array(z35.number()).optional(),
+  buildingIds: z35.array(z35.string()).optional(),
+  structureIds: z35.array(z35.string()).optional(),
+  label: z35.string().optional(),
+  massTypes: z35.array(PluginMassType).optional(),
+  spaceTypes: z35.array(PluginSpaceType).optional(),
   departmentId: PluginDepartmentId.optional(),
-  isSelected: z29.boolean().optional(),
-  isLocked: z29.boolean().optional(),
-  isHidden: z29.boolean().optional(),
+  isSelected: z35.boolean().optional(),
+  isLocked: z35.boolean().optional(),
+  isHidden: z35.boolean().optional(),
   within: BBoxComponents.optional(),
   overlaps: ComponentHandle.optional(),
-  ids: z29.array(ComponentHandle).optional()
+  ids: z35.array(ComponentHandle).optional()
 });
 var PluginDesignQueryListByTypeArgs = PluginEntityFilter.extend({
   type: PluginEntityType
 });
-var PluginDesignQueryComponentArgs = z29.object({
+var PluginDesignQueryComponentArgs = z35.object({
   component: ComponentHandle
 });
-var PluginDesignQueryIdArgs = z29.object({
+var PluginDesignQueryIdArgs = z35.object({
   id: ComponentHandle
 });
-var PluginDesignQueryComponentsArgs = z29.object({
-  components: z29.array(ComponentHandle)
+var PluginDesignQueryComponentsArgs = z35.object({
+  components: z35.array(ComponentHandle)
 });
-var PluginEntityProperties = z29.object({
-  id: z29.string(),
+var PluginEntityProperties = z35.object({
+  id: z35.string(),
   type: PluginEntityType,
-  label: z29.string(),
-  storey: z29.number(),
-  buildingId: z29.string(),
-  structureId: z29.string(),
-  massType: z29.string(),
+  label: z35.string(),
+  storey: z35.number(),
+  buildingId: z35.string(),
+  structureId: z35.string(),
+  massType: z35.string(),
   spaceType: PluginSpaceType,
   areaClass: PluginAreaClass,
-  departmentId: z29.string(),
-  isLocked: z29.boolean(),
-  isHidden: z29.boolean(),
-  isSelected: z29.boolean(),
+  departmentId: z35.string(),
+  isLocked: z35.boolean(),
+  isHidden: z35.boolean(),
+  isSelected: z35.boolean(),
   boundingBox: BBoxComponents,
-  adjacency: z29.array(z29.object({ spaceId: z29.string(), value: z29.number() }))
+  adjacency: z35.array(z35.object({ spaceId: z35.string(), value: z35.number() }))
 }).partial();
-var PluginEntityMeasurements = z29.object({
-  area: z29.number().optional(),
-  volume: z29.number().optional(),
-  length: z29.number().optional(),
+var PluginEntityMeasurements = z35.object({
+  area: z35.number().optional(),
+  volume: z35.number().optional(),
+  length: z35.number().optional(),
   boundingBox: BBoxComponents
 });
+var PluginStaircaseParams = z35.object({
+  staircaseType: PluginStaircasePreset,
+  staircasePreset: PluginStaircasePreset,
+  staircaseHeight: z35.number(),
+  steps: z35.number(),
+  riser: z35.number(),
+  tread: z35.number(),
+  width: z35.number(),
+  depth: z35.number(),
+  wellSize: z35.number().optional(),
+  landingWidth: z35.number().optional(),
+  flightStartDistAfterTurn: z35.number().optional(),
+  baseOffset: z35.number(),
+  isStoreyHeightUnlocked: z35.boolean(),
+  isStaircaseHeightUnlocked: z35.boolean(),
+  storey: z35.number()
+});
 var PluginDesignQueryApi = class {
   constructor() {
   }
 };
 
 // src/api/design/selection/index.ts
-import * as z30 from "zod";
+import * as z36 from "zod";
+var PluginSelectionEntityType = z36.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 = z36.object({
+  storeys: z36.array(z36.number()).optional(),
+  types: z36.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 = z36.object({
+  components: z36.array(ComponentHandle)
 });
 var PluginDesignSelectionAddArgs = PluginDesignSelectionSetArgs;
 var PluginDesignSelectionRemoveArgs = PluginDesignSelectionSetArgs;
 
 // src/api/design/doors/index.ts
-import * as z31 from "zod";
+import * as z37 from "zod";
 var PluginDesignDoorsApi = class {
   constructor() {
   }
 };
-var PluginDesignDoorArgs = z31.object({
+var PluginDesignDoorArgs = z37.object({
   door: ComponentHandle
 });
-var PluginMirrorAxis = z31.enum(["x", "y", "z"]);
-var PluginDesignDoorMirrorArgs = z31.object({
+var PluginMirrorAxis = z37.enum(["x", "y", "z"]);
+var PluginDesignDoorMirrorArgs = z37.object({
   door: ComponentHandle,
   axis: PluginMirrorAxis.optional()
 });
-var PluginDesignDoorSetWidthArgs = z31.object({
-  doors: z31.array(ComponentHandle),
-  width: z31.number()
+var PluginDesignDoorSetWidthArgs = z37.object({
+  doors: z37.array(ComponentHandle),
+  width: z37.number()
 });
-var PluginDesignDoorSetHeightArgs = z31.object({
-  doors: z31.array(ComponentHandle),
-  height: z31.number()
+var PluginDesignDoorSetHeightArgs = z37.object({
+  doors: z37.array(ComponentHandle),
+  height: z37.number()
 });
+var PluginObjectCatalogGroup = z37.object({
+  dbType: z37.string(),
+  label: z37.string(),
+  source: z37.enum(["default", "team"])
+});
+var PluginObjectCatalogItem = z37.object({
+  id: z37.string(),
+  name: z37.string(),
+  source: z37.enum(["team", "general"]),
+  dbType: z37.string(),
+  subType: z37.string().optional(),
+  thumbnailUrl: z37.string().optional(),
+  cost: z37.number().optional(),
+  familyName: z37.string().optional()
+});
+var PluginDesignDoorListCatalogArgs = z37.object({
+  group: z37.string().optional()
+});
+var PluginDesignDoorGetCatalogItemArgs = z37.object({
+  id: z37.string()
+});
+var PluginDesignDoorExistsArgs = PluginDesignDoorGetCatalogItemArgs;
 
 // src/api/design/windows/index.ts
-import * as z32 from "zod";
+import * as z38 from "zod";
 var PluginDesignWindowsApi = class {
   constructor() {
   }
 };
-var PluginDesignWindowArgs = z32.object({
+var PluginDesignWindowArgs = z38.object({
   window: ComponentHandle
 });
-var PluginWindowDimensions = z32.object({
-  width: z32.number(),
-  height: z32.number(),
-  thickness: z32.number()
+var PluginWindowDimensions = z38.object({
+  width: z38.number(),
+  height: z38.number(),
+  thickness: z38.number()
 });
-var PluginDesignWindowSetWidthArgs = z32.object({
+var PluginDesignWindowSetWidthArgs = z38.object({
   window: ComponentHandle,
-  width: z32.number()
+  width: z38.number()
 });
-var PluginDesignWindowSetHeightArgs = z32.object({
+var PluginDesignWindowSetHeightArgs = z38.object({
   window: ComponentHandle,
-  height: z32.number()
+  height: z38.number()
+});
+var PluginDesignWindowListCatalogArgs = z38.object({
+  group: z38.string().optional()
 });
+var PluginDesignWindowGetCatalogItemArgs = z38.object({
+  id: z38.string()
+});
+var PluginDesignWindowExistsArgs = PluginDesignWindowGetCatalogItemArgs;
 
 // src/api/design/furniture/index.ts
-import * as z33 from "zod";
+import * as z39 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 PluginDesignFurnitureListCatalogArgs = z33.object({
-  source: z33.enum(["team", "general"]).optional()
-});
-var PluginDesignFurnitureGetCatalogItemArgs = z33.object({
-  id: z33.string()
+var PluginFurnitureCatalogItem = z39.object({
+  id: z39.string(),
+  name: z39.string(),
+  source: z39.enum(["team", "general"]),
+  subType: z39.string().optional(),
+  category: z39.string().optional(),
+  thumbnailUrl: z39.string().optional(),
+  cost: z39.number().optional(),
+  familyName: z39.string().optional()
+});
+var PluginDesignFurnitureListCatalogArgs = z39.object({
+  source: z39.enum(["team", "general"]).optional(),
+  category: z39.string().optional()
+});
+var PluginDesignFurnitureGetCatalogItemArgs = z39.object({
+  id: z39.string()
 });
 var PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs;
 
 // src/api/design/materials/index.ts
-import * as z34 from "zod";
+import * as z40 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 PluginMaterialInfo = z40.object({
+  name: z40.string(),
+  id: z40.string(),
+  colorHex: z40.string(),
+  alpha: z40.number(),
+  materialType: z40.string().optional(),
+  textureUrl: z40.string().optional()
+});
+var PluginMaterialSpec = z40.object({
+  name: z40.string().optional(),
+  color: z40.string().optional(),
+  textureUrl: z40.string().optional(),
+  alpha: z40.number().optional(),
+  materialType: z40.string().optional()
+});
+var PluginMaterialResult = z40.object({ count: z40.number() });
+var PluginFaceMaterial = z40.object({
+  faceIndex: z40.number().int().nonnegative(),
+  material: MaterialHandle.nullable()
+});
+var PluginDesignMaterialsListArgs = z40.object({
+  scope: z40.enum(["project", "preset"]).optional()
+});
+var PluginDesignMaterialsGetInfoArgs = z40.object({ material: MaterialHandle });
+var PluginDesignMaterialsComponentArgs = z40.object({ component: ComponentHandle });
+var PluginDesignMaterialsApplyArgs = z40.object({
+  targets: z40.array(ComponentHandle),
+  material: z40.union([MaterialHandle, PluginMaterialSpec]),
+  save: z40.boolean().optional()
+});
+var PluginDesignMaterialsResetArgs = z40.object({
+  components: z40.array(ComponentHandle),
+  save: z40.boolean().optional()
+});
+var PluginDesignMaterialsCreateArgs = z40.object({ spec: PluginMaterialSpec });
+var PluginDesignMaterialsApplyToFacesArgs = z40.object({
+  component: ComponentHandle,
+  faces: z40.array(z40.number().int().nonnegative()),
+  material: z40.union([MaterialHandle, PluginMaterialSpec]),
+  save: z40.boolean().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 PluginDesignMaterialsResetFacesArgs = z40.object({
+  component: ComponentHandle,
+  faces: z40.array(z40.number().int().nonnegative()),
+  save: z40.boolean().optional()
 });
-var PluginDesignMaterialsResetArgs = z34.object({
-  components: z34.array(ComponentHandle),
-  save: z34.boolean().optional()
+var PluginDesignMaterialsGetByFaceArgs = z40.object({
+  component: ComponentHandle,
+  face: z40.number().int().nonnegative()
 });
-var PluginDesignMaterialsCreateArgs = z34.object({ spec: PluginMaterialSpec });
+var PluginDesignMaterialsListByFaceArgs = PluginDesignMaterialsComponentArgs;
 
 // src/api/design/lock.ts
-import * as z35 from "zod";
-var PluginDesignChangeResult = z35.object({
-  affected: z35.array(ComponentHandle)
+import * as z41 from "zod";
+var PluginDesignChangeResult = z41.object({
+  affected: z41.array(ComponentHandle)
 });
-var PluginDesignLockArgs = z35.object({
-  components: z35.array(ComponentHandle)
+var PluginDesignLockArgs = z41.object({
+  components: z41.array(ComponentHandle)
 });
 var PluginDesignUnlockArgs = PluginDesignLockArgs;
-var PluginDesignIsLockedArgs = z35.object({
+var PluginDesignIsLockedArgs = z41.object({
   component: ComponentHandle,
-  includeInherited: z35.boolean().optional()
+  includeInherited: z41.boolean().optional()
+});
+var PluginDesignLockAreaArgs = z41.object({
+  spaces: z41.array(ComponentHandle)
+});
+var PluginDesignUnlockAreaArgs = PluginDesignLockAreaArgs;
+var PluginDesignIsAreaLockedArgs = z41.object({
+  space: ComponentHandle
 });
 
 // src/api/design/erase/index.ts
-import * as z36 from "zod";
-var EraseStrategy = z36.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
+import * as z42 from "zod";
+var EraseStrategy = z42.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
 var DEFAULT_ERASE_STRATEGIES = ["DirectDelete", "DirectUnion"];
-var ErasableEdgeRef = z36.object({
+var ErasableEdgeRef = z42.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: z42.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: z42.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: z42.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 = z42.object({
+  components: z42.array(ComponentHandle).optional(),
+  strategies: z42.array(EraseStrategy).optional()
 });
-var PluginDesignEraseEdgeArgs = z36.object({
+var PluginDesignEraseEdgeArgs = z42.object({
   edge: ErasableEdgeRef
 });
-var PluginDesignEraseEdgeResult = z36.object({ ok: z36.literal(true) });
+var PluginDesignEraseEdgeResult = z42.object({ ok: z42.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 z43 from "zod";
+var PluginDesignDeleteEntitiesArgs = z43.object({
+  components: z43.array(ComponentHandle).min(1)
 });
 var PluginDesignDeleteApi = class {
   constructor() {
@@ -1673,89 +2000,120 @@ 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 z44 from "zod";
+var BooleanOutcome = z44.object({
+  created: z44.array(ComponentHandle),
+  deleted: z44.array(ComponentHandle)
 });
-var OffsetSplitOutcome = z38.object({
-  createdIds: z38.array(ComponentHandle),
-  deletedIds: z38.array(ComponentHandle),
-  offsetValue: z38.number()
+var OffsetSplitOutcome = z44.object({
+  createdIds: z44.array(ComponentHandle),
+  deletedIds: z44.array(ComponentHandle),
+  offsetValue: z44.number()
 });
 
 // src/api/design/boolean/index.ts
-import * as z39 from "zod";
+import * as z45 from "zod";
 var PluginDesignBooleanApi = class {
   constructor() {
   }
 };
-var BooleanOptions = z39.object({
+var BooleanOptions = z45.object({
   offset: Vec3Handle.optional()
 });
-var PluginDesignBooleanUnionArgs = z39.object({
-  components: z39.array(ComponentHandle).min(2),
+var PluginDesignBooleanUnionArgs = z45.object({
+  components: z45.array(ComponentHandle).min(2),
   options: BooleanOptions.optional()
 });
-var PluginDesignBooleanSubtractArgs = z39.object({
+var PluginDesignBooleanSubtractArgs = z45.object({
   target: ComponentHandle,
-  tools: z39.array(ComponentHandle).min(1),
+  tools: z45.array(ComponentHandle).min(1),
   options: BooleanOptions.optional()
 });
-var PluginDesignBooleanIntersectArgs = z39.object({
-  components: z39.array(ComponentHandle).length(2),
+var PluginDesignBooleanIntersectArgs = z45.object({
+  components: z45.array(ComponentHandle).length(2),
   options: BooleanOptions.optional()
 });
 
 // src/api/design/transform/index.ts
-import * as z40 from "zod";
+import * as z46 from "zod";
 var PluginDesignTransformApi = class {
   constructor() {
   }
 };
-var PluginDesignMoveArgs = z40.object({
-  components: z40.array(ComponentHandle).min(1),
+var PluginAlignEdge = z46.enum(["left", "right", "center", "top", "bottom", "middle"]);
+var PluginDesignMoveArgs = z46.object({
+  components: z46.array(ComponentHandle).min(1),
   displacement: Vec3Handle,
-  is2D: z40.boolean().optional(),
-  trackParentChange: z40.boolean().optional()
+  is2D: z46.boolean().optional(),
+  trackParentChange: z46.boolean().optional()
 });
-var PluginDesignRotateArgs = z40.object({
-  components: z40.array(ComponentHandle).min(1),
-  angleInDegrees: z40.number(),
+var PluginDesignRotateArgs = z46.object({
+  components: z46.array(ComponentHandle).min(1),
+  angleInDegrees: z46.number(),
   axis: Vec3Handle.optional(),
-  is2D: z40.boolean().optional()
+  is2D: z46.boolean().optional()
+});
+var PluginDesignAlignArgs = z46.object({
+  components: z46.array(ComponentHandle).min(1),
+  edge: PluginAlignEdge,
+  reference: ComponentHandle.optional()
 });
 
 // src/api/design/edit/index.ts
-import * as z41 from "zod";
+import * as z47 from "zod";
 var PluginDesignEditApi = class {
   constructor() {
   }
 };
-var PluginDesignOffsetSplitArgs = z41.object({
+var PluginDesignOffsetSplitArgs = z47.object({
   component: ComponentHandle,
-  offsetDistance: z41.number(),
+  offsetDistance: z47.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 z48 from "zod";
+var PluginSpacePropertyUpdates = z48.object({
+  room_type: z48.string().optional(),
   massType: PluginMassType.optional(),
   spaceType: PluginSpaceType.optional(),
   areaClass: PluginAreaClass.optional(),
   departmentId: PluginDepartmentId.optional()
 });
-var PluginSpaceGeometryUpdate = z42.object({
+var PluginSpaceGeometryUpdate = z48.object({
   profile: ProfileHandle,
-  extrudeHeight: z42.number()
+  extrudeHeight: z48.number()
 });
-var PluginUpdateSpaceItem = z42.object({
+var PluginUpdateSpaceItem = z48.object({
   space: ComponentHandle,
   properties: PluginSpacePropertyUpdates.optional(),
   geometry: PluginSpaceGeometryUpdate.optional()
 });
+var PluginDesignSetLabelArgs = z48.object({
+  component: ComponentHandle,
+  label: z48.string().trim().min(1)
+});
+var PluginStaircaseParamUpdates = z48.object({
+  isStoreyHeightUnlocked: z48.boolean().optional(),
+  isStaircaseHeightUnlocked: z48.boolean().optional(),
+  storeyHeight: z48.number().optional(),
+  staircaseHeight: z48.number().optional(),
+  steps: z48.number().int().optional(),
+  riser: z48.number().optional(),
+  tread: z48.number().optional(),
+  width: z48.number().optional(),
+  depth: z48.number().optional(),
+  wellSize: z48.number().optional(),
+  flightStartDistAfterTurn: z48.number().optional(),
+  landingWidth: z48.number().optional(),
+  baseOffset: z48.number().optional()
+}).refine((p) => Object.keys(p).length > 0, {
+  message: "PluginStaircaseParamUpdates requires at least one field to change"
+});
+var PluginDesignUpdateStaircaseArgs = z48.object({
+  staircases: z48.array(ComponentHandle),
+  params: PluginStaircaseParamUpdates
+});
 var PluginDesignUpdateApi = class {
   constructor() {
   }
@@ -1768,37 +2126,37 @@ var PluginDesignApi = class {
 };
 
 // src/api/entity/buildableEnvelope.ts
-import * as z43 from "zod";
+import * as z49 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 = z49.union([
+  z49.object({ x: z49.number().finite(), z: z49.number().finite() }).strict(),
+  z49.tuple([z49.number().finite(), z49.number().finite()])
 ]);
-var PluginBuildableEnvelopeVerticalCap = z43.discriminatedUnion("kind", [
-  z43.object({
-    kind: z43.literal("max_height"),
-    maxHeight: z43.number().finite().positive()
+var PluginBuildableEnvelopeVerticalCap = z49.discriminatedUnion("kind", [
+  z49.object({
+    kind: z49.literal("max_height"),
+    maxHeight: z49.number().finite().positive()
   }).strict(),
-  z43.object({
-    kind: z43.literal("max_floors"),
-    maxFloors: z43.number().finite().int().positive()
+  z49.object({
+    kind: z49.literal("max_floors"),
+    maxFloors: z49.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 = z49.object({
+  aboveHeight: z49.number().finite().nonnegative(),
+  front: z49.number().finite().nonnegative(),
+  side: z49.number().finite().nonnegative(),
+  rear: z49.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: z49.ZodIssueCode.custom,
       path: ["setbacks", 0, "aboveHeight"],
       message: "Ground tier required: setbacks[0].aboveHeight must be 0."
     });
@@ -1806,75 +2164,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: z49.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 = z49.object({
+  sitePolygon: z49.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z49.union([z49.literal("ft"), z49.literal("m")]),
+  setbacks: z49.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: z49.number().finite().positive(),
+  farRatio: z49.number().finite().positive().optional(),
+  lotCoverageMaxPct: z49.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeCreateResult = z43.object({
-  buildableEnvelopeId: z43.string().min(1)
+var PluginBuildableEnvelopeCreateResult = z49.object({
+  buildableEnvelopeId: z49.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 = z49.object({
+  buildableEnvelopeId: z49.string().min(1),
+  sitePolygon: z49.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z49.union([z49.literal("ft"), z49.literal("m")]),
+  setbacks: z49.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: z49.number().finite().positive(),
+  farRatio: z49.number().finite().positive().optional(),
+  lotCoverageMaxPct: z49.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeUpdateResult = z43.object({
-  buildableEnvelopeId: z43.string().min(1)
+var PluginBuildableEnvelopeUpdateResult = z49.object({
+  buildableEnvelopeId: z49.string().min(1)
 }).strict();
 
 // src/api/entity/referenceLine.ts
-import * as z44 from "zod";
+import * as z50 from "zod";
 var PluginReferenceLineApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineCreateMultiArgs = z44.object({
+var PluginReferenceLineCreateMultiArgs = z50.object({
   profile: ProfileHandle
 });
-var PluginReferenceLineCreateMultiResult = z44.object({
-  referenceLineIds: z44.array(z44.string())
+var PluginReferenceLineCreateMultiResult = z50.object({
+  referenceLineIds: z50.array(z50.string())
 });
-var PluginReferenceLineGetProperty = z44.enum([
+var PluginReferenceLineGetProperty = z50.enum([
   "curve"
 ]);
-var PluginReferenceLineGetArgs = z44.object({
-  referenceLineId: z44.string(),
-  properties: z44.array(PluginReferenceLineGetProperty)
+var PluginReferenceLineGetArgs = z50.object({
+  referenceLineId: z50.string(),
+  properties: z50.array(PluginReferenceLineGetProperty)
 });
-var PluginReferenceLineGetResult = z44.object({
+var PluginReferenceLineGetResult = z50.object({
   curve: CurveHandle
 }).partial();
-var PluginReferenceLineGetAllResult = z44.object({
-  referenceLineIds: z44.array(z44.string())
+var PluginReferenceLineGetAllResult = z50.object({
+  referenceLineIds: z50.array(z50.string())
 });
-var PluginReferenceLineDeleteArgs = z44.object({
-  referenceLineId: z44.string()
+var PluginReferenceLineDeleteArgs = z50.object({
+  referenceLineId: z50.string()
 });
 
 // src/api/entity/story.ts
-import * as z45 from "zod";
+import * as z51 from "zod";
 var PluginStoryApi = class {
   constructor() {
   }
 };
-var PluginStoryGetProperty = z45.enum([
+var PluginStoryGetProperty = z51.enum([
   "value",
   "id",
   "name",
@@ -1884,44 +2242,56 @@ 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 = z51.object({
+  storyValue: z51.number().int(),
+  properties: z51.array(PluginStoryGetProperty)
+});
+var PluginStoryGetResult = z51.object({
+  value: z51.number(),
+  id: z51.string(),
+  name: z51.string(),
+  height: z51.number(),
+  base: z51.number(),
+  hidden: z51.boolean(),
+  spacesCount: z51.number(),
+  totalArea: z51.number()
 }).partial();
-var PluginStoryGetAllResult = z45.object({
-  stories: z45.array(
-    z45.object({
-      value: z45.number(),
-      id: z45.string(),
-      name: z45.string()
+var PluginStoryGetAllResult = z51.object({
+  stories: z51.array(
+    z51.object({
+      value: z51.number(),
+      id: z51.string(),
+      name: z51.string()
     })
   )
 });
-var PluginStoryCreateArgs = z45.object({
-  storyValue: z45.number().int(),
-  height: z45.number().optional()
+var PluginStoryCreateArgs = z51.object({
+  storyValue: z51.number().int(),
+  height: z51.number().optional()
+});
+var PluginStoryCreateResult = z51.object({
+  storyId: z51.string(),
+  storyValue: z51.number()
 });
-var PluginStoryCreateResult = z45.object({
-  storyId: z45.string(),
-  storyValue: z45.number()
+var PluginStoryUpdateArgs = z51.object({
+  storyValue: z51.number().int(),
+  height: z51.number()
 });
-var PluginStoryUpdateArgs = z45.object({
-  storyValue: z45.number().int(),
-  height: z45.number()
+var PluginStoryUpdateResult = z51.object({
+  storyValue: z51.number(),
+  height: z51.number()
 });
-var PluginStoryUpdateResult = z45.object({
-  storyValue: z45.number(),
-  height: z45.number()
+var PluginStoryDuplicateArgs = z51.object({
+  direction: z51.enum(["up", "down"]),
+  components: z51.array(ComponentHandle).optional(),
+  unique: z51.boolean().optional()
+});
+var PluginStoryDuplicateResult = z51.object({
+  sourceStory: z51.number(),
+  targetStories: z51.array(z51.number()),
+  created: z51.array(ComponentHandle),
+  createdStoryValues: z51.array(z51.number()),
+  skipped: z51.number()
 });
 
 // src/api/entity/index.ts
@@ -1931,27 +2301,27 @@ var PluginEntityApi = class {
 };
 
 // src/api/program/departments.ts
-import * as z47 from "zod";
+import * as z53 from "zod";
 
 // src/api/program/metrics.ts
-import * as z46 from "zod";
+import * as z52 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 PluginProgramMetricsSummary = z46.object({
+var PluginAreaUnit = z52.enum(["ft2", "m2"]);
+var PluginProgramDepartmentMetric = z52.object({
+  departmentId: z52.string(),
+  name: z52.string(),
+  targetArea: z52.number().nullable(),
+  allocatedArea: z52.number()
+});
+var PluginProgramMetricsSummary = z52.object({
   units: PluginAreaUnit,
-  totalTargetArea: z46.number(),
-  totalAllocatedArea: z46.number(),
-  unassignedArea: z46.number(),
-  departments: z46.array(PluginProgramDepartmentMetric)
+  totalTargetArea: z52.number(),
+  totalAllocatedArea: z52.number(),
+  unassignedArea: z52.number(),
+  departments: z52.array(PluginProgramDepartmentMetric)
 }).refine(
   (s) => {
     const summed = s.unassignedArea + s.departments.reduce((acc, d) => acc + d.allocatedArea, 0);
@@ -1968,18 +2338,18 @@ var PluginProgramDepartmentsApi = class {
   constructor() {
   }
 };
-var PluginProgramDepartment = z47.object({
-  id: z47.string(),
-  name: z47.string(),
-  color: z47.string(),
-  targetArea: z47.number().nullable()
+var PluginProgramDepartment = z53.object({
+  id: z53.string(),
+  name: z53.string(),
+  color: z53.string(),
+  targetArea: z53.number().nullable()
 });
-var PluginProgramDepartmentsListResult = z47.object({
+var PluginProgramDepartmentsListResult = z53.object({
   units: PluginAreaUnit,
-  departments: z47.array(PluginProgramDepartment)
+  departments: z53.array(PluginProgramDepartment)
 });
-var PluginProgramDepartmentsGetArgs = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsGetArgs = z53.object({
+  departmentId: z53.string()
 });
 var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
   {
@@ -1989,81 +2359,95 @@ var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
 var PluginProgramDepartmentRecord = PluginProgramDepartment.extend({
   units: PluginAreaUnit
 });
-var PluginProgramDepartmentsCreateArgs = z47.object({
-  name: z47.string(),
-  color: z47.string()
+var PluginProgramDepartmentsCreateArgs = z53.object({
+  name: z53.string(),
+  color: z53.string()
 });
-var PluginProgramDepartmentsCreateResult = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsCreateResult = z53.object({
+  departmentId: z53.string()
 });
-var PluginProgramDepartmentsUpdateArgs = z47.object({
-  departmentId: z47.string(),
-  name: z47.string().optional(),
-  color: z47.string().optional()
+var PluginProgramDepartmentsUpdateArgs = z53.object({
+  departmentId: z53.string(),
+  name: z53.string().optional(),
+  color: z53.string().optional()
 });
 var PluginProgramDepartmentsUpdateResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsAssignArgs = z47.object({
-  departmentId: z47.string(),
-  spaceIds: z47.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsAssignArgs = z53.object({
+  departmentId: z53.string(),
+  spaceIds: z53.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsAssignResult = z47.object({
-  departmentId: z47.string(),
-  spaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsAssignResult = z53.object({
+  departmentId: z53.string(),
+  spaceIds: z53.array(ComponentHandle)
 });
-var PluginProgramDepartmentsUnassignArgs = z47.object({
-  spaceIds: z47.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsUnassignArgs = z53.object({
+  spaceIds: z53.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsUnassignResult = z47.object({
-  spaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsUnassignResult = z53.object({
+  spaceIds: z53.array(ComponentHandle)
 });
-var PluginProgramDepartmentsSetTargetAreaArgs = z47.object({
-  departmentId: z47.string(),
-  targetArea: z47.number(),
+var PluginProgramDepartmentsSetTargetAreaArgs = z53.object({
+  departmentId: z53.string(),
+  targetArea: z53.number(),
   units: PluginAreaUnit.optional()
 });
 var PluginProgramDepartmentsSetTargetAreaResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsDeleteArgs = z47.object({
-  departmentId: z47.string()
+var PluginProgramDepartmentsDeleteArgs = z53.object({
+  departmentId: z53.string()
 });
-var PluginProgramDepartmentsDeleteResult = z47.object({
-  departmentId: z47.string(),
-  reassignedSpaceIds: z47.array(ComponentHandle)
+var PluginProgramDepartmentsDeleteResult = z53.object({
+  departmentId: z53.string(),
+  reassignedSpaceIds: z53.array(ComponentHandle)
 });
 
 // src/api/program/adjacency.ts
-import * as z48 from "zod";
+import * as z54 from "zod";
 var PluginProgramAdjacencyApi = class {
   constructor() {
   }
 };
-var PluginAdjacencyLevel = z48.enum(["department", "space"]);
-var PluginProgramAdjacencyGetMatrixArgs = z48.object({
+var PluginAdjacencyLevel = z54.enum(["department", "space"]);
+var PluginProgramAdjacencyGetMatrixArgs = z54.object({
   level: PluginAdjacencyLevel,
-  ids: z48.array(z48.string()).optional()
+  ids: z54.array(z54.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 = z54.object({
+  ids: z54.array(z54.string()),
+  departmentIds: z54.array(z54.string().nullable()).optional(),
+  matrix: z54.array(z54.array(z54.number()))
 });
-var PluginProgramAdjacencyComputeResult = z48.object({
-  success: z48.boolean(),
-  error: z48.string().optional()
+var PluginProgramAdjacencyComputeResult = z54.object({
+  success: z54.boolean(),
+  error: z54.string().optional()
 });
 
 // src/api/program/layout.ts
-import * as z49 from "zod";
+import * as z55 from "zod";
 var PluginProgramLayoutApi = class {
   constructor() {
   }
 };
-var PluginProgramLayoutRunResult = z49.object({
-  success: z49.boolean(),
-  error: z49.string().optional()
+var PluginProgramLayoutRunArgs = z55.object({
+  spaceIds: z55.array(z55.string()).optional(),
+  departmentIds: z55.array(z55.string()).optional(),
+  envelopeId: z55.string().optional()
+});
+var PluginProgramLayoutRunResult = z55.object({
+  success: z55.boolean(),
+  error: z55.string().optional()
+});
+var PluginProgramLayoutJobStatus = z55.enum([
+  "running",
+  "active",
+  "inactive"
+]);
+var PluginProgramLayoutJobState = z55.object({
+  status: PluginProgramLayoutJobStatus
 });
+var PluginProgramLayoutStateResult = PluginProgramLayoutJobState.nullable();
 
 // src/api/program/spreadsheet.ts
-import * as z50 from "zod";
+import * as z56 from "zod";
 var PluginProgramSpreadsheetApi = class {
   constructor() {
   }
@@ -2076,84 +2460,84 @@ var PluginProgramSpreadsheetBindingsApi = class {
   constructor() {
   }
 };
-var PluginSpreadsheetCell = z50.union([
-  z50.string(),
-  z50.number(),
-  z50.boolean(),
-  z50.null()
+var PluginSpreadsheetCell = z56.union([
+  z56.string(),
+  z56.number(),
+  z56.boolean(),
+  z56.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 = z56.enum(["left", "center", "right"]);
+var PluginSpreadsheetColumn = z56.object({
+  key: z56.string(),
+  header: z56.string(),
+  width: z56.number().optional(),
+  format: z56.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 = z56.object({
+  column: z56.string(),
+  fn: z56.enum(["sum", "avg", "count", "min", "max"]),
+  label: z56.string().optional()
+});
+var PluginProgramSpreadsheetRenderArgs = z56.object({
+  sheetName: z56.string(),
+  columns: z56.array(PluginSpreadsheetColumn),
+  rows: z56.array(z56.record(z56.string(), PluginSpreadsheetCell)),
+  title: z56.string().optional(),
+  startCell: z56.string().optional(),
+  whenExists: z56.enum(["replace", "error"]).optional(),
+  asTable: z56.boolean().optional(),
+  freezeHeader: z56.boolean().optional(),
+  totals: z56.array(PluginSpreadsheetTotal).optional()
+});
+var PluginProgramSpreadsheetRenderResult = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
+  headerRange: z56.string(),
+  rowCount: z56.number(),
+  colCount: z56.number(),
+  tableName: z56.string().nullable(),
+  replaced: z56.boolean()
+});
+var PluginProgramSpreadsheetRenderDatasetArgs = z56.object({
+  sheetName: z56.string().optional(),
+  title: z56.string().optional(),
+  filter: z56.string().optional()
+});
+var PluginSpreadsheetExportFormat = z56.enum(["xlsx", "pdf", "csv"]);
+var PluginProgramSpreadsheetExportArgs = z56.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z50.string().optional()
+  fileName: z56.string().optional()
 });
-var PluginProgramSpreadsheetExportResult = z50.object({
+var PluginProgramSpreadsheetExportResult = z56.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z50.string(),
-  mimeType: z50.string(),
-  dataBase64: z50.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([
+  fileName: z56.string(),
+  mimeType: z56.string(),
+  dataBase64: z56.string()
+});
+var PluginSpreadsheetSheetInfo = z56.object({
+  name: z56.string(),
+  index: z56.number(),
+  visible: z56.boolean(),
+  rowCount: z56.number(),
+  colCount: z56.number()
+});
+var PluginProgramSpreadsheetListSheetsResult = z56.object({
+  sheets: z56.array(PluginSpreadsheetSheetInfo),
+  activeSheet: z56.string().nullable()
+});
+var PluginProgramSpreadsheetGetSheetDataArgs = z56.object({
+  sheetName: z56.string(),
+  range: z56.string().optional(),
+  header: z56.boolean().optional()
+});
+var PluginProgramSpreadsheetGetSheetDataResult = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
+  values: z56.array(z56.array(PluginSpreadsheetCell)),
+  records: z56.array(z56.record(z56.string(), PluginSpreadsheetCell)).optional()
+});
+var PluginSpreadsheetChartType = z56.enum([
   "column",
   "bar",
   "line",
@@ -2161,249 +2545,249 @@ var PluginSpreadsheetChartType = z50.enum([
   "area",
   "scatter"
 ]);
-var PluginProgramSpreadsheetAddChartArgs = z50.object({
-  sheetName: z50.string(),
+var PluginProgramSpreadsheetAddChartArgs = z56.object({
+  sheetName: z56.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()
-});
-var PluginProgramSpreadsheetGetProgramResult = z50.object({
+  dataRange: z56.string(),
+  title: z56.string().optional(),
+  position: z56.object({ x: z56.number(), y: z56.number() }).optional(),
+  size: z56.object({ width: z56.number(), height: z56.number() }).optional()
+});
+var PluginProgramSpreadsheetAddChartResult = z56.object({
+  chartId: z56.string()
+});
+var PluginProgramSpreadsheetHighlightCellsArgs = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
+  color: z56.string().optional(),
+  bold: z56.boolean().optional()
+});
+var PluginProgramSpreadsheetHighlightCellsResult = z56.object({
+  sheetName: z56.string(),
+  range: z56.string()
+});
+var PluginSpreadsheetProgramRow = z56.object({
+  departmentId: z56.string(),
+  name: z56.string(),
+  targetArea: z56.number().nullable(),
+  allocatedArea: z56.number(),
+  variance: z56.number().nullable()
+});
+var PluginProgramSpreadsheetGetProgramResult = z56.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: z56.array(PluginSpreadsheetProgramRow),
+  totalTargetArea: z56.number(),
+  totalAllocatedArea: z56.number(),
+  generatedAt: z56.string()
+});
+var PluginSpreadsheetTakeoffRow = z56.object({
+  objectType: z56.string(),
+  category: z56.string(),
+  family: z56.string(),
+  quantity: z56.number(),
+  unit: z56.string()
+});
+var PluginProgramSpreadsheetGetTakeoffResult = z56.object({
+  rows: z56.array(PluginSpreadsheetTakeoffRow),
+  rowCount: z56.number(),
+  generatedAt: z56.string()
+});
+var PluginSpreadsheetWhenExists = z56.enum(["reuse", "replace", "error"]);
+var PluginProgramSpreadsheetCreateSheetArgs = z56.object({
+  name: z56.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 = z56.object({
+  sheetName: z56.string(),
+  replaced: z56.boolean(),
+  sheetIndex: z56.number().nullable()
+});
+var PluginProgramSpreadsheetSetValuesArgs = z56.object({
+  sheetName: z56.string(),
+  values: z56.array(z56.array(PluginSpreadsheetCell)),
+  startCell: z56.string().optional()
+});
+var PluginProgramSpreadsheetSetValuesResult = z56.object({
+  sheetName: z56.string(),
+  startCell: z56.string(),
+  rowCount: z56.number(),
+  colCount: z56.number()
+});
+var PluginSpreadsheetFormula = z56.object({
+  cell: z56.string(),
+  formula: z56.string()
+});
+var PluginProgramSpreadsheetSetFormulasArgs = z56.object({
+  sheetName: z56.string(),
+  formulas: z56.array(PluginSpreadsheetFormula)
+});
+var PluginProgramSpreadsheetSetFormulasResult = z56.object({
+  sheetName: z56.string(),
+  count: z56.number()
+});
+var PluginSpreadsheetFontWeight = z56.enum(["normal", "bold"]);
+var PluginSpreadsheetFontStyle = z56.enum(["normal", "italic"]);
+var PluginSpreadsheetHorizontalAlign = z56.enum([
   "left",
   "center",
   "right",
   "general"
 ]);
-var PluginSpreadsheetVerticalAlign = z50.enum([
+var PluginSpreadsheetVerticalAlign = z56.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 = z56.object({
+  backColor: z56.string().optional(),
+  foreColor: z56.string().optional(),
+  font: z56.string().optional(),
+  fontFamily: z56.string().optional(),
+  fontSize: z56.number().optional(),
   fontWeight: PluginSpreadsheetFontWeight.optional(),
   fontStyle: PluginSpreadsheetFontStyle.optional(),
-  formatter: z50.string().optional(),
+  formatter: z56.string().optional(),
   horizontalAlign: PluginSpreadsheetHorizontalAlign.optional(),
   verticalAlign: PluginSpreadsheetVerticalAlign.optional()
 });
-var PluginSpreadsheetRangeStyle = z50.object({
-  range: z50.string(),
+var PluginSpreadsheetRangeStyle = z56.object({
+  range: z56.string(),
   style: PluginSpreadsheetCellStyle
 });
-var PluginProgramSpreadsheetSetStylesArgs = z50.object({
-  sheetName: z50.string(),
-  ranges: z50.array(PluginSpreadsheetRangeStyle)
+var PluginProgramSpreadsheetSetStylesArgs = z56.object({
+  sheetName: z56.string(),
+  ranges: z56.array(PluginSpreadsheetRangeStyle)
 });
-var PluginProgramSpreadsheetSetStylesResult = z50.object({
-  sheetName: z50.string(),
-  count: z50.number()
+var PluginProgramSpreadsheetSetStylesResult = z56.object({
+  sheetName: z56.string(),
+  count: z56.number()
 });
-var PluginProgramSpreadsheetMergeCellsArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
+var PluginProgramSpreadsheetMergeCellsArgs = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
   value: PluginSpreadsheetCell.optional()
 });
-var PluginProgramSpreadsheetMergeCellsResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string()
+var PluginProgramSpreadsheetMergeCellsResult = z56.object({
+  sheetName: z56.string(),
+  range: z56.string()
 });
-var PluginSpreadsheetConditionalRuleType = z50.enum(["dataBar"]);
-var PluginSpreadsheetConditionalRule = z50.object({
+var PluginSpreadsheetConditionalRuleType = z56.enum(["dataBar"]);
+var PluginSpreadsheetConditionalRule = z56.object({
   type: PluginSpreadsheetConditionalRuleType,
-  color: z50.string().optional()
+  color: z56.string().optional()
 });
-var PluginProgramSpreadsheetAddConditionalFormattingArgs = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
+var PluginProgramSpreadsheetAddConditionalFormattingArgs = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
   rule: PluginSpreadsheetConditionalRule
 });
-var PluginProgramSpreadsheetAddConditionalFormattingResult = z50.object({
-  sheetName: z50.string(),
-  range: z50.string(),
-  created: z50.boolean()
+var PluginProgramSpreadsheetAddConditionalFormattingResult = z56.object({
+  sheetName: z56.string(),
+  range: z56.string(),
+  created: z56.boolean()
 });
-var PluginProgramSpreadsheetRecalculateArgs = z50.object({
-  sheetName: z50.string().optional()
+var PluginProgramSpreadsheetRecalculateArgs = z56.object({
+  sheetName: z56.string().optional()
 });
-var PluginProgramSpreadsheetRecalculateResult = z50.object({
-  scope: z50.enum(["sheet", "workbook"]),
-  sheetName: z50.string().nullable()
+var PluginProgramSpreadsheetRecalculateResult = z56.object({
+  scope: z56.enum(["sheet", "workbook"]),
+  sheetName: z56.string().nullable()
 });
-var PluginSpreadsheetTransactionMethod = z50.enum([
+var PluginSpreadsheetTransactionMethod = z56.enum([
   "createSheet",
   "setValues",
   "setFormulas",
   "setStyles",
   "mergeCells"
 ]);
-var PluginSpreadsheetTransactionOp = z50.object({
+var PluginSpreadsheetTransactionOp = z56.object({
   method: PluginSpreadsheetTransactionMethod,
-  args: z50.unknown()
-});
-var PluginProgramSpreadsheetTransactionArgs = z50.object({
-  operations: z50.array(PluginSpreadsheetTransactionOp),
-  label: z50.string().optional()
-});
-var PluginProgramSpreadsheetTransactionResult = z50.object({
-  label: z50.string(),
-  operationCount: z50.number(),
-  results: z50.array(z50.unknown())
-});
-var PluginProgramSpreadsheetRunScriptArgs = z50.object({
-  script: z50.string()
-});
-var PluginProgramSpreadsheetRunScriptResult = z50.object({
-  result: z50.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(),
+  args: z56.unknown()
+});
+var PluginProgramSpreadsheetTransactionArgs = z56.object({
+  operations: z56.array(PluginSpreadsheetTransactionOp),
+  label: z56.string().optional()
+});
+var PluginProgramSpreadsheetTransactionResult = z56.object({
+  label: z56.string(),
+  operationCount: z56.number(),
+  results: z56.array(z56.unknown())
+});
+var PluginProgramSpreadsheetRunScriptArgs = z56.object({
+  script: z56.string()
+});
+var PluginProgramSpreadsheetRunScriptResult = z56.object({
+  result: z56.unknown()
+});
+var PluginSpreadsheetAuditStatus = z56.enum(["success", "error"]);
+var PluginSpreadsheetAuditEntry = z56.object({
+  id: z56.string(),
+  pluginId: z56.string(),
+  method: z56.string(),
+  label: z56.string().optional(),
+  sheetName: z56.string().optional(),
+  timestamp: z56.string(),
   status: PluginSpreadsheetAuditStatus,
-  summary: z50.string().optional()
+  summary: z56.string().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogArgs = z50.object({
-  limit: z50.number().optional()
+var PluginProgramSpreadsheetGetAuditLogArgs = z56.object({
+  limit: z56.number().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogResult = z50.object({
-  entries: z50.array(PluginSpreadsheetAuditEntry)
+var PluginProgramSpreadsheetGetAuditLogResult = z56.object({
+  entries: z56.array(PluginSpreadsheetAuditEntry)
 });
-var PluginProgramSpreadsheetPingResult = z50.object({
-  pong: z50.boolean()
+var PluginProgramSpreadsheetPingResult = z56.object({
+  pong: z56.boolean()
 });
-var PluginSpreadsheetTemplateScope = z50.enum(["project", "global"]);
-var PluginProgramSpreadsheetTemplatesCreateArgs = z50.object({
-  name: z50.string(),
-  sheetName: z50.string(),
+var PluginSpreadsheetTemplateScope = z56.enum(["project", "global"]);
+var PluginProgramSpreadsheetTemplatesCreateArgs = z56.object({
+  name: z56.string(),
+  sheetName: z56.string(),
   scope: PluginSpreadsheetTemplateScope.optional()
 });
-var PluginProgramSpreadsheetTemplatesCreateResult = z50.object({
-  id: z50.string(),
-  name: z50.string(),
+var PluginProgramSpreadsheetTemplatesCreateResult = z56.object({
+  id: z56.string(),
+  name: z56.string(),
   scope: PluginSpreadsheetTemplateScope,
-  sheetName: z50.string()
+  sheetName: z56.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyArgs = z50.object({
-  name: z50.string(),
-  targetSheetName: z50.string()
+var PluginProgramSpreadsheetTemplatesApplyArgs = z56.object({
+  name: z56.string(),
+  targetSheetName: z56.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyResult = z50.object({
-  name: z50.string(),
-  targetSheetName: z50.string()
+var PluginProgramSpreadsheetTemplatesApplyResult = z56.object({
+  name: z56.string(),
+  targetSheetName: z56.string()
 });
-var PluginSpreadsheetBindingSource = z50.object({
-  dataset: z50.enum(["takeoff"])
+var PluginSpreadsheetBindingSource = z56.object({
+  dataset: z56.enum(["takeoff"])
 });
-var PluginSpreadsheetBindingMode = z50.enum(["replaceRange"]);
-var PluginSpreadsheetBindingTarget = z50.object({
-  sheetName: z50.string(),
-  startCell: z50.string().optional()
+var PluginSpreadsheetBindingMode = z56.enum(["replaceRange"]);
+var PluginSpreadsheetBindingTarget = z56.object({
+  sheetName: z56.string(),
+  startCell: z56.string().optional()
 });
-var PluginSpreadsheetBinding = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  pluginId: z50.string(),
+var PluginSpreadsheetBinding = z56.object({
+  id: z56.string(),
+  name: z56.string(),
+  pluginId: z56.string(),
   source: PluginSpreadsheetBindingSource,
-  target: z50.object({
-    sheetName: z50.string(),
-    startCell: z50.string()
+  target: z56.object({
+    sheetName: z56.string(),
+    startCell: z56.string()
   }),
   mode: PluginSpreadsheetBindingMode,
-  createdAt: z50.string(),
-  updatedAt: z50.string()
+  createdAt: z56.string(),
+  updatedAt: z56.string()
 });
-var PluginSpreadsheetBindingRefresh = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  sheetName: z50.string(),
-  rowCount: z50.number()
+var PluginSpreadsheetBindingRefresh = z56.object({
+  id: z56.string(),
+  name: z56.string(),
+  sheetName: z56.string(),
+  rowCount: z56.number()
 });
-var PluginProgramSpreadsheetBindingsCreateArgs = z50.object({
-  name: z50.string(),
+var PluginProgramSpreadsheetBindingsCreateArgs = z56.object({
+  name: z56.string(),
   source: PluginSpreadsheetBindingSource,
   target: PluginSpreadsheetBindingTarget,
   mode: PluginSpreadsheetBindingMode.optional()
@@ -2411,179 +2795,186 @@ var PluginProgramSpreadsheetBindingsCreateArgs = z50.object({
 var PluginProgramSpreadsheetBindingsCreateResult = PluginSpreadsheetBinding.extend({
   refresh: PluginSpreadsheetBindingRefresh
 });
-var PluginProgramSpreadsheetBindingsRefreshArgs = z50.object({
-  name: z50.string().optional()
+var PluginProgramSpreadsheetBindingsRefreshArgs = z56.object({
+  name: z56.string().optional()
 });
-var PluginProgramSpreadsheetBindingsRefreshResult = z50.object({
-  refreshed: z50.array(PluginSpreadsheetBindingRefresh)
+var PluginProgramSpreadsheetBindingsRefreshResult = z56.object({
+  refreshed: z56.array(PluginSpreadsheetBindingRefresh)
 });
-var PluginProgramSpreadsheetBindingsListResult = z50.object({
-  bindings: z50.array(PluginSpreadsheetBinding)
+var PluginProgramSpreadsheetBindingsListResult = z56.object({
+  bindings: z56.array(PluginSpreadsheetBinding)
 });
 
 // src/api/program/site.ts
-import * as z51 from "zod";
+import * as z57 from "zod";
 var PluginProgramSiteApi = class {
   constructor() {
   }
 };
-var PluginSiteFootprintPoint = z51.object({
-  x: z51.number(),
-  z: z51.number()
-});
-var PluginSiteGeoPoint = z51.object({
-  lat: z51.number(),
-  lng: z51.number(),
-  alt: z51.number()
-});
-var PluginSitePolygon = z51.object({
-  id: z51.string(),
-  area: z51.number(),
-  label: z51.string(),
-  footprint: z51.array(PluginSiteFootprintPoint)
-});
-var PluginProgramSiteSnapshot = z51.object({
+var PluginSiteFootprintPoint = z57.object({
+  x: z57.number(),
+  z: z57.number()
+});
+var PluginSiteGeoPoint = z57.object({
+  lat: z57.number(),
+  lng: z57.number(),
+  alt: z57.number()
+});
+var PluginSitePolygon = z57.object({
+  id: z57.string(),
+  area: z57.number(),
+  label: z57.string(),
+  footprint: z57.array(PluginSiteFootprintPoint)
+});
+var PluginProgramSiteSnapshot = z57.object({
   units: PluginAreaUnit,
-  totalArea: z51.number(),
-  polygonCount: z51.number(),
-  polygons: z51.array(PluginSitePolygon)
+  totalArea: z57.number(),
+  polygonCount: z57.number(),
+  polygons: z57.array(PluginSitePolygon)
 });
-var PluginProgramSiteAreaResult = z51.object({
+var PluginProgramSiteAreaResult = z57.object({
   units: PluginAreaUnit,
-  area: z51.number()
+  area: z57.number()
 });
-var PluginProgramSiteListPolygonsResult = z51.object({
+var PluginProgramSiteListPolygonsResult = z57.object({
   units: PluginAreaUnit,
-  polygons: z51.array(PluginSitePolygon)
+  polygons: z57.array(PluginSitePolygon)
 });
-var PluginProgramSiteListGeoPolygonsResult = z51.object({
-  polygons: z51.array(z51.array(PluginSiteGeoPoint))
+var PluginProgramSiteListGeoPolygonsResult = z57.object({
+  polygons: z57.array(z57.array(PluginSiteGeoPoint))
 });
-var PluginSiteLatLng = z51.object({
-  lat: z51.number(),
-  lng: z51.number()
+var PluginSiteLatLng = z57.object({
+  lat: z57.number(),
+  lng: z57.number()
 });
-var PluginSiteBounds = z51.object({
-  north: z51.number(),
-  south: z51.number(),
-  east: z51.number(),
-  west: z51.number()
+var PluginSiteBounds = z57.object({
+  north: z57.number(),
+  south: z57.number(),
+  east: z57.number(),
+  west: z57.number()
 });
-var PluginSiteContextParcel = z51.object({
-  footprint: z51.array(PluginSiteLatLng),
-  area: z51.number()
+var PluginSiteContextParcel = z57.object({
+  footprint: z57.array(PluginSiteLatLng),
+  area: z57.number()
 });
-var PluginProgramSiteContext = z51.object({
+var PluginProgramSiteContext = z57.object({
   center: PluginSiteLatLng,
   bounds: PluginSiteBounds,
-  widthInM: z51.number(),
-  heightInM: z51.number(),
-  zoom: z51.number(),
-  parcels: z51.array(PluginSiteContextParcel)
+  widthInM: z57.number(),
+  heightInM: z57.number(),
+  zoom: z57.number(),
+  parcels: z57.array(PluginSiteContextParcel)
 });
 var PluginProgramSiteContextResult = PluginProgramSiteContext.nullable();
+var PluginProgramSiteLocation = z57.object({
+  latitude: z57.number(),
+  longitude: z57.number()
+});
+var PluginProgramSiteLocationResult = PluginProgramSiteLocation.nullable();
+var PluginProgramSiteNorthAngleResult = z57.number().nullable();
 
 // src/api/program/cores.ts
-import * as z52 from "zod";
+import * as z58 from "zod";
 var PluginProgramCoresApi = class {
   constructor() {
   }
 };
-var PluginProgramCore = z52.object({
-  id: z52.string(),
-  groupId: z52.string(),
-  storey: z52.number()
+var PluginProgramCore = z58.object({
+  id: z58.string(),
+  groupId: z58.string(),
+  storey: z58.number()
 });
-var PluginProgramCoresListResult = z52.object({
-  cores: z52.array(PluginProgramCore)
+var PluginProgramCoresListResult = z58.object({
+  cores: z58.array(PluginProgramCore)
 });
-var PluginProgramCoresIsCoreArgs = z52.object({
-  id: z52.string()
+var PluginProgramCoresIsCoreArgs = z58.object({
+  id: z58.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 = z58.object({
+  type: z58.string().optional(),
+  position: z58.object({ x: z58.number(), y: z58.number(), z: z58.number() }),
+  width: z58.number(),
+  depth: z58.number(),
+  fromStorey: z58.number().optional(),
+  toStorey: z58.number().optional()
 });
-var PluginProgramCoresCreateArgs = z52.object({
-  cores: z52.array(PluginProgramCoreSpec),
-  lengthUnit: z52.enum(["mm", "m", "ft"]).optional()
+var PluginProgramCoresCreateArgs = z58.object({
+  cores: z58.array(PluginProgramCoreSpec),
+  lengthUnit: z58.enum(["mm", "m", "ft"]).optional()
 });
-var PluginProgramCoresCreateResult = z52.object({
-  createdCount: z52.number()
+var PluginProgramCoresCreateResult = z58.object({
+  createdCount: z58.number()
 });
 
 // src/api/program/classification.ts
-import * as z53 from "zod";
+import * as z59 from "zod";
 var PluginProgramClassificationApi = class {
   constructor() {
   }
 };
-var PluginClassificationOption = z53.object({
-  value: z53.string(),
-  label: z53.string()
+var PluginClassificationOption = z59.object({
+  value: z59.string(),
+  label: z59.string()
 });
-var PluginProgramClassificationTypesResult = z53.object({
-  spaceTypes: z53.array(PluginClassificationOption),
-  areaClasses: z53.array(PluginClassificationOption),
-  massTypes: z53.array(PluginClassificationOption)
+var PluginProgramClassificationTypesResult = z59.object({
+  spaceTypes: z59.array(PluginClassificationOption),
+  areaClasses: z59.array(PluginClassificationOption),
+  massTypes: z59.array(PluginClassificationOption)
 });
-var PluginProgramClassificationListTagsArgs = z53.object({
-  id: z53.string()
+var PluginProgramClassificationListTagsArgs = z59.object({
+  id: z59.string()
 });
-var PluginSpaceTag = z53.object({
-  tagId: z53.string(),
-  tagName: z53.string(),
-  color: z53.string(),
-  categoryId: z53.string()
+var PluginSpaceTag = z59.object({
+  tagId: z59.string(),
+  tagName: z59.string(),
+  color: z59.string(),
+  categoryId: z59.string()
 });
-var PluginProgramClassificationTagsResult = z53.object({
-  tagIds: z53.array(z53.string()),
-  tagsByCategory: z53.record(z53.string(), PluginSpaceTag)
+var PluginProgramClassificationTagsResult = z59.object({
+  tagIds: z59.array(z59.string()),
+  tagsByCategory: z59.record(z59.string(), PluginSpaceTag)
 });
 
 // src/api/program/areas.ts
-import * as z54 from "zod";
+import * as z60 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 = z60.object({
+  count: z60.number().int(),
+  hiddenCount: z60.number().int(),
+  carpet: z60.number(),
+  builtUp: z60.number(),
+  excluded: z60.number(),
+  farBuiltUp: z60.number(),
+  siteArea: z60.number(),
+  achievedFar: z60.number().nullable(),
+  targetFar: z60.number(),
+  deviation: z60.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 = z60.object({
+  groupId: z60.string(),
+  name: z60.string(),
+  color: z60.string(),
+  carpet: z60.number(),
+  builtUp: z60.number(),
+  excluded: z60.number(),
+  count: z60.number().int(),
+  targetArea: z60.number(),
   targetUnit: PluginAreaUnit
 });
-var PluginProgramAreaMember = z54.object({
+var PluginProgramAreaMember = z60.object({
   id: ComponentHandle,
-  label: z54.string(),
-  carpet: z54.number(),
-  builtUp: z54.number(),
-  excluded: z54.number(),
-  isVisible: z54.boolean()
+  label: z60.string(),
+  areaClass: PluginAreaClass,
+  carpet: z60.number(),
+  builtUp: z60.number(),
+  excluded: z60.number(),
+  isVisible: z60.boolean()
 });
-var PluginProgramAreaGroupBy = z54.enum([
+var PluginProgramAreaGroupBy = z60.enum([
   "labels",
   "storeys",
   "buildings",
@@ -2591,29 +2982,29 @@ var PluginProgramAreaGroupBy = z54.enum([
   "tagCategories"
 ]);
 var PluginProgramAreasGetResult = PluginProgramAreaSummary;
-var PluginProgramAreasListArgs = z54.object({
+var PluginProgramAreasListArgs = z60.object({
   groupBy: PluginProgramAreaGroupBy,
-  categoryId: z54.string().optional()
+  categoryId: z60.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 = z60.object({
+  groups: z60.array(PluginProgramAreaGroup)
 });
-var PluginProgramAreasListMembersArgs = z54.object({
+var PluginProgramAreasListMembersArgs = z60.object({
   groupBy: PluginProgramAreaGroupBy,
-  groupId: z54.string(),
-  categoryId: z54.string().optional()
+  groupId: z60.string(),
+  categoryId: z60.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 = z60.object({
+  members: z60.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 = z60.object({
+  targetFar: z60.number().min(0).optional(),
+  siteArea: z60.number().positive().optional(),
+  deviation: z60.number().min(0).max(100).optional()
 });
 var PluginProgramAreasUpdateResult = PluginProgramAreaSummary;
 
@@ -2624,257 +3015,295 @@ var PluginProgramApi = class {
 };
 
 // src/api/presentation/views.ts
-import * as z55 from "zod";
+import * as z61 from "zod";
 var PluginPresentationViewsApi = class {
   constructor() {
   }
 };
-var PluginPresentationViewType = z55.enum(["2d", "3d"]);
-var PluginPresentationView = z55.object({
-  id: z55.string(),
-  name: z55.string(),
+var PluginPresentationViewType = z61.enum(["2d", "3d"]);
+var PluginPresentationView = z61.object({
+  id: z61.string(),
+  name: z61.string(),
   type: PluginPresentationViewType,
-  isActive: z55.boolean()
+  isActive: z61.boolean()
 });
-var PluginPresentationViewsListResult = z55.object({
-  views: z55.array(PluginPresentationView)
+var PluginPresentationViewsListResult = z61.object({
+  views: z61.array(PluginPresentationView)
 });
-var PluginPresentationViewsGetArgs = z55.object({
-  id: z55.string()
+var PluginPresentationViewsGetArgs = z61.object({
+  id: z61.string()
 });
 var PluginPresentationViewsGetResult = PluginPresentationView.nullable();
-var PluginPresentationImageFormat = z55.enum(["png", "jpeg"]);
-var PluginPresentationViewsCaptureArgs = z55.object({
-  viewId: z55.string().optional(),
+var PluginPresentationImageFormat = z61.enum(["png", "jpeg"]);
+var PluginPresentationViewsCaptureArgs = z61.object({
+  viewId: z61.string().optional(),
   format: PluginPresentationImageFormat.optional(),
-  resolution: z55.string().optional()
+  resolution: z61.string().optional()
 });
-var PluginPresentationViewsCaptureResult = z55.object({
-  image: z55.string()
+var PluginPresentationViewsCaptureResult = z61.object({
+  image: z61.string()
 });
-var PluginPresentationViewsSetActiveArgs = z55.object({
-  id: z55.string()
+var PluginPresentationViewsSetActiveArgs = z61.object({
+  id: z61.string()
 });
-var PluginPresentationViewsSetActiveResult = z55.object({
-  id: z55.string()
+var PluginPresentationViewsSetActiveResult = z61.object({
+  id: z61.string()
 });
-var PluginPresentationViewsCreateArgs = z55.object({
-  name: z55.string().optional(),
-  kind: z55.enum(["view", "sitePlan"]).optional()
+var PluginPresentationViewsCreateArgs = z61.object({
+  name: z61.string().optional(),
+  kind: z61.enum(["view", "sitePlan"]).optional()
 });
 var PluginPresentationViewsCreateResult = PluginPresentationView;
+var PluginPresentationViewColorMode = z61.union([
+  z61.enum(["monochrome", "texture", "department"]),
+  z61.templateLiteral(["tag:", z61.string()])
+]);
+var PluginPresentationViewLabel = z61.enum([
+  "objectLabels",
+  "areas",
+  "department"
+]);
+var PluginPresentationViewSettings = z61.object({
+  backgroundColor: z61.string(),
+  colorMode: PluginPresentationViewColorMode,
+  showAxis: z61.boolean(),
+  showEdges: z61.boolean(),
+  showLabels: z61.boolean(),
+  labels: z61.array(PluginPresentationViewLabel)
+});
+var PluginPresentationViewsGetSettingsArgs = z61.object({
+  id: z61.string()
+});
+var PluginPresentationViewsGetSettingsResult = PluginPresentationViewSettings.nullable();
+var PluginPresentationViewsUpdateSettingsArgs = z61.object({
+  id: z61.string(),
+  settings: PluginPresentationViewSettings.partial()
+}).refine(
+  (v) => !(v.settings.showLabels === false && (v.settings.labels?.length ?? 0) > 0),
+  {
+    message: "Contradictory patch: labels cannot be set while showLabels is false"
+  }
+).refine(
+  (v) => !(v.settings.showLabels === true && v.settings.labels !== void 0 && v.settings.labels.length === 0),
+  {
+    message: "Contradictory patch: showLabels cannot be true with an explicitly empty labels list \u2014 pass a non-empty list, or omit labels to apply the defaults"
+  }
+);
+var PluginPresentationViewsUpdateSettingsResult = z61.object({
+  id: z61.string()
+});
 
 // src/api/presentation/sheets.ts
-import * as z56 from "zod";
+import * as z62 from "zod";
 var PluginPresentationSheetsApi = class {
   constructor() {
   }
 };
-var PluginPresentationSheet = z56.object({
-  id: z56.string(),
-  name: z56.string()
+var PluginPresentationSheet = z62.object({
+  id: z62.string(),
+  name: z62.string()
 });
-var PluginSheetPosition = z56.object({
-  x: z56.number(),
-  y: z56.number()
+var PluginSheetPosition = z62.object({
+  x: z62.number(),
+  y: z62.number()
 });
-var PluginPresentationSheetsListResult = z56.object({
-  sheets: z56.array(PluginPresentationSheet)
+var PluginPresentationSheetsListResult = z62.object({
+  sheets: z62.array(PluginPresentationSheet)
 });
-var PluginPresentationSheetsGetArgs = z56.object({
-  id: z56.string()
+var PluginPresentationSheetsGetArgs = z62.object({
+  id: z62.string()
 });
 var PluginPresentationSheetsGetResult = PluginPresentationSheet.nullable();
-var PluginPresentationSheetsCreateArgs = z56.object({
-  name: z56.string().optional()
+var PluginPresentationSheetsCreateArgs = z62.object({
+  name: z62.string().optional()
 });
-var PluginPresentationSheetsPlaceArgs = z56.object({
-  sheetId: z56.string(),
-  viewId: z56.string(),
+var PluginPresentationSheetsPlaceArgs = z62.object({
+  sheetId: z62.string(),
+  viewId: z62.string(),
   position: PluginSheetPosition.optional()
 });
-var PluginPresentationSheetsPlaceResult = z56.object({
-  shapeId: z56.string()
+var PluginPresentationSheetsPlaceResult = z62.object({
+  shapeId: z62.string()
 });
 
 // src/api/presentation/diagrams.ts
-import * as z57 from "zod";
+import * as z63 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 = z63.object({
+  sheetId: z63.string(),
+  urls: z63.array(z63.string()),
+  position: z63.object({ x: z63.number(), y: z63.number() }).optional()
 });
-var PluginPresentationDiagramsPlaceResult = z57.object({
-  shapeIds: z57.array(z57.string())
+var PluginPresentationDiagramsPlaceResult = z63.object({
+  shapeIds: z63.array(z63.string())
 });
 
 // src/api/presentation/import.ts
-import * as z58 from "zod";
+import * as z64 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 = z64.object({
+  url: z64.string().optional(),
+  dataUrl: z64.string().optional(),
+  position: z64.object({ x: z64.number(), y: z64.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 = z64.object({
+  shapeIds: z64.array(z64.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 z65 from "zod";
+var JsonPrimitive = z65.union([z65.string(), z65.number(), z65.boolean(), z65.null()]);
+var JsonValue = z65.lazy(
+  () => z65.union([JsonPrimitive, z65.array(JsonValue), z65.record(z65.string(), JsonValue)])
 );
-var PluginAIInspirationOutputKind = z59.enum([
+var PluginAIInspirationOutputKind = z65.enum([
   "source",
   "image",
   "video"
 ]);
-var PluginAIInspirationModelOutput = z59.enum(["image", "video"]);
-var PluginAIInspirationShapeKind = z59.enum(["image", "view", "video"]);
-var PluginAIInspirationVideoMode = z59.enum([
+var PluginAIInspirationModelOutput = z65.enum(["image", "video"]);
+var PluginAIInspirationShapeKind = z65.enum(["image", "view", "video"]);
+var PluginAIInspirationVideoMode = z65.enum([
   "animate",
   "references",
   "keyframes"
 ]);
-var PluginAIInspirationVideoMotion = z59.enum([
+var PluginAIInspirationVideoMotion = z65.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 = z65.enum(["4s", "6s", "8s"]);
+var PluginAIInspirationRegionHint = z65.object({
+  x: z65.number().finite(),
+  y: z65.number().finite(),
+  w: z65.number().finite().positive(),
+  h: z65.number().finite().positive()
+});
+var PluginAIInspirationPoint = z65.object({
+  x: z65.number().finite(),
+  y: z65.number().finite()
+});
+var PluginAIInspirationTextAnnotation = z65.object({
+  text: z65.string().min(1),
+  x: z65.number().finite().optional(),
+  y: z65.number().finite().optional()
+});
+var PluginAIInspirationSketchGuidance = z65.object({
+  visualShapeIds: z65.array(z65.string()).optional(),
+  textAnnotations: z65.array(PluginAIInspirationTextAnnotation).optional()
+});
+var PluginAIInspirationSiteOptions = z65.object({
+  includeSatellite: z65.boolean().optional(),
+  includeStreetView: z65.boolean().optional(),
+  includeAerial: z65.boolean().optional(),
+  aerialBearing: z65.number().finite().optional(),
+  aerialPitch: z65.number().finite().optional(),
+  selectedDiagramIds: z65.array(z65.string()).optional(),
+  location: z65.object({
+    lat: z65.number().finite(),
+    lng: z65.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 = z65.object({
+  source: z65.enum(["curated", "user"]),
+  presetId: z65.string().min(1),
+  name: z65.string().min(1),
+  savedPresetKind: z65.enum(["prompt", "style"]).optional(),
+  stylePrompt: z65.string().optional(),
+  modelId: z65.string().optional(),
+  referenceImages: z65.array(
+    z65.object({
+      url: z65.string().min(1),
+      label: z65.string().optional(),
+      weight: z65.number().finite().optional()
     })
   ).optional(),
-  siteDefaults: z59.object({
-    includeSatellite: z59.boolean().optional(),
-    includeStreetView: z59.boolean().optional(),
-    includeAerial: z59.boolean().optional()
+  siteDefaults: z65.object({
+    includeSatellite: z65.boolean().optional(),
+    includeStreetView: z65.boolean().optional(),
+    includeAerial: z65.boolean().optional()
   }).optional()
 });
-var PluginAIInspirationVideoOptions = z59.object({
+var PluginAIInspirationVideoOptions = z65.object({
   mode: PluginAIInspirationVideoMode.optional(),
-  endFrameShapeId: z59.string().optional(),
+  endFrameShapeId: z65.string().optional(),
   motion: PluginAIInspirationVideoMotion.optional(),
   duration: PluginAIInspirationVideoDuration.optional()
 });
-var PluginAIInspirationModel = z59.object({
-  id: z59.string(),
-  label: z59.string(),
-  supportsMultiImage: z59.boolean(),
+var PluginAIInspirationModel = z65.object({
+  id: z65.string(),
+  label: z65.string(),
+  supportsMultiImage: z65.boolean(),
   output: PluginAIInspirationModelOutput,
-  isDefault: z59.boolean().optional()
+  isDefault: z65.boolean().optional()
 });
-var PluginAIInspirationListModelsResult = z59.object({
-  defaultModelId: z59.string(),
-  models: z59.array(PluginAIInspirationModel)
+var PluginAIInspirationListModelsResult = z65.object({
+  defaultModelId: z65.string(),
+  models: z65.array(PluginAIInspirationModel)
 });
-var PluginAIInspirationShapeRef = z59.object({
-  shapeId: z59.string(),
-  assetId: z59.string().optional(),
+var PluginAIInspirationShapeRef = z65.object({
+  shapeId: z65.string(),
+  assetId: z65.string().optional(),
   kind: PluginAIInspirationShapeKind,
-  name: z59.string().optional(),
-  width: z59.number().finite().optional(),
-  height: z59.number().finite().optional(),
+  name: z65.string().optional(),
+  width: z65.number().finite().optional(),
+  height: z65.number().finite().optional(),
   outputType: PluginAIInspirationOutputKind.optional(),
-  sourceUrl: z59.string().optional()
+  sourceUrl: z65.string().optional()
 });
-var PluginAIInspirationListSourcesArgs = z59.object({
-  includeGenerated: z59.boolean().optional(),
-  includeSourceUrl: z59.boolean().optional()
+var PluginAIInspirationListSourcesArgs = z65.object({
+  includeGenerated: z65.boolean().optional(),
+  includeSourceUrl: z65.boolean().optional()
 });
-var PluginAIInspirationListSourcesResult = z59.object({
-  sources: z59.array(PluginAIInspirationShapeRef)
+var PluginAIInspirationListSourcesResult = z65.object({
+  sources: z65.array(PluginAIInspirationShapeRef)
 });
-var PluginAIInspirationOutput = z59.object({
-  outputType: z59.enum(["image", "video"]),
-  shapeId: z59.string(),
-  assetId: z59.string(),
-  outputUrl: z59.string().optional(),
+var PluginAIInspirationOutput = z65.object({
+  outputType: z65.enum(["image", "video"]),
+  shapeId: z65.string(),
+  assetId: z65.string(),
+  outputUrl: z65.string().optional(),
   position: PluginAIInspirationPoint.optional()
 });
-var PluginAIInspirationDebugSummary = z59.record(z59.string(), JsonValue);
-var PluginAIInspirationRunMetadata = z59.object({
-  geometryFidelity: z59.string().optional(),
+var PluginAIInspirationDebugSummary = z65.record(z65.string(), JsonValue);
+var PluginAIInspirationRunMetadata = z65.object({
+  geometryFidelity: z65.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: z65.object({
+    used: z65.boolean(),
+    renderMode: z65.enum(["prompt_refs_default", "masked_composite_pilot"]),
+    backgroundLabel: z65.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 = z65.object({
+  sourceShapeId: z65.string().min(1),
+  prompt: z65.string().min(1).max(8e3),
+  modelId: z65.string().optional(),
+  referenceShapeIds: z65.array(z65.string()).max(12).optional(),
+  referenceStrength: z65.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 = z65.object({
+  outputs: z65.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 = z65.object({
+  sourceShapeId: z65.string().min(1),
+  upscaleFactor: z65.union([z65.literal(1.5), z65.literal(2), z65.literal(4)]).optional()
 });
 var PluginPresentationAIInspirationApi = class {
   constructor() {
@@ -2887,32 +3316,299 @@ var PluginPresentationApi = class {
   }
 };
 
+// src/api/analysis/sunpath.ts
+var PluginAnalysisSunpathApi = class {
+  constructor() {
+  }
+};
+
+// src/api/analysis/shadows.ts
+import * as z66 from "zod";
+var PluginAnalysisShadowsApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisShadowsEnableOptions = z66.object({
+  dateTime: z66.string().optional()
+});
+var PluginAnalysisShadowsSetDateTimeArgs = z66.object({
+  dateTime: z66.string()
+});
+var PluginAnalysisShadowsDateTimeResult = z66.string();
+
+// src/api/analysis/sunlightHours.ts
+import * as z67 from "zod";
+var PluginAnalysisSunlightHoursApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisComputeResult = z67.object({
+  success: z67.boolean(),
+  error: z67.string().optional()
+});
+var PluginAnalysisJobStatus = z67.enum([
+  "running",
+  "active",
+  "inactive"
+]);
+var PluginAnalysisJobState = z67.object({
+  status: PluginAnalysisJobStatus,
+  startDate: z67.string(),
+  endDate: z67.string()
+});
+var PluginAnalysisJobStateResult = PluginAnalysisJobState.nullable();
+
+// src/api/analysis/illuminance.ts
+var PluginAnalysisIlluminanceApi = class {
+  constructor() {
+  }
+};
+
+// src/api/analysis/heatmaps.ts
+import * as z68 from "zod";
+var PluginAnalysisHeatmapsApi = class {
+  constructor() {
+  }
+};
+var PluginAnalysisHeatmapSpaceEntry = z68.object({
+  space: ComponentHandle,
+  value: z68.number().finite()
+});
+var PluginAnalysisHeatmapGridCell = z68.object({
+  position: Vec3Components,
+  value: z68.number().finite()
+});
+var PluginAnalysisHeatmapOptions = z68.object({
+  title: z68.string().optional(),
+  unit: z68.string().optional(),
+  min: z68.number().finite().optional(),
+  max: z68.number().finite().optional(),
+  colors: z68.array(z68.string().regex(/^#?[0-9a-fA-F]{6}$/, 'expected a 6-digit hex colour like "#0000ff"')).min(1).optional()
+});
+var PluginAnalysisHeatmapsRenderResult = z68.object({
+  success: z68.literal(true)
+});
+
+// src/api/analysis/index.ts
+var PluginAnalysisApi = class {
+  constructor() {
+  }
+};
+
 // src/api/index.ts
 var PluginApi = class {
   constructor() {
   }
 };
+
+// src/errors/codes.ts
+var PLUGIN_ERROR_CODES = [
+  "VALIDATION",
+  "INVALID_RPC_FORMAT",
+  "METHOD_NOT_FOUND",
+  "METHOD_NOT_PERMITTED",
+  "HANDLE_INVALID",
+  "HANDLE_KIND_MISMATCH",
+  "RESOURCE_QUOTA_EXCEEDED",
+  "RATE_LIMITED",
+  "PRECONDITION_FAILED",
+  "OPERATION_FAILED",
+  "TIMEOUT",
+  "CALL_TIMEOUT",
+  "TRANSPORT_LOST",
+  "PLUGIN_NOT_READY",
+  "PLUGIN_TERMINATED",
+  "RESULT_NOT_SERIALIZABLE",
+  "RESULT_TOO_LARGE",
+  "BATCH_PARTIAL",
+  "STORY_UPDATE_FAILED",
+  "STORY_HEIGHT_REJECTED",
+  "NO_ACTIVE_STRUCTURE",
+  "NO_ELIGIBLE_ELEMENTS",
+  "PROPOSAL_SWITCH_BLOCKED",
+  "INTERNAL",
+  "UNKNOWN"
+];
+var CODE_META = {
+  VALIDATION: {
+    category: "validation",
+    hintTemplate: "Check details.issues for the failing argument."
+  },
+  INVALID_RPC_FORMAT: { category: "validation" },
+  METHOD_NOT_FOUND: {
+    category: "not_found",
+    hintTemplate: "Check details.didYouMean for a close match."
+  },
+  METHOD_NOT_PERMITTED: { category: "permission" },
+  HANDLE_INVALID: {
+    category: "handle",
+    hintTemplate: "Re-query the entity; do not cache handles across undo/reload."
+  },
+  HANDLE_KIND_MISMATCH: { category: "handle" },
+  RESOURCE_QUOTA_EXCEEDED: {
+    category: "quota",
+    hintTemplate: "Release unused handles (core.handles.release) or use scopes."
+  },
+  RATE_LIMITED: {
+    category: "quota",
+    hintTemplate: "Wait details.retryAfterMs before retrying."
+  },
+  PRECONDITION_FAILED: { category: "execution" },
+  OPERATION_FAILED: { category: "execution" },
+  TIMEOUT: { category: "timeout" },
+  CALL_TIMEOUT: { category: "timeout" },
+  TRANSPORT_LOST: { category: "transport" },
+  PLUGIN_NOT_READY: { category: "lifecycle" },
+  PLUGIN_TERMINATED: { category: "lifecycle" },
+  RESULT_NOT_SERIALIZABLE: { category: "execution" },
+  RESULT_TOO_LARGE: { category: "execution" },
+  BATCH_PARTIAL: { category: "execution" },
+  STORY_UPDATE_FAILED: {
+    category: "execution",
+    hintTemplate: "The storey update could not be applied; re-read the storey and retry."
+  },
+  STORY_HEIGHT_REJECTED: {
+    category: "execution",
+    hintTemplate: "The requested height was out of range; pick a value within the storey's limits."
+  },
+  NO_ACTIVE_STRUCTURE: {
+    category: "execution",
+    hintTemplate: "Activate a structure before running this operation."
+  },
+  NO_ELIGIBLE_ELEMENTS: {
+    category: "execution",
+    hintTemplate: "The storey has no elements eligible for this operation."
+  },
+  PROPOSAL_SWITCH_BLOCKED: {
+    category: "execution",
+    hintTemplate: "Wait for the in-canvas agent run to finish, then retry."
+  },
+  INTERNAL: {
+    category: "internal",
+    hintTemplate: "Host-side fault. Report with errorId."
+  },
+  UNKNOWN: { category: "internal" }
+};
+function isPluginErrorCode(value) {
+  return PLUGIN_ERROR_CODES.includes(value);
+}
+
+// src/errors/envelope.ts
+var ERROR_ENVELOPE_VERSION = 1;
+function isErrorEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record5 = value;
+  return record5.envelopeVersion === ERROR_ENVELOPE_VERSION && typeof record5.code === "string" && typeof record5.message === "string" && typeof record5.errorId === "string";
+}
+var idCounter = 0;
+function newErrorId(prefix = "") {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.randomUUID) return `${prefix}${cryptoApi.randomUUID()}`;
+  idCounter += 1;
+  return `${prefix}${Date.now().toString(36)}-${idCounter}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/errors/plugin-error.ts
+var BRAND = /* @__PURE__ */ Symbol.for("snaptrude.pluginError");
+var PluginError = class extends Error {
+  constructor(envelope) {
+    super(envelope.message);
+    this.name = new.target.name;
+    this.code = envelope.code;
+    this.errorId = envelope.errorId;
+    this.details = envelope.details;
+    this.handle = envelope.handle;
+    this.methodPath = envelope.methodPath;
+    this.hint = envelope.hint ?? hintFor(envelope.code);
+    this[BRAND] = true;
+  }
+  /** Canonical check — survives bundled duplicate SDK copies where `instanceof` fails. */
+  static is(value) {
+    return typeof value === "object" && value !== null && value[BRAND] === true;
+  }
+  /** Derived (not wire-carried) family of the code; unknown codes map to "internal". */
+  get category() {
+    return isPluginErrorCode(this.code) ? CODE_META[this.code].category : "internal";
+  }
+};
+var PluginValidationError = class extends PluginError {
+};
+var PluginNotFoundError = class extends PluginError {
+};
+var PluginPermissionError = class extends PluginError {
+};
+var PluginHandleError = class extends PluginError {
+};
+var PluginQuotaError = class extends PluginError {
+};
+var PluginTimeoutError = class extends PluginError {
+};
+var PluginTransportError = class extends PluginError {
+};
+var PluginLifecycleError = class extends PluginError {
+};
+var PluginExecutionError = class extends PluginError {
+};
+var PluginInternalError = class extends PluginError {
+};
+var CATEGORY_CLASS = {
+  validation: PluginValidationError,
+  not_found: PluginNotFoundError,
+  permission: PluginPermissionError,
+  handle: PluginHandleError,
+  quota: PluginQuotaError,
+  timeout: PluginTimeoutError,
+  transport: PluginTransportError,
+  lifecycle: PluginLifecycleError,
+  execution: PluginExecutionError,
+  internal: PluginInternalError
+};
+function hintFor(code) {
+  return isPluginErrorCode(code) ? CODE_META[code].hintTemplate : void 0;
+}
+function fromEnvelope(envelope) {
+  if (!isPluginErrorCode(envelope.code)) return new PluginError(envelope);
+  const ErrorClass = CATEGORY_CLASS[CODE_META[envelope.code].category];
+  return new ErrorClass(envelope);
+}
+function makeClientEnvelope(code, message, extra) {
+  return {
+    envelopeVersion: ERROR_ENVELOPE_VERSION,
+    code,
+    message,
+    errorId: newErrorId("c-"),
+    ...extra
+  };
+}
 export {
   ArcHandle,
   BBoxComponents,
   BooleanOptions,
   BooleanOutcome,
   BrepHandle,
+  CODE_META,
+  CadJsonInput,
   CircleHandle,
   CommentHandle,
   ComponentHandle,
   ContourHandle,
   CurveHandle,
   DEFAULT_ERASE_STRATEGIES,
+  ERROR_ENVELOPE_VERSION,
   EdgeHandle,
   ErasableEdgeRef,
   EraseStrategy,
   FaceHandle,
   HalfEdgeHandle,
+  ImportJobHandle,
+  ImportJobStatus,
+  ImportSource,
   LineHandle,
   MassHandle,
   MaterialHandle,
+  ModelFormat,
   OffsetSplitOutcome,
+  PLUGIN_ERROR_CODES,
   PUnitType,
   PluginAIInspirationAppliedPreset,
   PluginAIInspirationDebugSummary,
@@ -2939,6 +3635,24 @@ export {
   PluginAIInspirationVideoMotion,
   PluginAIInspirationVideoOptions,
   PluginAdjacencyLevel,
+  PluginAlignEdge,
+  PluginAnalysisApi,
+  PluginAnalysisComputeResult,
+  PluginAnalysisHeatmapGridCell,
+  PluginAnalysisHeatmapOptions,
+  PluginAnalysisHeatmapSpaceEntry,
+  PluginAnalysisHeatmapsApi,
+  PluginAnalysisHeatmapsRenderResult,
+  PluginAnalysisIlluminanceApi,
+  PluginAnalysisJobState,
+  PluginAnalysisJobStateResult,
+  PluginAnalysisJobStatus,
+  PluginAnalysisShadowsApi,
+  PluginAnalysisShadowsDateTimeResult,
+  PluginAnalysisShadowsEnableOptions,
+  PluginAnalysisShadowsSetDateTimeArgs,
+  PluginAnalysisSunlightHoursApi,
+  PluginAnalysisSunpathApi,
   PluginApi,
   PluginAreaClass,
   PluginAreaUnit,
@@ -2998,6 +3712,12 @@ export {
   PluginCoreGroupsListResult,
   PluginCoreGroupsUpdateArgs,
   PluginCoreGroupsUpdateResult,
+  PluginCoreIoApi,
+  PluginCoreIoImportApi,
+  PluginCoreIoJobApi,
+  PluginCoreIoQueryApi,
+  PluginCoreIoTerrainApi,
+  PluginCoreIoUnderlayApi,
   PluginCoreLayer,
   PluginCoreLayerType,
   PluginCoreLayersApi,
@@ -3011,6 +3731,23 @@ export {
   PluginCoreLayersSetActiveResult,
   PluginCoreLayersUpdateArgs,
   PluginCoreLayersUpdateResult,
+  PluginCoreProposalRef,
+  PluginCoreProposalsApi,
+  PluginCoreProposalsCreateArgs,
+  PluginCoreProposalsCreateResult,
+  PluginCoreProposalsDeleteArgs,
+  PluginCoreProposalsDeleteResult,
+  PluginCoreProposalsGetActiveResult,
+  PluginCoreProposalsGetArgs,
+  PluginCoreProposalsGetResult,
+  PluginCoreProposalsIsActiveArgs,
+  PluginCoreProposalsListForComponentArgs,
+  PluginCoreProposalsListForComponentResult,
+  PluginCoreProposalsListResult,
+  PluginCoreProposalsRenameArgs,
+  PluginCoreProposalsRenameResult,
+  PluginCoreProposalsSetActiveArgs,
+  PluginCoreProposalsSetActiveResult,
   PluginCoreTag,
   PluginCoreTagCategory,
   PluginCoreTagsApi,
@@ -3043,6 +3780,7 @@ export {
   PluginCoreTagsUpdateResult,
   PluginCreateSpaceItem,
   PluginDepartmentId,
+  PluginDesignAlignArgs,
   PluginDesignApi,
   PluginDesignBooleanApi,
   PluginDesignBooleanIntersectArgs,
@@ -3054,6 +3792,7 @@ export {
   PluginDesignCreateCeilingArgs,
   PluginDesignCreateColumnArgs,
   PluginDesignCreateCopyArgs,
+  PluginDesignCreateDoorArgs,
   PluginDesignCreateFloorArgs,
   PluginDesignCreateFurnitureArgs,
   PluginDesignCreateMassArgs,
@@ -3063,9 +3802,13 @@ export {
   PluginDesignCreateSpaceArgs,
   PluginDesignCreateStaircaseArgs,
   PluginDesignCreateWallsArgs,
+  PluginDesignCreateWindowArgs,
   PluginDesignDeleteApi,
   PluginDesignDeleteEntitiesArgs,
   PluginDesignDoorArgs,
+  PluginDesignDoorExistsArgs,
+  PluginDesignDoorGetCatalogItemArgs,
+  PluginDesignDoorListCatalogArgs,
   PluginDesignDoorMirrorArgs,
   PluginDesignDoorSetHeightArgs,
   PluginDesignDoorSetWidthArgs,
@@ -3078,16 +3821,22 @@ export {
   PluginDesignFurnitureExistsArgs,
   PluginDesignFurnitureGetCatalogItemArgs,
   PluginDesignFurnitureListCatalogArgs,
+  PluginDesignIsAreaLockedArgs,
   PluginDesignIsLockedArgs,
   PluginDesignListErasableEdgesArgs,
+  PluginDesignLockAreaArgs,
   PluginDesignLockArgs,
   PluginDesignMaterialsApi,
   PluginDesignMaterialsApplyArgs,
+  PluginDesignMaterialsApplyToFacesArgs,
   PluginDesignMaterialsComponentArgs,
   PluginDesignMaterialsCreateArgs,
+  PluginDesignMaterialsGetByFaceArgs,
   PluginDesignMaterialsGetInfoArgs,
   PluginDesignMaterialsListArgs,
+  PluginDesignMaterialsListByFaceArgs,
   PluginDesignMaterialsResetArgs,
+  PluginDesignMaterialsResetFacesArgs,
   PluginDesignMoveArgs,
   PluginDesignOffsetSplitArgs,
   PluginDesignQueryApi,
@@ -3109,10 +3858,16 @@ export {
   PluginDesignSelectionApi,
   PluginDesignSelectionRemoveArgs,
   PluginDesignSelectionSetArgs,
+  PluginDesignSetLabelArgs,
   PluginDesignTransformApi,
+  PluginDesignUnlockAreaArgs,
   PluginDesignUnlockArgs,
   PluginDesignUpdateApi,
+  PluginDesignUpdateStaircaseArgs,
   PluginDesignWindowArgs,
+  PluginDesignWindowExistsArgs,
+  PluginDesignWindowGetCatalogItemArgs,
+  PluginDesignWindowListCatalogArgs,
   PluginDesignWindowSetHeightArgs,
   PluginDesignWindowSetWidthArgs,
   PluginDesignWindowsApi,
@@ -3121,6 +3876,9 @@ export {
   PluginEntityMeasurements,
   PluginEntityProperties,
   PluginEntityType,
+  PluginError,
+  PluginExecutionError,
+  PluginFaceMaterial,
   PluginFurnitureCatalogItem,
   PluginGeomApi,
   PluginGeomCreateApi,
@@ -3298,15 +4056,29 @@ export {
   PluginGeomUpdateProfileSimplifyArgs,
   PluginGridApi,
   PluginGridValueArgs,
+  PluginHandleError,
   PluginHistoryApi,
   PluginHistoryStepArgs,
   PluginHistoryStepResult,
+  PluginImportCadJsonArgs,
+  PluginImportDwgArgs,
+  PluginImportImageArgs,
+  PluginImportJobArgs,
+  PluginImportModelArgs,
+  PluginImportPdfArgs,
+  PluginImportTerrainArgs,
+  PluginInternalError,
+  PluginLifecycleError,
   PluginMassType,
   PluginMaterialInfo,
   PluginMaterialResult,
   PluginMaterialSpec,
   PluginMathApi,
   PluginMirrorAxis,
+  PluginNotFoundError,
+  PluginObjectCatalogGroup,
+  PluginObjectCatalogItem,
+  PluginPermissionError,
   PluginPresentationAIInspirationApi,
   PluginPresentationApi,
   PluginPresentationDiagramsApi,
@@ -3325,6 +4097,9 @@ export {
   PluginPresentationSheetsPlaceArgs,
   PluginPresentationSheetsPlaceResult,
   PluginPresentationView,
+  PluginPresentationViewColorMode,
+  PluginPresentationViewLabel,
+  PluginPresentationViewSettings,
   PluginPresentationViewType,
   PluginPresentationViewsApi,
   PluginPresentationViewsCaptureArgs,
@@ -3333,9 +4108,13 @@ export {
   PluginPresentationViewsCreateResult,
   PluginPresentationViewsGetArgs,
   PluginPresentationViewsGetResult,
+  PluginPresentationViewsGetSettingsArgs,
+  PluginPresentationViewsGetSettingsResult,
   PluginPresentationViewsListResult,
   PluginPresentationViewsSetActiveArgs,
   PluginPresentationViewsSetActiveResult,
+  PluginPresentationViewsUpdateSettingsArgs,
+  PluginPresentationViewsUpdateSettingsResult,
   PluginProgramAdjacencyApi,
   PluginProgramAdjacencyComputeResult,
   PluginProgramAdjacencyGetMatrixArgs,
@@ -3384,7 +4163,11 @@ export {
   PluginProgramDepartmentsUpdateArgs,
   PluginProgramDepartmentsUpdateResult,
   PluginProgramLayoutApi,
+  PluginProgramLayoutJobState,
+  PluginProgramLayoutJobStatus,
+  PluginProgramLayoutRunArgs,
   PluginProgramLayoutRunResult,
+  PluginProgramLayoutStateResult,
   PluginProgramMetricsApi,
   PluginProgramMetricsSummary,
   PluginProgramSiteApi,
@@ -3393,6 +4176,9 @@ export {
   PluginProgramSiteContextResult,
   PluginProgramSiteListGeoPolygonsResult,
   PluginProgramSiteListPolygonsResult,
+  PluginProgramSiteLocation,
+  PluginProgramSiteLocationResult,
+  PluginProgramSiteNorthAngleResult,
   PluginProgramSiteSnapshot,
   PluginProgramSpreadsheetAddChartArgs,
   PluginProgramSpreadsheetAddChartResult,
@@ -3444,6 +4230,9 @@ export {
   PluginProjectApi,
   PluginProjectSettingsApi,
   PluginQuatApi,
+  PluginQueryCadLayersArgs,
+  PluginQueryPdfPageCountArgs,
+  PluginQuotaError,
   PluginReferenceLineApi,
   PluginReferenceLineCreateMultiArgs,
   PluginReferenceLineCreateMultiResult,
@@ -3453,6 +4242,8 @@ export {
   PluginReferenceLineGetProperty,
   PluginReferenceLineGetResult,
   PluginReferenceLineStyle,
+  PluginSelectionEntityType,
+  PluginSelectionFilter,
   PluginSheetPosition,
   PluginSiteBounds,
   PluginSiteContextParcel,
@@ -3461,6 +4252,8 @@ export {
   PluginSiteLatLng,
   PluginSitePolygon,
   PluginSlabType,
+  PluginSmartLayoutArgs,
+  PluginSmartLayoutResult,
   PluginSnapValueArgs,
   PluginSnapsApi,
   PluginSpaceBulkCreateArgs,
@@ -3517,21 +4310,36 @@ export {
   PluginSpreadsheetTransactionOp,
   PluginSpreadsheetVerticalAlign,
   PluginSpreadsheetWhenExists,
+  PluginStaircaseParamUpdates,
+  PluginStaircaseParams,
   PluginStaircasePreset,
   PluginStoryApi,
   PluginStoryCreateArgs,
   PluginStoryCreateResult,
+  PluginStoryDuplicateArgs,
+  PluginStoryDuplicateResult,
   PluginStoryGetAllResult,
   PluginStoryGetArgs,
   PluginStoryGetProperty,
   PluginStoryGetResult,
   PluginStoryUpdateArgs,
   PluginStoryUpdateResult,
+  PluginTerrainSetDatumArgs,
+  PluginTerrainSetOpacityArgs,
+  PluginTimeoutError,
   PluginToleranceArgs,
+  PluginTransportError,
+  PluginUnderlayListArgs,
+  PluginUnderlayPlanSize,
+  PluginUnderlayRefArgs,
+  PluginUnderlaySetOpacityArgs,
+  PluginUnderlaySetScaleArgs,
+  PluginUnderlaySetScaleValue,
   PluginUnitsApi,
   PluginUnitsConvertArgs,
   PluginUnitsSetTypeArgs,
   PluginUpdateSpaceItem,
+  PluginValidationError,
   PluginVec3Api,
   PluginWellKnownDepartmentId,
   PluginWindowDimensions,
@@ -3539,9 +4347,17 @@ export {
   ProfileHandle,
   QuatComponents,
   QuatHandle,
+  TerrainHandle,
+  TerrainReport,
+  UnderlayHandle,
   Vec3Components,
   Vec3Handle,
   VertexHandle,
-  handleSchema
+  fromEnvelope,
+  handleSchema,
+  isErrorEnvelope,
+  isPluginErrorCode,
+  makeClientEnvelope,
+  newErrorId
 };
 //# sourceMappingURL=index.js.map