@snaptrude/plugin-core 0.0.0-dev-20260708130115

package/dist/index.js

@@ -0,0 +1,3870 @@
+// src/api/core/math/vec3.ts
+var PluginVec3Api = class {
+  constructor() {
+  }
+};
+
+// src/api/core/math/quat.ts
+var PluginQuatApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/math/index.ts
+var PluginMathApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/geom/create/index.ts
+import * as z2 from "zod";
+
+// src/handles.ts
+import * as z from "zod";
+var handleSchema = (kind) => z.string().regex(new RegExp(`^${kind}_[A-Za-z0-9_-]+$`), `expected a "${kind}" handle`).transform((s) => s);
+var ProfileHandle = handleSchema("profile");
+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 Vec3Handle = handleSchema("vec3");
+var QuatHandle = handleSchema("quat");
+var LineHandle = handleSchema("line");
+var ArcHandle = handleSchema("arc");
+var CurveHandle = z.union([LineHandle, ArcHandle]);
+var CircleHandle = handleSchema("circle");
+var BrepHandle = handleSchema("brep");
+var FaceHandle = handleSchema("face");
+var EdgeHandle = handleSchema("edge");
+var HalfEdgeHandle = handleSchema("halfedge");
+var VertexHandle = handleSchema("vertex");
+var Vec3Components = z.object({ x: z.number(), y: z.number(), z: z.number() });
+var QuatComponents = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number(),
+  w: z.number()
+});
+var BBoxComponents = z.object({ min: Vec3Components, max: Vec3Components });
+
+// src/api/core/geom/create/index.ts
+var PluginGeomCreateApi = class {
+  constructor() {
+  }
+};
+var PluginGeomCreateLineArgs = z2.object({
+  startPoint: Vec3Handle,
+  endPoint: Vec3Handle
+});
+var PluginGeomCreateArcArgs = z2.object({
+  startPoint: Vec3Handle,
+  endPoint: Vec3Handle,
+  centrePoint: Vec3Handle,
+  axis: Vec3Handle
+});
+var PluginGeomCreateCircleArgs = z2.object({
+  centrePoint: Vec3Handle,
+  axis: Vec3Handle,
+  radius: z2.number()
+});
+var PluginGeomCreateProfileFromLinePointsArgs = z2.object({
+  points: z2.array(Vec3Handle)
+});
+var PluginGeomCreateProfileFromCurvesArgs = z2.object({
+  curves: z2.array(CurveHandle)
+});
+var PluginGeomCreateContourFromProfileArgs = z2.object({
+  outer: ProfileHandle
+});
+var PluginGeomCreateContourFromProfilesArgs = z2.object({
+  outer: ProfileHandle,
+  holes: z2.array(ProfileHandle).optional()
+});
+
+// src/api/core/geom/query/curve.ts
+import * as z3 from "zod";
+var PluginGeomQueryCurveApi = class {
+  constructor() {
+  }
+};
+var PluginGeomQueryCurveGetStartPointArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveGetEndPointArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveGetMidPointArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveGetLengthArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveGetChordLengthArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveGetTangentArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetNormalArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetNearestPointArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetProjectionArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetPointAtDistanceArgs = z3.object({
+  curve: CurveHandle,
+  referencePoint: Vec3Handle,
+  distance: z3.number(),
+  forward: z3.boolean().optional()
+});
+var PluginGeomQueryCurveGetParameterAtPointArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetCurvatureArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetDistanceToPointArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCurveGetDistanceAlongArgs = z3.object({
+  curve: CurveHandle,
+  pointA: Vec3Handle,
+  pointB: Vec3Handle
+});
+var PluginGeomQueryCurveListPointsArgs = z3.object({
+  curve: CurveHandle,
+  resolution: z3.number().optional()
+});
+var PluginGeomQueryCurveListSubdivisionsArgs = z3.object({
+  curve: CurveHandle,
+  segments: z3.number()
+});
+var PluginGeomQueryCurveIsLinearArgs = z3.object({
+  curve: CurveHandle
+});
+var PluginGeomQueryCurveIsOnCurveArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle,
+  threshold: z3.number().optional()
+});
+var PluginGeomQueryCurveHasPointArgs = z3.object({
+  curve: CurveHandle,
+  point: Vec3Handle,
+  includeEndPoints: z3.boolean().optional()
+});
+var PluginGeomQueryCurveIsEqualArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle
+});
+var PluginGeomQueryCurveIsOverlappingArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle,
+  includeEndPoints: z3.boolean().optional()
+});
+var PluginGeomQueryCurveGetCommonPartArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle
+});
+var PluginGeomQueryCurveListIntersectionsArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle,
+  boundedA: z3.boolean().optional(),
+  boundedB: z3.boolean().optional()
+});
+var PluginGeomQueryCurveGetMergedCurveArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle
+});
+var PluginGeomQueryCurveIsContinuousArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle
+});
+var PluginGeomQueryCurveIsParallelArgs = z3.object({
+  lineA: LineHandle,
+  lineB: LineHandle,
+  tolerance: z3.number().optional()
+});
+var PluginGeomQueryCurveGetShortestGapArgs = z3.object({
+  curveA: CurveHandle,
+  curveB: CurveHandle,
+  includeEndPoints: z3.boolean().optional()
+});
+var PluginGeomQueryCurveGetDistanceBetweenArgs = z3.object({
+  lineA: LineHandle,
+  lineB: LineHandle
+});
+
+// src/api/core/geom/query/arc.ts
+import * as z4 from "zod";
+var PluginGeomQueryArcApi = class {
+  constructor() {
+  }
+};
+var PluginGeomQueryArcGetRadiusArgs = z4.object({ arc: ArcHandle });
+var PluginGeomQueryArcGetCentreArgs = z4.object({ arc: ArcHandle });
+var PluginGeomQueryArcGetAxisArgs = z4.object({ arc: ArcHandle });
+var PluginGeomQueryArcGetSweepAngleArgs = z4.object({ arc: ArcHandle });
+var PluginGeomQueryArcIsValidArgs = z4.object({ arc: ArcHandle });
+
+// src/api/core/geom/query/circle.ts
+import * as z5 from "zod";
+var PluginGeomQueryCircleApi = class {
+  constructor() {
+  }
+};
+var PluginGeomQueryCircleGetRadiusArgs = z5.object({ circle: CircleHandle });
+var PluginGeomQueryCircleGetCentreArgs = z5.object({ circle: CircleHandle });
+var PluginGeomQueryCircleGetAxisArgs = z5.object({ circle: CircleHandle });
+var PluginGeomQueryCircleGetLengthArgs = z5.object({ circle: CircleHandle });
+var PluginGeomQueryCircleIsValidArgs = z5.object({ circle: CircleHandle });
+var PluginGeomQueryCircleGetNearestPointArgs = z5.object({
+  circle: CircleHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCircleHasPointArgs = z5.object({
+  circle: CircleHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCircleGetTangentArgs = z5.object({
+  circle: CircleHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCircleGetNormalArgs = z5.object({
+  circle: CircleHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryCircleGetPointAtDistanceArgs = z5.object({
+  circle: CircleHandle,
+  referencePoint: Vec3Handle,
+  distance: z5.number(),
+  forward: z5.boolean().optional()
+});
+var PluginGeomQueryCircleIsEqualArgs = z5.object({
+  circleA: CircleHandle,
+  circleB: CircleHandle
+});
+var PluginGeomQueryCircleListPointsArgs = z5.object({
+  circle: CircleHandle,
+  resolution: z5.number().optional()
+});
+
+// src/api/core/geom/query/profile.ts
+import * as z6 from "zod";
+var PluginGeomQueryProfileApi = class {
+  constructor() {
+  }
+};
+var PluginGeomQueryProfileListPointsArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileListCurvesArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileGetAreaArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileGetPerimeterArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileGetBoundingBoxArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileGetNormalArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileGetNearestPointArgs = z6.object({
+  profile: ProfileHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryProfileHasPointArgs = z6.object({
+  profile: ProfileHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryProfileIsOnBoundaryArgs = z6.object({
+  profile: ProfileHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryProfileIsClosedArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileIsPlanarArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileIsClockwiseArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileIsSelfIntersectingArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileIsEmptyArgs = z6.object({
+  profile: ProfileHandle
+});
+var PluginGeomQueryProfileIsEqualArgs = z6.object({
+  profileA: ProfileHandle,
+  profileB: ProfileHandle
+});
+
+// src/api/core/geom/query/contour.ts
+import * as z7 from "zod";
+var PluginGeomQueryContourApi = class {
+  constructor() {
+  }
+};
+var PluginGeomQueryContourGetOuterProfileArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourListHolesArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetHoleCountArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetAreaArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetPerimeterArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetBoundingBoxArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetNormalArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourGetNearestPointArgs = z7.object({
+  contour: ContourHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryContourHasPointArgs = z7.object({
+  contour: ContourHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryContourIsOnBoundaryArgs = z7.object({
+  contour: ContourHandle,
+  point: Vec3Handle
+});
+var PluginGeomQueryContourIsClockwiseArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourIsPlanarArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourIsEmptyArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourIsSelfIntersectingArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourIsOrientationValidArgs = z7.object({
+  contour: ContourHandle
+});
+var PluginGeomQueryContourIsEqualArgs = z7.object({
+  contourA: ContourHandle,
+  contourB: ContourHandle
+});
+
+// src/api/core/geom/query/brep.ts
+import * as z8 from "zod";
+var PluginGeomQueryBrepApi = class {
+  constructor() {
+  }
+};
+var brepArg = z8.object({ brep: BrepHandle });
+var brepEdgeArg = z8.object({
+  brep: BrepHandle,
+  vertexIndexA: z8.number(),
+  vertexIndexB: z8.number()
+});
+var PluginGeomQueryBrepListFacesArgs = brepArg;
+var PluginGeomQueryBrepListEdgesArgs = brepArg;
+var PluginGeomQueryBrepListVerticesArgs = brepArg;
+var PluginGeomQueryBrepListHalfEdgesArgs = brepArg;
+var PluginGeomQueryBrepGetEdgeArgs = brepEdgeArg;
+var PluginGeomQueryBrepHasEdgeArgs = brepEdgeArg;
+var PluginGeomQueryBrepListEdgesBetweenArgs = brepEdgeArg;
+var PluginGeomQueryBrepGetVertexPositionArgs = z8.object({
+  brep: BrepHandle,
+  vertex: VertexHandle
+});
+var PluginGeomQueryBrepListVertexPositionsArgs = brepArg;
+var PluginGeomQueryBrepGetCentroidArgs = brepArg;
+var PluginGeomQueryBrepGetFaceCountArgs = brepArg;
+var PluginGeomQueryBrepGetEdgeCountArgs = brepArg;
+var PluginGeomQueryBrepGetVertexCountArgs = brepArg;
+var PluginGeomQueryBrepGetHalfEdgeCountArgs = brepArg;
+var PluginGeomQueryBrepGetBoundingBoxArgs = brepArg;
+var PluginGeomQueryBrepIsEqualArgs = z8.object({
+  brepA: BrepHandle,
+  brepB: BrepHandle
+});
+
+// src/api/core/geom/query/face.ts
+import * as z9 from "zod";
+var PluginGeomQueryFaceApi = class {
+  constructor() {
+  }
+};
+var faceArg = z9.object({ face: FaceHandle });
+var PluginGeomQueryFaceGetIndexArgs = faceArg;
+var PluginGeomQueryFaceGetMaterialIndexArgs = faceArg;
+var PluginGeomQueryFaceGetHalfEdgeArgs = faceArg;
+var PluginGeomQueryFaceListEdgesArgs = faceArg;
+var PluginGeomQueryFaceListHalfEdgesArgs = faceArg;
+var PluginGeomQueryFaceListVerticesArgs = faceArg;
+var PluginGeomQueryFaceListHolesArgs = faceArg;
+var PluginGeomQueryFaceGetHoleCountArgs = faceArg;
+var PluginGeomQueryFaceListHoleHalfEdgesArgs = z9.object({
+  face: FaceHandle,
+  holeIndex: z9.number()
+});
+var PluginGeomQueryFaceHasHolesArgs = faceArg;
+var PluginGeomQueryFaceGetHoleContainingHalfEdgeArgs = z9.object({
+  face: FaceHandle,
+  halfEdge: HalfEdgeHandle
+});
+var PluginGeomQueryFaceListVertexPositionsArgs = z9.object({
+  face: FaceHandle,
+  brep: BrepHandle
+});
+var PluginGeomQueryFaceListVertexPositionsWithCurvesArgs = faceArg;
+var PluginGeomQueryFaceListAdjacentFacesArgs = faceArg;
+
+// src/api/core/geom/query/edge.ts
+import * as z10 from "zod";
+var PluginGeomQueryEdgeApi = class {
+  constructor() {
+  }
+};
+var edgeArg = z10.object({ edge: EdgeHandle });
+var PluginGeomQueryEdgeGetIndexArgs = edgeArg;
+var PluginGeomQueryEdgeGetHalfEdgeArgs = edgeArg;
+var PluginGeomQueryEdgeListVerticesArgs = edgeArg;
+var PluginGeomQueryEdgeGetCurveArgs = edgeArg;
+var PluginGeomQueryEdgeListFacesArgs = edgeArg;
+
+// src/api/core/geom/query/halfedge.ts
+import * as z11 from "zod";
+var PluginGeomQueryHalfEdgeApi = class {
+  constructor() {
+  }
+};
+var heArg = z11.object({ halfEdge: HalfEdgeHandle });
+var PluginGeomQueryHalfEdgeGetNextArgs = heArg;
+var PluginGeomQueryHalfEdgeGetPrevArgs = heArg;
+var PluginGeomQueryHalfEdgeGetFlipArgs = heArg;
+var PluginGeomQueryHalfEdgeGetVertexArgs = heArg;
+var PluginGeomQueryHalfEdgeGetEdgeArgs = heArg;
+var PluginGeomQueryHalfEdgeGetFaceArgs = heArg;
+var PluginGeomQueryHalfEdgeIsOnBoundaryArgs = heArg;
+var PluginGeomQueryHalfEdgeIsForwardArgs = heArg;
+
+// src/api/core/geom/query/vertex.ts
+import * as z12 from "zod";
+var PluginGeomQueryVertexApi = class {
+  constructor() {
+  }
+};
+var vertexArg = z12.object({ vertex: VertexHandle });
+var PluginGeomQueryVertexGetIndexArgs = vertexArg;
+var PluginGeomQueryVertexGetHalfEdgeArgs = vertexArg;
+var PluginGeomQueryVertexGetPositionArgs = z12.object({
+  brep: BrepHandle,
+  vertex: VertexHandle
+});
+var PluginGeomQueryVertexListHalfEdgesArgs = vertexArg;
+var PluginGeomQueryVertexListEdgesArgs = vertexArg;
+var PluginGeomQueryVertexListFacesArgs = vertexArg;
+var PluginGeomQueryVertexListNeighborsArgs = vertexArg;
+
+// src/api/core/geom/query/index.ts
+var PluginGeomQueryApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/geom/update/curve.ts
+import * as z13 from "zod";
+var PluginGeomUpdateCurveApi = class {
+  constructor() {
+  }
+};
+var PluginGeomUpdateCurveExtendArgs = z13.object({
+  curve: CurveHandle,
+  distance: z13.number(),
+  fromStart: z13.boolean()
+});
+var PluginGeomUpdateCurveSplitArgs = z13.object({
+  curve: CurveHandle,
+  point: Vec3Handle
+});
+var PluginGeomUpdateCurveTrimArgs = z13.object({
+  curve: CurveHandle,
+  startParam: z13.number(),
+  endParam: z13.number()
+});
+var PluginGeomUpdateCurveOffsetArgs = z13.object({
+  curve: CurveHandle,
+  vector: Vec3Handle
+});
+var PluginGeomUpdateCurveReverseArgs = z13.object({
+  curve: CurveHandle
+});
+
+// src/api/core/geom/update/profile.ts
+import * as z14 from "zod";
+var PluginGeomUpdateProfileApi = class {
+  constructor() {
+  }
+};
+var PluginGeomUpdateProfileOffsetArgs = z14.object({
+  profile: ProfileHandle,
+  distance: z14.number()
+});
+var PluginGeomUpdateProfileMoveArgs = z14.object({
+  profile: ProfileHandle,
+  translation: Vec3Handle
+});
+var PluginGeomUpdateProfileRotateArgs = z14.object({
+  profile: ProfileHandle,
+  axis: Vec3Handle,
+  angle: z14.number(),
+  pivot: Vec3Handle.optional()
+});
+var PluginGeomUpdateProfileScaleArgs = z14.object({
+  profile: ProfileHandle,
+  factor: z14.union([z14.number(), Vec3Components]),
+  pivot: Vec3Handle.optional()
+});
+var PluginGeomUpdateProfileMirrorArgs = z14.object({
+  profile: ProfileHandle,
+  plane: z14.object({
+    point: Vec3Handle,
+    normal: Vec3Handle
+  })
+});
+var PluginGeomUpdateProfileAddArgs = z14.object({
+  profile: ProfileHandle,
+  curve: CurveHandle,
+  position: z14.enum(["start", "end"]).optional()
+});
+var PluginGeomUpdateProfileRemoveArgs = z14.object({
+  profile: ProfileHandle,
+  position: z14.enum(["start", "end"]).optional()
+});
+var PluginGeomUpdateProfileReverseArgs = z14.object({
+  profile: ProfileHandle
+});
+var PluginGeomUpdateProfileSimplifyArgs = z14.object({
+  profile: ProfileHandle
+});
+
+// src/api/core/geom/update/contour.ts
+import * as z15 from "zod";
+var PluginGeomUpdateContourApi = class {
+  constructor() {
+  }
+};
+var PluginGeomUpdateContourOffsetArgs = z15.object({
+  contour: ContourHandle,
+  distance: z15.number()
+});
+var PluginGeomUpdateContourMoveArgs = z15.object({
+  contour: ContourHandle,
+  translation: Vec3Handle
+});
+var PluginGeomUpdateContourRotateArgs = z15.object({
+  contour: ContourHandle,
+  axis: Vec3Handle,
+  angle: z15.number(),
+  pivot: Vec3Handle.optional()
+});
+var PluginGeomUpdateContourScaleArgs = z15.object({
+  contour: ContourHandle,
+  factor: z15.union([z15.number(), Vec3Components]),
+  pivot: Vec3Handle.optional()
+});
+var PluginGeomUpdateContourMirrorArgs = z15.object({
+  contour: ContourHandle,
+  plane: z15.object({
+    point: Vec3Handle,
+    normal: Vec3Handle
+  })
+});
+var PluginGeomUpdateContourAddHoleArgs = z15.object({
+  contour: ContourHandle,
+  hole: ProfileHandle
+});
+var PluginGeomUpdateContourRemoveHoleArgs = z15.object({
+  contour: ContourHandle,
+  index: z15.number()
+});
+
+// src/api/core/geom/update/index.ts
+var PluginGeomUpdateApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/geom/delete/index.ts
+import * as z16 from "zod";
+var PluginGeomDeleteApi = class {
+  constructor() {
+  }
+};
+var PluginGeomDeleteProfileArgs = z16.object({
+  profile: ProfileHandle
+});
+var PluginGeomDeleteContourArgs = z16.object({
+  contour: ContourHandle
+});
+
+// src/api/core/geom/index.ts
+var PluginGeomApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/history/index.ts
+import * as z17 from "zod";
+var PluginHistoryApi = class {
+  constructor() {
+  }
+};
+var PluginHistoryStepArgs = z17.object({
+  steps: z17.number().int().positive().optional()
+});
+var PluginHistoryStepResult = z17.object({
+  stepsApplied: z17.number().int().nonnegative()
+});
+
+// src/api/core/units/index.ts
+import * as z18 from "zod";
+var PluginUnitsApi = class {
+  constructor() {
+  }
+};
+var PUnitType = z18.enum([
+  "meters",
+  "feet-inches",
+  "inches",
+  "centimeters",
+  "millimeters",
+  "kilometers",
+  "miles",
+  "babylon"
+]);
+var PluginUnitsSetTypeArgs = z18.object({
+  type: PUnitType
+});
+var PluginUnitsConvertArgs = z18.object({
+  value: z18.number(),
+  from: PUnitType,
+  to: PUnitType,
+  degree: z18.number().int().min(1).max(3).optional()
+});
+
+// src/api/core/zoom/index.ts
+var PluginZoomApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/project/index.ts
+import * as z19 from "zod";
+var PluginProjectApi = class {
+  constructor() {
+  }
+};
+var PluginProjectSettingsApi = class {
+  constructor() {
+  }
+};
+var PluginSnapsApi = class {
+  constructor() {
+  }
+};
+var PluginGridApi = class {
+  constructor() {
+  }
+};
+var PluginSnapValueArgs = z19.object({
+  value: z19.number()
+});
+var PluginGridValueArgs = z19.object({
+  value: z19.number()
+});
+var PluginToleranceArgs = z19.object({
+  value: z19.number()
+});
+
+// src/api/core/comment/index.ts
+import * as z20 from "zod";
+var PluginCommentApi = class {
+  constructor() {
+  }
+};
+var CommentHandle = z20.string().min(1).transform((s) => s);
+var PluginCommentCreateArgs = z20.object({
+  component: ComponentHandle.optional(),
+  position: Vec3Handle.optional(),
+  message: z20.string(),
+  mentions: z20.array(z20.string()).optional()
+});
+var PluginCommentUpdateArgs = z20.object({
+  comment: CommentHandle,
+  message: z20.string(),
+  mentions: z20.array(z20.string()).optional()
+});
+var PluginCommentRefArgs = z20.object({
+  comment: CommentHandle
+});
+var PluginCommentTagArgs = z20.object({
+  comment: CommentHandle,
+  email: z20.string()
+});
+
+// src/api/core/groups.ts
+import * as z21 from "zod";
+var PluginCoreGroupsApi = class {
+  constructor() {
+  }
+};
+var PluginCoreGroupRef = z21.object({
+  id: z21.string(),
+  name: z21.string(),
+  memberCount: z21.number().int(),
+  isLocked: z21.boolean(),
+  parentId: z21.string().optional()
+});
+var PluginCoreGroupMember = z21.object({
+  id: z21.string(),
+  type: z21.enum(["component", "group"])
+});
+var PluginCoreGroupsListResult = z21.object({
+  groups: z21.array(PluginCoreGroupRef)
+});
+var PluginCoreGroupsGetArgs = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsGetResult = PluginCoreGroupRef.nullable();
+var PluginCoreGroupsGetForComponentArgs = z21.object({
+  componentId: ComponentHandle
+});
+var PluginCoreGroupsGetForComponentResult = PluginCoreGroupRef.nullable();
+var PluginCoreGroupsListMembersArgs = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsListMembersResult = z21.object({
+  members: z21.array(PluginCoreGroupMember)
+});
+var PluginCoreGroupsIsLockedArgs = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsIsLockedResult = z21.boolean();
+var PluginCoreGroupsGetBoundsArgs = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsGetBoundsResult = z21.object({
+  min: Vec3Components,
+  max: Vec3Components,
+  center: Vec3Components
+}).nullable();
+var PluginCoreGroupsCreateArgs = z21.object({
+  componentIds: z21.array(ComponentHandle).min(1),
+  name: z21.string().optional()
+});
+var PluginCoreGroupsCreateResult = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsUpdateArgs = z21.object({
+  groupId: z21.string(),
+  name: z21.string().optional(),
+  addComponentIds: z21.array(ComponentHandle).optional(),
+  removeComponentIds: z21.array(ComponentHandle).optional()
+});
+var PluginCoreGroupsUpdateResult = PluginCoreGroupRef;
+var PluginCoreGroupsDeleteArgs = z21.object({
+  groupId: z21.string()
+});
+var PluginCoreGroupsDeleteResult = z21.object({
+  deleted: z21.literal(true)
+});
+
+// src/api/core/buildings.ts
+import * as z22 from "zod";
+var PluginCoreBuildingsApi = class {
+  constructor() {
+  }
+};
+var PluginCoreBuildingRef = z22.object({
+  id: z22.string(),
+  name: z22.string(),
+  baseElevation: z22.number()
+});
+var PluginCoreBuildingsListResult = z22.object({
+  buildings: z22.array(PluginCoreBuildingRef)
+});
+var PluginCoreBuildingsGetArgs = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsGetResult = PluginCoreBuildingRef.nullable();
+var PluginCoreBuildingsListStoreysArgs = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsListStoreysResult = z22.object({
+  storeyIds: z22.array(z22.string())
+});
+var PluginCoreBuildingsGetActiveResult = z22.object({
+  buildingId: z22.string()
+}).nullable();
+var PluginCoreBuildingsSetActiveArgs = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsSetActiveResult = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsCreateArgs = z22.object({
+  name: z22.string(),
+  baseElevation: z22.number().optional()
+});
+var PluginCoreBuildingsCreateResult = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsUpdateArgs = z22.object({
+  buildingId: z22.string(),
+  name: z22.string().optional(),
+  baseElevation: z22.number().optional()
+});
+var PluginCoreBuildingsUpdateResult = PluginCoreBuildingRef;
+var PluginCoreBuildingsCopyArgs = z22.object({
+  buildingId: z22.string(),
+  name: z22.string().optional(),
+  baseElevation: z22.number().optional(),
+  asInstances: z22.boolean().optional()
+});
+var PluginCoreBuildingsCopyResult = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsDeleteArgs = z22.object({
+  buildingId: z22.string()
+});
+var PluginCoreBuildingsDeleteResult = z22.object({
+  deleted: z22.literal(true)
+});
+
+// src/api/core/layers.ts
+import * as z23 from "zod";
+var PluginCoreLayersApi = class {
+  constructor() {
+  }
+};
+var PluginCoreLayerType = z23.enum([
+  "floor",
+  "wall",
+  "ceiling",
+  "rough",
+  "default",
+  "image",
+  "cad",
+  "pdf",
+  "terrain",
+  "buildings"
+]);
+var PluginCoreLayer = z23.object({
+  id: z23.string(),
+  name: z23.string(),
+  layerType: PluginCoreLayerType,
+  storeyId: z23.string(),
+  buildingId: z23.string(),
+  hidden: z23.boolean(),
+  locked: z23.boolean(),
+  contentSummary: z23.object({
+    hasFloorplan: z23.boolean(),
+    pdfCount: z23.number().int(),
+    hasTerrain: z23.boolean()
+  })
+});
+var PluginCoreLayersListArgs = z23.object({
+  storeyId: z23.string(),
+  layerType: PluginCoreLayerType.optional()
+});
+var PluginCoreLayersListResult = z23.object({
+  layers: z23.array(PluginCoreLayer)
+});
+var PluginCoreLayersGetArgs = z23.object({
+  layerId: z23.string()
+});
+var PluginCoreLayersGetResult = PluginCoreLayer.nullable();
+var PluginCoreLayersGetActiveArgs = z23.object({
+  storeyId: z23.string()
+});
+var PluginCoreLayersGetActiveResult = PluginCoreLayer.nullable();
+var PluginCoreLayersSetActiveArgs = z23.object({
+  layerId: z23.string()
+});
+var PluginCoreLayersSetActiveResult = z23.object({
+  layerId: z23.string()
+});
+var PluginCoreLayersUpdateArgs = z23.object({
+  layerId: z23.string(),
+  hidden: z23.boolean().optional()
+});
+var PluginCoreLayersUpdateResult = PluginCoreLayer;
+
+// src/api/core/tags.ts
+import * as z24 from "zod";
+var PluginCoreTagsApi = class {
+  constructor() {
+  }
+};
+var PluginCoreTagCategory = z24.object({
+  id: z24.string(),
+  name: z24.string(),
+  tagIds: z24.array(z24.string())
+});
+var PluginCoreTag = z24.object({
+  id: z24.string(),
+  categoryId: z24.string(),
+  name: z24.string(),
+  color: z24.string()
+});
+var PluginCoreComponentTag = z24.object({
+  categoryId: z24.string(),
+  categoryName: z24.string(),
+  tagId: z24.string(),
+  tagName: z24.string(),
+  color: z24.string()
+});
+var PluginCoreAssignOutcome = z24.object({
+  assigned: z24.array(z24.string()),
+  skipped: z24.array(
+    z24.object({
+      id: z24.string(),
+      reason: z24.enum(["locked", "not-taggable", "not-found"])
+    })
+  )
+});
+var PluginCoreTagsListCategoriesResult = z24.object({
+  categories: z24.array(PluginCoreTagCategory)
+});
+var PluginCoreTagsGetCategoryArgs = z24.object({
+  categoryId: z24.string()
+});
+var PluginCoreTagsGetCategoryResult = PluginCoreTagCategory.nullable();
+var PluginCoreTagsListArgs = z24.object({
+  categoryId: z24.string().optional()
+});
+var PluginCoreTagsListResult = z24.object({
+  tags: z24.array(PluginCoreTag)
+});
+var PluginCoreTagsGetArgs = z24.object({
+  tagId: z24.string()
+});
+var PluginCoreTagsGetResult = PluginCoreTag.nullable();
+var PluginCoreTagsGetTagsForComponentArgs = z24.object({
+  componentId: ComponentHandle
+});
+var PluginCoreTagsGetTagsForComponentResult = z24.object({
+  tags: z24.array(PluginCoreComponentTag)
+});
+var PluginCoreTagsListComponentsArgs = z24.object({
+  tagId: z24.string().optional(),
+  categoryId: z24.string().optional(),
+  untagged: z24.boolean().optional()
+}).refine((v) => v.tagId == null !== (v.categoryId == null), {
+  message: "Provide exactly one of tagId or categoryId"
+}).refine((v) => v.untagged == null || v.categoryId != null, {
+  message: "untagged is valid only together with categoryId"
+});
+var PluginCoreTagsListComponentsResult = z24.object({
+  componentIds: z24.array(ComponentHandle)
+});
+var PluginCoreTagsCreateCategoryArgs = z24.object({
+  name: z24.string()
+});
+var PluginCoreTagsCreateCategoryResult = PluginCoreTagCategory;
+var PluginCoreTagsUpdateCategoryArgs = z24.object({
+  categoryId: z24.string(),
+  name: z24.string()
+});
+var PluginCoreTagsUpdateCategoryResult = PluginCoreTagCategory;
+var PluginCoreTagsDeleteCategoryArgs = z24.object({
+  categoryId: z24.string()
+});
+var PluginCoreTagsDeleteCategoryResult = z24.object({
+  deletedTagCount: z24.number().int(),
+  resetComponentCount: z24.number().int()
+});
+var PluginCoreTagsCreateArgs = z24.object({
+  categoryId: z24.string(),
+  name: z24.string(),
+  color: z24.string().optional()
+});
+var PluginCoreTagsCreateResult = PluginCoreTag;
+var PluginCoreTagsUpdateArgs = z24.object({
+  tagId: z24.string(),
+  name: z24.string().optional(),
+  color: z24.string().optional()
+});
+var PluginCoreTagsUpdateResult = PluginCoreTag;
+var PluginCoreTagsDeleteArgs = z24.object({
+  tagId: z24.string()
+});
+var PluginCoreTagsDeleteResult = z24.object({
+  resetComponentCount: z24.number().int()
+});
+var PluginCoreTagsAssignArgs = z24.object({
+  componentIds: z24.array(ComponentHandle).min(1),
+  categoryName: z24.string(),
+  tagName: z24.string()
+});
+var PluginCoreTagsAssignResult = PluginCoreAssignOutcome.extend({
+  categoryId: z24.string(),
+  tagId: z24.string(),
+  categoryCreated: z24.boolean(),
+  tagCreated: z24.boolean()
+});
+var PluginCoreTagsUnassignArgs = z24.object({
+  categoryId: z24.string(),
+  componentIds: z24.array(ComponentHandle).min(1)
+});
+var PluginCoreTagsUnassignResult = PluginCoreAssignOutcome;
+
+// src/api/core/index.ts
+var PluginCoreApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/create/index.ts
+import * as z26 from "zod";
+
+// src/api/entity/space.ts
+import * as z25 from "zod";
+var PluginSpaceCreateRectangularArgs = z25.object({
+  position: Vec3Handle,
+  dimensions: z25.object({
+    width: z25.number(),
+    height: z25.number(),
+    depth: z25.number()
+  })
+});
+var PluginSpaceCreateRectangularResult = z25.object({
+  spaceId: z25.string()
+});
+var PluginSpaceCreateFromProfileArgs = z25.object({
+  profile: ProfileHandle,
+  innerProfiles: z25.array(ProfileHandle).optional(),
+  extrudeHeight: z25.number(),
+  position: Vec3Handle
+});
+var PluginSpaceCreateFromProfileResult = z25.object({
+  spaceId: z25.string()
+});
+var PluginSpaceUpdateGeometryFromProfileArgs = z25.object({
+  spaceId: z25.string(),
+  profile: ProfileHandle,
+  extrudeHeight: z25.number()
+});
+var PluginSpaceUpdateGeometryFromProfileResult = z25.object({
+  spaceId: z25.string()
+});
+var PluginSpaceGetProperty = z25.enum([
+  // Basic
+  "id",
+  "type",
+  "room_type",
+  "name",
+  // Derived from parametric data
+  "area",
+  "breadth",
+  "depth",
+  "height",
+  "massType",
+  "spaceType",
+  "areaClass",
+  "storey",
+  "departmentId",
+  "departmentName",
+  "departmentColor",
+  // Derived from mesh
+  "position",
+  "absolutePosition",
+  "rotation",
+  "rotationQuaternion",
+  // Derived from brep
+  "planPoints",
+  "profile",
+  "innerProfiles",
+  "innerPlanPoints",
+  // Derived from adjacency manager
+  "adjacency"
+]);
+var PluginSpaceGetArgs = z25.object({
+  spaceId: z25.string(),
+  properties: z25.array(PluginSpaceGetProperty)
+});
+var PluginSpaceType = z25.enum([
+  "Room",
+  "Program Block",
+  "Balcony",
+  "Road",
+  "Garden",
+  "Deck",
+  "Pool",
+  "Walkway",
+  "Envelope",
+  "Parking"
+]);
+var PluginAreaClass = z25.enum(["NET", "GROSS", "EXCLUDED"]);
+var PluginSpaceGetResult = z25.object({
+  // Basic
+  id: z25.string(),
+  type: z25.string(),
+  room_type: z25.string(),
+  name: z25.string(),
+  // Derived from parametric data
+  area: z25.number(),
+  breadth: z25.number(),
+  depth: z25.number(),
+  height: z25.number(),
+  massType: z25.string().nullable(),
+  spaceType: PluginSpaceType.nullable(),
+  areaClass: PluginAreaClass,
+  storey: z25.number().nullable(),
+  departmentId: z25.string().nullable(),
+  departmentName: z25.string(),
+  departmentColor: z25.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)),
+  // 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()
+  }))
+}).partial();
+var PluginSpaceGetAllResult = z25.object({
+  spacesIds: z25.array(z25.string())
+});
+var PluginSpaceDeleteArgs = z25.object({
+  spaceId: z25.string()
+});
+var PluginMassType = z25.enum([
+  "Plinth",
+  "Void",
+  "Pergola",
+  "Furniture",
+  "Facade element",
+  "Generic mass",
+  "Room",
+  "Department",
+  "Building",
+  "Revit Import",
+  "Mass",
+  "Site"
+]);
+var PluginWellKnownDepartmentId = z25.enum([
+  "DEFAULT",
+  "SITE",
+  "ENVELOPE",
+  "CORE"
+]);
+var PluginDepartmentId = z25.union([
+  PluginWellKnownDepartmentId,
+  z25.uuid()
+]);
+var PluginSpaceUpdateArgs = z25.object({
+  spaceId: z25.string(),
+  properties: z25.object({
+    room_type: z25.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(),
+  areaClass: PluginAreaClass.optional(),
+  departmentId: z25.string().nullable().optional()
+});
+var PluginSpaceBulkCreateItem = z25.discriminatedUnion("kind", [
+  z25.object({
+    kind: z25.literal("rectangular"),
+    position: Vec3Handle,
+    dimensions: z25.object({
+      width: z25.number(),
+      height: z25.number(),
+      depth: z25.number()
+    }),
+    room_type: z25.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional()
+  }),
+  z25.object({
+    kind: z25.literal("profile"),
+    profile: ProfileHandle,
+    innerProfiles: z25.array(ProfileHandle).optional(),
+    extrudeHeight: z25.number(),
+    position: Vec3Handle,
+    room_type: z25.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional()
+  })
+]);
+var PluginSpaceBulkCreateArgs = z25.object({
+  items: z25.array(PluginSpaceBulkCreateItem)
+});
+var PluginSpaceBulkCreateResult = z25.object({
+  spaceIds: z25.array(z25.string())
+});
+var PluginSpaceBulkUpdateItem = z25.object({
+  spaceId: z25.string(),
+  profile: ProfileHandle.optional(),
+  extrudeHeight: z25.number().optional(),
+  properties: z25.object({
+    room_type: z25.string().optional(),
+    massType: PluginMassType.optional(),
+    spaceType: PluginSpaceType.optional(),
+    areaClass: PluginAreaClass.optional(),
+    departmentId: PluginDepartmentId.optional()
+  }).optional()
+});
+var PluginSpaceBulkUpdateArgs = z25.object({
+  items: z25.array(PluginSpaceBulkUpdateItem)
+});
+var PluginSpaceBulkUpdateResult = z25.object({
+  spaces: z25.array(PluginSpaceUpdateResult)
+});
+var PluginSpaceBulkDeleteArgs = z25.object({
+  spaceIds: z25.array(z25.string())
+});
+var PluginSpaceBulkDeleteResult = z25.object({
+  deletedSpaceIds: z25.array(z25.string())
+});
+
+// src/api/design/create/index.ts
+var PluginDesignCreateApi = class {
+  constructor() {
+  }
+};
+var PluginReferenceLineStyle = z26.enum(["SOLID", "DASHED", "DOT_DASH"]);
+var PluginSlabType = z26.enum([
+  "Intermediate Slab",
+  "Basement Slab",
+  "Plinth",
+  "Roof"
+]);
+var PluginStaircasePreset = z26.enum([
+  "straight",
+  "straightWoLanding",
+  "straightFlightWoMidLanding",
+  "dogLegged",
+  "openWell",
+  "lShaped",
+  "3StepLShaped",
+  "square",
+  "singleStep",
+  "plinthLevel",
+  "amphitheatre",
+  "connectingStepsToAmphitheatre",
+  "mezzanineFloorStraight",
+  "mezzanineFloorDogLegged",
+  "mezzanineFloorLShaped",
+  "custom"
+]);
+var PluginDesignCreateSpaceArgs = z26.object({
+  contour: ContourHandle,
+  height: z26.number(),
+  label: z26.string().optional(),
+  position: Vec3Handle.optional(),
+  spaceType: PluginSpaceType.optional(),
+  massType: PluginMassType.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+var PluginDesignCreateMassArgs = z26.object({
+  contour: ContourHandle,
+  height: z26.number(),
+  label: z26.string().optional(),
+  position: Vec3Handle.optional(),
+  massType: PluginMassType.optional()
+});
+var PluginDesignCreateSlabArgs = z26.object({
+  contour: ContourHandle,
+  thickness: z26.number(),
+  direction: z26.enum(["up", "down"]).optional(),
+  slabType: PluginSlabType.optional()
+});
+var PluginDesignCreateFloorArgs = z26.object({
+  contour: ContourHandle,
+  thickness: z26.number(),
+  position: Vec3Handle.optional()
+});
+var PluginDesignCreateRoofArgs = z26.object({
+  contour: ContourHandle,
+  thickness: z26.number()
+});
+var PluginDesignCreateCeilingArgs = z26.object({
+  contour: ContourHandle,
+  thickness: z26.number(),
+  heightFromFloor: z26.number().optional()
+});
+var PluginDesignCreateColumnArgs = z26.object({
+  position: Vec3Handle,
+  crossSection: ContourHandle,
+  height: z26.number(),
+  directionUp: Vec3Handle.optional()
+});
+var PluginDesignCreateBeamArgs = z26.object({
+  section: ContourHandle,
+  length: z26.number(),
+  direction: Vec3Handle.optional()
+});
+var PluginDesignCreateWallsArgs = z26.object({
+  profile: ProfileHandle,
+  height: z26.number().optional(),
+  thickness: z26.number().optional()
+});
+var PluginDesignCreateStaircaseArgs = z26.object({
+  preset: PluginStaircasePreset,
+  position: Vec3Handle,
+  label: z26.string().optional(),
+  structureId: z26.string().optional(),
+  level: z26.string().optional()
+});
+var PluginDesignCreateFurnitureArgs = z26.object({
+  catalogId: z26.string().min(1),
+  position: Vec3Handle,
+  label: z26.string().optional(),
+  createNewSourceMesh: z26.boolean().optional()
+});
+var PluginDesignCreateReferenceLinesArgs = z26.object({
+  profile: ProfileHandle,
+  color: z26.string().optional(),
+  thickness: z26.number().optional(),
+  style: PluginReferenceLineStyle.optional(),
+  gridTag: z26.string().optional()
+});
+var PluginCopyMode = z26.enum(["instance", "unique"]);
+var PluginDesignCreateCopyArgs = z26.object({
+  components: z26.array(ComponentHandle).min(1),
+  displacement: Vec3Handle,
+  count: z26.number().int().positive().optional(),
+  mode: PluginCopyMode.optional()
+});
+var PluginCreateSpaceItem = z26.object({
+  contour: ContourHandle,
+  height: z26.number(),
+  label: z26.string().optional(),
+  position: Vec3Handle.optional(),
+  spaceType: PluginSpaceType.optional(),
+  massType: PluginMassType.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+
+// src/api/design/query/index.ts
+import * as z29 from "zod";
+
+// src/api/design/query/geometry/index.ts
+import * as z27 from "zod";
+var PluginDesignQueryGeometryApi = class {
+  constructor() {
+  }
+};
+var PluginDesignQueryGeometryGetBrepArgs = z27.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryGeometryGetBottomContourArgs = z27.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryGeometryGetCenterlineArgs = z27.object({
+  component: ComponentHandle
+});
+
+// src/api/design/query/spaces.ts
+import * as z28 from "zod";
+var PluginDesignQuerySpacesApi = class {
+  constructor() {
+  }
+};
+var PluginDesignQueryGetFootprintArgs = z28.object({
+  space: ComponentHandle
+});
+var PluginDesignQuerySpacesGetProperty = PluginSpaceGetProperty.exclude(["adjacency"]);
+var PluginDesignQuerySpacesGetArgs = z28.object({
+  space: ComponentHandle,
+  properties: z28.array(PluginDesignQuerySpacesGetProperty)
+});
+var PluginDesignQuerySpacesGetResult = PluginSpaceGetResult.omit({
+  adjacency: true
+});
+
+// src/api/design/query/index.ts
+var PluginEntityType = z29.enum([
+  "wall",
+  "space",
+  "mass",
+  "door",
+  "window",
+  "floor",
+  "slab",
+  "roof",
+  "column",
+  "beam",
+  "ceiling",
+  "staircase",
+  "furniture",
+  "referenceLine",
+  "curtainWall",
+  "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(),
+  departmentId: PluginDepartmentId.optional(),
+  isSelected: z29.boolean().optional(),
+  isLocked: z29.boolean().optional(),
+  isHidden: z29.boolean().optional(),
+  within: BBoxComponents.optional(),
+  overlaps: ComponentHandle.optional(),
+  ids: z29.array(ComponentHandle).optional()
+});
+var PluginDesignQueryListByTypeArgs = PluginEntityFilter.extend({
+  type: PluginEntityType
+});
+var PluginDesignQueryComponentArgs = z29.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryIdArgs = z29.object({
+  id: ComponentHandle
+});
+var PluginDesignQueryComponentsArgs = z29.object({
+  components: z29.array(ComponentHandle)
+});
+var PluginEntityProperties = z29.object({
+  id: z29.string(),
+  type: PluginEntityType,
+  label: z29.string(),
+  storey: z29.number(),
+  buildingId: z29.string(),
+  structureId: z29.string(),
+  massType: z29.string(),
+  spaceType: PluginSpaceType,
+  areaClass: PluginAreaClass,
+  departmentId: z29.string(),
+  isLocked: z29.boolean(),
+  isHidden: z29.boolean(),
+  isSelected: z29.boolean(),
+  boundingBox: BBoxComponents,
+  adjacency: z29.array(z29.object({ spaceId: z29.string(), value: z29.number() }))
+}).partial();
+var PluginEntityMeasurements = z29.object({
+  area: z29.number().optional(),
+  volume: z29.number().optional(),
+  length: z29.number().optional(),
+  boundingBox: BBoxComponents
+});
+var PluginDesignQueryApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/selection/index.ts
+import * as z30 from "zod";
+var PluginDesignSelectionApi = class {
+  constructor() {
+  }
+};
+var PluginDesignSelectionSetArgs = z30.object({
+  components: z30.array(ComponentHandle)
+});
+var PluginDesignSelectionAddArgs = PluginDesignSelectionSetArgs;
+var PluginDesignSelectionRemoveArgs = PluginDesignSelectionSetArgs;
+
+// src/api/design/doors/index.ts
+import * as z31 from "zod";
+var PluginDesignDoorsApi = class {
+  constructor() {
+  }
+};
+var PluginDesignDoorArgs = z31.object({
+  door: ComponentHandle
+});
+var PluginMirrorAxis = z31.enum(["x", "y", "z"]);
+var PluginDesignDoorMirrorArgs = z31.object({
+  door: ComponentHandle,
+  axis: PluginMirrorAxis.optional()
+});
+var PluginDesignDoorSetWidthArgs = z31.object({
+  doors: z31.array(ComponentHandle),
+  width: z31.number()
+});
+var PluginDesignDoorSetHeightArgs = z31.object({
+  doors: z31.array(ComponentHandle),
+  height: z31.number()
+});
+
+// src/api/design/windows/index.ts
+import * as z32 from "zod";
+var PluginDesignWindowsApi = class {
+  constructor() {
+  }
+};
+var PluginDesignWindowArgs = z32.object({
+  window: ComponentHandle
+});
+var PluginWindowDimensions = z32.object({
+  width: z32.number(),
+  height: z32.number(),
+  thickness: z32.number()
+});
+var PluginDesignWindowSetWidthArgs = z32.object({
+  window: ComponentHandle,
+  width: z32.number()
+});
+var PluginDesignWindowSetHeightArgs = z32.object({
+  window: ComponentHandle,
+  height: z32.number()
+});
+
+// src/api/design/furniture/index.ts
+import * as z33 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 PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs;
+
+// src/api/design/materials/index.ts
+import * as z34 from "zod";
+var PluginDesignMaterialsApi = class {
+  constructor() {
+  }
+};
+var PluginMaterialInfo = z34.object({
+  name: z34.string(),
+  id: z34.string(),
+  colorHex: z34.string(),
+  alpha: z34.number(),
+  materialType: z34.string().optional(),
+  textureUrl: z34.string().optional()
+});
+var PluginMaterialSpec = z34.object({
+  name: z34.string().optional(),
+  color: z34.string().optional(),
+  textureUrl: z34.string().optional(),
+  alpha: z34.number().optional(),
+  materialType: z34.string().optional()
+});
+var PluginMaterialResult = z34.object({ count: z34.number() });
+var PluginDesignMaterialsListArgs = z34.object({
+  scope: z34.enum(["project", "preset"]).optional()
+});
+var PluginDesignMaterialsGetInfoArgs = z34.object({ material: MaterialHandle });
+var PluginDesignMaterialsComponentArgs = z34.object({ component: ComponentHandle });
+var PluginDesignMaterialsApplyArgs = z34.object({
+  targets: z34.array(ComponentHandle),
+  material: z34.union([MaterialHandle, PluginMaterialSpec]),
+  save: z34.boolean().optional()
+});
+var PluginDesignMaterialsResetArgs = z34.object({
+  components: z34.array(ComponentHandle),
+  save: z34.boolean().optional()
+});
+var PluginDesignMaterialsCreateArgs = z34.object({ spec: PluginMaterialSpec });
+
+// src/api/design/lock.ts
+import * as z35 from "zod";
+var PluginDesignChangeResult = z35.object({
+  affected: z35.array(ComponentHandle)
+});
+var PluginDesignLockArgs = z35.object({
+  components: z35.array(ComponentHandle)
+});
+var PluginDesignUnlockArgs = PluginDesignLockArgs;
+var PluginDesignIsLockedArgs = z35.object({
+  component: ComponentHandle,
+  includeInherited: z35.boolean().optional()
+});
+
+// src/api/design/erase/index.ts
+import * as z36 from "zod";
+var EraseStrategy = z36.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
+var DEFAULT_ERASE_STRATEGIES = ["DirectDelete", "DirectUnion"];
+var ErasableEdgeRef = z36.object({
+  /** Opaque bottom-graph edge id (engine form `"e-<n>"`). Do not mutate. Pass verbatim to {@linkcode PluginDesignEraseApi.edge}. */
+  id: z36.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),
+  /** 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 PluginDesignEraseEdgeArgs = z36.object({
+  edge: ErasableEdgeRef
+});
+var PluginDesignEraseEdgeResult = z36.object({ ok: z36.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)
+});
+var PluginDesignDeleteApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/shared.ts
+import * as z38 from "zod";
+var BooleanOutcome = z38.object({
+  created: z38.array(ComponentHandle),
+  deleted: z38.array(ComponentHandle)
+});
+var OffsetSplitOutcome = z38.object({
+  createdIds: z38.array(ComponentHandle),
+  deletedIds: z38.array(ComponentHandle),
+  offsetValue: z38.number()
+});
+
+// src/api/design/boolean/index.ts
+import * as z39 from "zod";
+var PluginDesignBooleanApi = class {
+  constructor() {
+  }
+};
+var BooleanOptions = z39.object({
+  offset: Vec3Handle.optional()
+});
+var PluginDesignBooleanUnionArgs = z39.object({
+  components: z39.array(ComponentHandle).min(2),
+  options: BooleanOptions.optional()
+});
+var PluginDesignBooleanSubtractArgs = z39.object({
+  target: ComponentHandle,
+  tools: z39.array(ComponentHandle).min(1),
+  options: BooleanOptions.optional()
+});
+var PluginDesignBooleanIntersectArgs = z39.object({
+  components: z39.array(ComponentHandle).length(2),
+  options: BooleanOptions.optional()
+});
+
+// src/api/design/transform/index.ts
+import * as z40 from "zod";
+var PluginDesignTransformApi = class {
+  constructor() {
+  }
+};
+var PluginDesignMoveArgs = z40.object({
+  components: z40.array(ComponentHandle).min(1),
+  displacement: Vec3Handle,
+  is2D: z40.boolean().optional(),
+  trackParentChange: z40.boolean().optional()
+});
+var PluginDesignRotateArgs = z40.object({
+  components: z40.array(ComponentHandle).min(1),
+  angleInDegrees: z40.number(),
+  axis: Vec3Handle.optional(),
+  is2D: z40.boolean().optional()
+});
+
+// src/api/design/edit/index.ts
+import * as z41 from "zod";
+var PluginDesignEditApi = class {
+  constructor() {
+  }
+};
+var PluginDesignOffsetSplitArgs = z41.object({
+  component: ComponentHandle,
+  offsetDistance: z41.number(),
+  profilePickPoint: Vec3Handle.optional()
+});
+
+// src/api/design/update/index.ts
+import * as z42 from "zod";
+var PluginSpacePropertyUpdates = z42.object({
+  room_type: z42.string().optional(),
+  massType: PluginMassType.optional(),
+  spaceType: PluginSpaceType.optional(),
+  areaClass: PluginAreaClass.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+var PluginSpaceGeometryUpdate = z42.object({
+  profile: ProfileHandle,
+  extrudeHeight: z42.number()
+});
+var PluginUpdateSpaceItem = z42.object({
+  space: ComponentHandle,
+  properties: PluginSpacePropertyUpdates.optional(),
+  geometry: PluginSpaceGeometryUpdate.optional()
+});
+var PluginDesignUpdateApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/index.ts
+var PluginDesignApi = class {
+  constructor() {
+  }
+};
+
+// src/api/entity/buildableEnvelope.ts
+import * as z43 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 PluginBuildableEnvelopeVerticalCap = z43.discriminatedUnion("kind", [
+  z43.object({
+    kind: z43.literal("max_height"),
+    maxHeight: z43.number().finite().positive()
+  }).strict(),
+  z43.object({
+    kind: z43.literal("max_floors"),
+    maxFloors: z43.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()
+}).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,
+      path: ["setbacks", 0, "aboveHeight"],
+      message: "Ground tier required: setbacks[0].aboveHeight must be 0."
+    });
+  }
+  for (let i = 1; i < tiers.length; i++) {
+    if (!(tiers[i].aboveHeight > tiers[i - 1].aboveHeight)) {
+      ctx.addIssue({
+        code: z43.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),
+  verticalCap: PluginBuildableEnvelopeVerticalCap,
+  floorToFloor: z43.number().finite().positive(),
+  farRatio: z43.number().finite().positive().optional(),
+  lotCoverageMaxPct: z43.number().finite().min(0).max(100).optional()
+}).strict().superRefine(refineSetbackTiers);
+var PluginBuildableEnvelopeCreateResult = z43.object({
+  buildableEnvelopeId: z43.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),
+  verticalCap: PluginBuildableEnvelopeVerticalCap,
+  floorToFloor: z43.number().finite().positive(),
+  farRatio: z43.number().finite().positive().optional(),
+  lotCoverageMaxPct: z43.number().finite().min(0).max(100).optional()
+}).strict().superRefine(refineSetbackTiers);
+var PluginBuildableEnvelopeUpdateResult = z43.object({
+  buildableEnvelopeId: z43.string().min(1)
+}).strict();
+
+// src/api/entity/referenceLine.ts
+import * as z44 from "zod";
+var PluginReferenceLineApi = class {
+  constructor() {
+  }
+};
+var PluginReferenceLineCreateMultiArgs = z44.object({
+  profile: ProfileHandle
+});
+var PluginReferenceLineCreateMultiResult = z44.object({
+  referenceLineIds: z44.array(z44.string())
+});
+var PluginReferenceLineGetProperty = z44.enum([
+  "curve"
+]);
+var PluginReferenceLineGetArgs = z44.object({
+  referenceLineId: z44.string(),
+  properties: z44.array(PluginReferenceLineGetProperty)
+});
+var PluginReferenceLineGetResult = z44.object({
+  curve: CurveHandle
+}).partial();
+var PluginReferenceLineGetAllResult = z44.object({
+  referenceLineIds: z44.array(z44.string())
+});
+var PluginReferenceLineDeleteArgs = z44.object({
+  referenceLineId: z44.string()
+});
+
+// src/api/entity/story.ts
+import * as z45 from "zod";
+var PluginStoryApi = class {
+  constructor() {
+  }
+};
+var PluginStoryGetProperty = z45.enum([
+  "value",
+  "id",
+  "name",
+  "height",
+  "base",
+  "hidden",
+  "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()
+}).partial();
+var PluginStoryGetAllResult = z45.object({
+  stories: z45.array(
+    z45.object({
+      value: z45.number(),
+      id: z45.string(),
+      name: z45.string()
+    })
+  )
+});
+var PluginStoryCreateArgs = z45.object({
+  storyValue: z45.number().int(),
+  height: z45.number().optional()
+});
+var PluginStoryCreateResult = z45.object({
+  storyId: z45.string(),
+  storyValue: z45.number()
+});
+var PluginStoryUpdateArgs = z45.object({
+  storyValue: z45.number().int(),
+  height: z45.number()
+});
+var PluginStoryUpdateResult = z45.object({
+  storyValue: z45.number(),
+  height: z45.number()
+});
+
+// src/api/entity/index.ts
+var PluginEntityApi = class {
+  constructor() {
+  }
+};
+
+// src/api/program/departments.ts
+import * as z47 from "zod";
+
+// src/api/program/metrics.ts
+import * as z46 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({
+  units: PluginAreaUnit,
+  totalTargetArea: z46.number(),
+  totalAllocatedArea: z46.number(),
+  unassignedArea: z46.number(),
+  departments: z46.array(PluginProgramDepartmentMetric)
+}).refine(
+  (s) => {
+    const summed = s.unassignedArea + s.departments.reduce((acc, d) => acc + d.allocatedArea, 0);
+    const tolerance = Math.max(0.01, Math.abs(s.totalAllocatedArea) * 1e-4);
+    return Math.abs(s.totalAllocatedArea - summed) <= tolerance;
+  },
+  {
+    message: "totalAllocatedArea must equal unassignedArea + the sum of departments[].allocatedArea"
+  }
+);
+
+// src/api/program/departments.ts
+var PluginProgramDepartmentsApi = class {
+  constructor() {
+  }
+};
+var PluginProgramDepartment = z47.object({
+  id: z47.string(),
+  name: z47.string(),
+  color: z47.string(),
+  targetArea: z47.number().nullable()
+});
+var PluginProgramDepartmentsListResult = z47.object({
+  units: PluginAreaUnit,
+  departments: z47.array(PluginProgramDepartment)
+});
+var PluginProgramDepartmentsGetArgs = z47.object({
+  departmentId: z47.string()
+});
+var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
+  {
+    units: PluginAreaUnit
+  }
+).nullable();
+var PluginProgramDepartmentRecord = PluginProgramDepartment.extend({
+  units: PluginAreaUnit
+});
+var PluginProgramDepartmentsCreateArgs = z47.object({
+  name: z47.string(),
+  color: z47.string()
+});
+var PluginProgramDepartmentsCreateResult = z47.object({
+  departmentId: z47.string()
+});
+var PluginProgramDepartmentsUpdateArgs = z47.object({
+  departmentId: z47.string(),
+  name: z47.string().optional(),
+  color: z47.string().optional()
+});
+var PluginProgramDepartmentsUpdateResult = PluginProgramDepartmentRecord;
+var PluginProgramDepartmentsAssignArgs = z47.object({
+  departmentId: z47.string(),
+  spaceIds: z47.array(ComponentHandle).min(1)
+});
+var PluginProgramDepartmentsAssignResult = z47.object({
+  departmentId: z47.string(),
+  spaceIds: z47.array(ComponentHandle)
+});
+var PluginProgramDepartmentsUnassignArgs = z47.object({
+  spaceIds: z47.array(ComponentHandle).min(1)
+});
+var PluginProgramDepartmentsUnassignResult = z47.object({
+  spaceIds: z47.array(ComponentHandle)
+});
+var PluginProgramDepartmentsSetTargetAreaArgs = z47.object({
+  departmentId: z47.string(),
+  targetArea: z47.number(),
+  units: PluginAreaUnit.optional()
+});
+var PluginProgramDepartmentsSetTargetAreaResult = PluginProgramDepartmentRecord;
+var PluginProgramDepartmentsDeleteArgs = z47.object({
+  departmentId: z47.string()
+});
+var PluginProgramDepartmentsDeleteResult = z47.object({
+  departmentId: z47.string(),
+  reassignedSpaceIds: z47.array(ComponentHandle)
+});
+
+// src/api/program/adjacency.ts
+import * as z48 from "zod";
+var PluginProgramAdjacencyApi = class {
+  constructor() {
+  }
+};
+var PluginAdjacencyLevel = z48.enum(["department", "space"]);
+var PluginProgramAdjacencyGetMatrixArgs = z48.object({
+  level: PluginAdjacencyLevel,
+  ids: z48.array(z48.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 PluginProgramAdjacencyComputeResult = z48.object({
+  success: z48.boolean(),
+  error: z48.string().optional()
+});
+
+// src/api/program/layout.ts
+import * as z49 from "zod";
+var PluginProgramLayoutApi = class {
+  constructor() {
+  }
+};
+var PluginProgramLayoutRunResult = z49.object({
+  success: z49.boolean(),
+  error: z49.string().optional()
+});
+
+// src/api/program/spreadsheet.ts
+import * as z50 from "zod";
+var PluginProgramSpreadsheetApi = class {
+  constructor() {
+  }
+};
+var PluginProgramSpreadsheetTemplatesApi = class {
+  constructor() {
+  }
+};
+var PluginProgramSpreadsheetBindingsApi = class {
+  constructor() {
+  }
+};
+var PluginSpreadsheetCell = z50.union([
+  z50.string(),
+  z50.number(),
+  z50.boolean(),
+  z50.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(),
+  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({
+  format: PluginSpreadsheetExportFormat,
+  fileName: z50.string().optional()
+});
+var PluginProgramSpreadsheetExportResult = z50.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([
+  "column",
+  "bar",
+  "line",
+  "pie",
+  "area",
+  "scatter"
+]);
+var PluginProgramSpreadsheetAddChartArgs = z50.object({
+  sheetName: z50.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({
+  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(),
+  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([
+  "left",
+  "center",
+  "right",
+  "general"
+]);
+var PluginSpreadsheetVerticalAlign = z50.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(),
+  fontWeight: PluginSpreadsheetFontWeight.optional(),
+  fontStyle: PluginSpreadsheetFontStyle.optional(),
+  formatter: z50.string().optional(),
+  horizontalAlign: PluginSpreadsheetHorizontalAlign.optional(),
+  verticalAlign: PluginSpreadsheetVerticalAlign.optional()
+});
+var PluginSpreadsheetRangeStyle = z50.object({
+  range: z50.string(),
+  style: PluginSpreadsheetCellStyle
+});
+var PluginProgramSpreadsheetSetStylesArgs = z50.object({
+  sheetName: z50.string(),
+  ranges: z50.array(PluginSpreadsheetRangeStyle)
+});
+var PluginProgramSpreadsheetSetStylesResult = z50.object({
+  sheetName: z50.string(),
+  count: z50.number()
+});
+var PluginProgramSpreadsheetMergeCellsArgs = z50.object({
+  sheetName: z50.string(),
+  range: z50.string(),
+  value: PluginSpreadsheetCell.optional()
+});
+var PluginProgramSpreadsheetMergeCellsResult = z50.object({
+  sheetName: z50.string(),
+  range: z50.string()
+});
+var PluginSpreadsheetConditionalRuleType = z50.enum(["dataBar"]);
+var PluginSpreadsheetConditionalRule = z50.object({
+  type: PluginSpreadsheetConditionalRuleType,
+  color: z50.string().optional()
+});
+var PluginProgramSpreadsheetAddConditionalFormattingArgs = z50.object({
+  sheetName: z50.string(),
+  range: z50.string(),
+  rule: PluginSpreadsheetConditionalRule
+});
+var PluginProgramSpreadsheetAddConditionalFormattingResult = z50.object({
+  sheetName: z50.string(),
+  range: z50.string(),
+  created: z50.boolean()
+});
+var PluginProgramSpreadsheetRecalculateArgs = z50.object({
+  sheetName: z50.string().optional()
+});
+var PluginProgramSpreadsheetRecalculateResult = z50.object({
+  scope: z50.enum(["sheet", "workbook"]),
+  sheetName: z50.string().nullable()
+});
+var PluginSpreadsheetTransactionMethod = z50.enum([
+  "createSheet",
+  "setValues",
+  "setFormulas",
+  "setStyles",
+  "mergeCells"
+]);
+var PluginSpreadsheetTransactionOp = z50.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(),
+  status: PluginSpreadsheetAuditStatus,
+  summary: z50.string().optional()
+});
+var PluginProgramSpreadsheetGetAuditLogArgs = z50.object({
+  limit: z50.number().optional()
+});
+var PluginProgramSpreadsheetGetAuditLogResult = z50.object({
+  entries: z50.array(PluginSpreadsheetAuditEntry)
+});
+var PluginProgramSpreadsheetPingResult = z50.object({
+  pong: z50.boolean()
+});
+var PluginSpreadsheetTemplateScope = z50.enum(["project", "global"]);
+var PluginProgramSpreadsheetTemplatesCreateArgs = z50.object({
+  name: z50.string(),
+  sheetName: z50.string(),
+  scope: PluginSpreadsheetTemplateScope.optional()
+});
+var PluginProgramSpreadsheetTemplatesCreateResult = z50.object({
+  id: z50.string(),
+  name: z50.string(),
+  scope: PluginSpreadsheetTemplateScope,
+  sheetName: z50.string()
+});
+var PluginProgramSpreadsheetTemplatesApplyArgs = z50.object({
+  name: z50.string(),
+  targetSheetName: z50.string()
+});
+var PluginProgramSpreadsheetTemplatesApplyResult = z50.object({
+  name: z50.string(),
+  targetSheetName: z50.string()
+});
+var PluginSpreadsheetBindingSource = z50.object({
+  dataset: z50.enum(["takeoff"])
+});
+var PluginSpreadsheetBindingMode = z50.enum(["replaceRange"]);
+var PluginSpreadsheetBindingTarget = z50.object({
+  sheetName: z50.string(),
+  startCell: z50.string().optional()
+});
+var PluginSpreadsheetBinding = z50.object({
+  id: z50.string(),
+  name: z50.string(),
+  pluginId: z50.string(),
+  source: PluginSpreadsheetBindingSource,
+  target: z50.object({
+    sheetName: z50.string(),
+    startCell: z50.string()
+  }),
+  mode: PluginSpreadsheetBindingMode,
+  createdAt: z50.string(),
+  updatedAt: z50.string()
+});
+var PluginSpreadsheetBindingRefresh = z50.object({
+  id: z50.string(),
+  name: z50.string(),
+  sheetName: z50.string(),
+  rowCount: z50.number()
+});
+var PluginProgramSpreadsheetBindingsCreateArgs = z50.object({
+  name: z50.string(),
+  source: PluginSpreadsheetBindingSource,
+  target: PluginSpreadsheetBindingTarget,
+  mode: PluginSpreadsheetBindingMode.optional()
+});
+var PluginProgramSpreadsheetBindingsCreateResult = PluginSpreadsheetBinding.extend({
+  refresh: PluginSpreadsheetBindingRefresh
+});
+var PluginProgramSpreadsheetBindingsRefreshArgs = z50.object({
+  name: z50.string().optional()
+});
+var PluginProgramSpreadsheetBindingsRefreshResult = z50.object({
+  refreshed: z50.array(PluginSpreadsheetBindingRefresh)
+});
+var PluginProgramSpreadsheetBindingsListResult = z50.object({
+  bindings: z50.array(PluginSpreadsheetBinding)
+});
+
+// src/api/program/site.ts
+import * as z51 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({
+  units: PluginAreaUnit,
+  totalArea: z51.number(),
+  polygonCount: z51.number(),
+  polygons: z51.array(PluginSitePolygon)
+});
+var PluginProgramSiteAreaResult = z51.object({
+  units: PluginAreaUnit,
+  area: z51.number()
+});
+var PluginProgramSiteListPolygonsResult = z51.object({
+  units: PluginAreaUnit,
+  polygons: z51.array(PluginSitePolygon)
+});
+var PluginProgramSiteListGeoPolygonsResult = z51.object({
+  polygons: z51.array(z51.array(PluginSiteGeoPoint))
+});
+var PluginSiteLatLng = z51.object({
+  lat: z51.number(),
+  lng: z51.number()
+});
+var PluginSiteBounds = z51.object({
+  north: z51.number(),
+  south: z51.number(),
+  east: z51.number(),
+  west: z51.number()
+});
+var PluginSiteContextParcel = z51.object({
+  footprint: z51.array(PluginSiteLatLng),
+  area: z51.number()
+});
+var PluginProgramSiteContext = z51.object({
+  center: PluginSiteLatLng,
+  bounds: PluginSiteBounds,
+  widthInM: z51.number(),
+  heightInM: z51.number(),
+  zoom: z51.number(),
+  parcels: z51.array(PluginSiteContextParcel)
+});
+var PluginProgramSiteContextResult = PluginProgramSiteContext.nullable();
+
+// src/api/program/cores.ts
+import * as z52 from "zod";
+var PluginProgramCoresApi = class {
+  constructor() {
+  }
+};
+var PluginProgramCore = z52.object({
+  id: z52.string(),
+  groupId: z52.string(),
+  storey: z52.number()
+});
+var PluginProgramCoresListResult = z52.object({
+  cores: z52.array(PluginProgramCore)
+});
+var PluginProgramCoresIsCoreArgs = z52.object({
+  id: z52.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 PluginProgramCoresCreateArgs = z52.object({
+  cores: z52.array(PluginProgramCoreSpec),
+  lengthUnit: z52.enum(["mm", "m", "ft"]).optional()
+});
+var PluginProgramCoresCreateResult = z52.object({
+  createdCount: z52.number()
+});
+
+// src/api/program/classification.ts
+import * as z53 from "zod";
+var PluginProgramClassificationApi = class {
+  constructor() {
+  }
+};
+var PluginClassificationOption = z53.object({
+  value: z53.string(),
+  label: z53.string()
+});
+var PluginProgramClassificationTypesResult = z53.object({
+  spaceTypes: z53.array(PluginClassificationOption),
+  areaClasses: z53.array(PluginClassificationOption),
+  massTypes: z53.array(PluginClassificationOption)
+});
+var PluginProgramClassificationListTagsArgs = z53.object({
+  id: z53.string()
+});
+var PluginSpaceTag = z53.object({
+  tagId: z53.string(),
+  tagName: z53.string(),
+  color: z53.string(),
+  categoryId: z53.string()
+});
+var PluginProgramClassificationTagsResult = z53.object({
+  tagIds: z53.array(z53.string()),
+  tagsByCategory: z53.record(z53.string(), PluginSpaceTag)
+});
+
+// src/api/program/areas.ts
+import * as z54 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(),
+  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(),
+  targetUnit: PluginAreaUnit
+});
+var PluginProgramAreaMember = z54.object({
+  id: ComponentHandle,
+  label: z54.string(),
+  carpet: z54.number(),
+  builtUp: z54.number(),
+  excluded: z54.number(),
+  isVisible: z54.boolean()
+});
+var PluginProgramAreaGroupBy = z54.enum([
+  "labels",
+  "storeys",
+  "buildings",
+  "departments",
+  "tagCategories"
+]);
+var PluginProgramAreasGetResult = PluginProgramAreaSummary;
+var PluginProgramAreasListArgs = z54.object({
+  groupBy: PluginProgramAreaGroupBy,
+  categoryId: z54.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 PluginProgramAreasListMembersArgs = z54.object({
+  groupBy: PluginProgramAreaGroupBy,
+  groupId: z54.string(),
+  categoryId: z54.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 PluginProgramAreasUpdateArgs = z54.object({
+  targetFar: z54.number().min(0).optional(),
+  siteArea: z54.number().positive().optional(),
+  deviation: z54.number().min(0).max(100).optional()
+});
+var PluginProgramAreasUpdateResult = PluginProgramAreaSummary;
+
+// src/api/program/index.ts
+var PluginProgramApi = class {
+  constructor() {
+  }
+};
+
+// src/api/presentation/views.ts
+import * as z55 from "zod";
+var PluginPresentationViewsApi = class {
+  constructor() {
+  }
+};
+var PluginPresentationViewType = z55.enum(["2d", "3d"]);
+var PluginPresentationView = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  type: PluginPresentationViewType,
+  isActive: z55.boolean()
+});
+var PluginPresentationViewsListResult = z55.object({
+  views: z55.array(PluginPresentationView)
+});
+var PluginPresentationViewsGetArgs = z55.object({
+  id: z55.string()
+});
+var PluginPresentationViewsGetResult = PluginPresentationView.nullable();
+var PluginPresentationImageFormat = z55.enum(["png", "jpeg"]);
+var PluginPresentationViewsCaptureArgs = z55.object({
+  viewId: z55.string().optional(),
+  format: PluginPresentationImageFormat.optional(),
+  resolution: z55.string().optional()
+});
+var PluginPresentationViewsCaptureResult = z55.object({
+  image: z55.string()
+});
+var PluginPresentationViewsSetActiveArgs = z55.object({
+  id: z55.string()
+});
+var PluginPresentationViewsSetActiveResult = z55.object({
+  id: z55.string()
+});
+var PluginPresentationViewsCreateArgs = z55.object({
+  name: z55.string().optional(),
+  kind: z55.enum(["view", "sitePlan"]).optional()
+});
+var PluginPresentationViewsCreateResult = PluginPresentationView;
+
+// src/api/presentation/sheets.ts
+import * as z56 from "zod";
+var PluginPresentationSheetsApi = class {
+  constructor() {
+  }
+};
+var PluginPresentationSheet = z56.object({
+  id: z56.string(),
+  name: z56.string()
+});
+var PluginSheetPosition = z56.object({
+  x: z56.number(),
+  y: z56.number()
+});
+var PluginPresentationSheetsListResult = z56.object({
+  sheets: z56.array(PluginPresentationSheet)
+});
+var PluginPresentationSheetsGetArgs = z56.object({
+  id: z56.string()
+});
+var PluginPresentationSheetsGetResult = PluginPresentationSheet.nullable();
+var PluginPresentationSheetsCreateArgs = z56.object({
+  name: z56.string().optional()
+});
+var PluginPresentationSheetsPlaceArgs = z56.object({
+  sheetId: z56.string(),
+  viewId: z56.string(),
+  position: PluginSheetPosition.optional()
+});
+var PluginPresentationSheetsPlaceResult = z56.object({
+  shapeId: z56.string()
+});
+
+// src/api/presentation/diagrams.ts
+import * as z57 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 PluginPresentationDiagramsPlaceResult = z57.object({
+  shapeIds: z57.array(z57.string())
+});
+
+// src/api/presentation/import.ts
+import * as z58 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()
+}).refine((a) => Boolean(a.url) || Boolean(a.dataUrl), {
+  message: "Provide a url or a dataUrl"
+});
+var PluginPresentationImportResult = z58.object({
+  shapeIds: z58.array(z58.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)])
+);
+var PluginAIInspirationRunMode = z59.enum(["blocking", "job"]);
+var PluginAIInspirationOutputKind = z59.enum([
+  "source",
+  "image",
+  "video"
+]);
+var PluginAIInspirationModelOutput = z59.enum(["image", "video"]);
+var PluginAIInspirationRuntimeProvider = z59.enum(["gpt", "fal"]);
+var PluginAIInspirationPromptStrategy = z59.enum([
+  "gpt-image",
+  "fal-image",
+  "fal-video"
+]);
+var PluginAIInspirationShapeKind = z59.enum(["image", "view", "video"]);
+var PluginAIInspirationVideoMode = z59.enum([
+  "animate",
+  "references",
+  "keyframes"
+]);
+var PluginAIInspirationVideoMotion = z59.enum([
+  "auto",
+  "slow-dolly",
+  "subtle-orbit",
+  "reveal"
+]);
+var PluginAIInspirationVideoDuration = z59.enum(["4s", "6s", "8s"]);
+var PluginAIInspirationJobStatus = z59.enum([
+  "queued",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var PluginAIInspirationWorkflowRunState = z59.enum([
+  "current",
+  "stale",
+  "running",
+  "failed",
+  "superseded"
+]);
+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()
+  }).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()
+    })
+  ).optional(),
+  siteDefaults: z59.object({
+    includeSatellite: z59.boolean().optional(),
+    includeStreetView: z59.boolean().optional(),
+    includeAerial: z59.boolean().optional()
+  }).optional()
+});
+var PluginAIInspirationVideoOptions = z59.object({
+  mode: PluginAIInspirationVideoMode.optional(),
+  endFrameShapeId: z59.string().optional(),
+  motion: PluginAIInspirationVideoMotion.optional(),
+  duration: PluginAIInspirationVideoDuration.optional()
+});
+var PluginAIInspirationModel = z59.object({
+  id: z59.string(),
+  label: z59.string(),
+  supportsMultiImage: z59.boolean(),
+  output: PluginAIInspirationModelOutput,
+  isDefault: z59.boolean().optional()
+});
+var PluginAIInspirationModelCapability = z59.object({
+  id: z59.string(),
+  output: PluginAIInspirationModelOutput,
+  provider: PluginAIInspirationRuntimeProvider,
+  supportsRegionEdit: z59.boolean(),
+  supportsReferenceImages: z59.boolean(),
+  supportsStylePresets: z59.boolean(),
+  supportsSiteContext: z59.boolean(),
+  supportsSketchGuidance: z59.boolean(),
+  supportsKeyframes: z59.boolean(),
+  maxExtraImages: z59.number().int().nonnegative(),
+  promptStrategy: PluginAIInspirationPromptStrategy
+});
+var PluginAIInspirationListModelsResult = z59.object({
+  defaultModelId: z59.string(),
+  models: z59.array(PluginAIInspirationModel)
+});
+var PluginAIInspirationGetModelCapabilitiesArgs = z59.object({
+  modelId: z59.string().min(1)
+});
+var PluginAIInspirationGetModelCapabilitiesResult = z59.object({
+  capability: PluginAIInspirationModelCapability
+});
+var PluginAIInspirationShapeRef = z59.object({
+  shapeId: z59.string(),
+  assetId: z59.string().optional(),
+  kind: PluginAIInspirationShapeKind,
+  name: z59.string().optional(),
+  width: z59.number().finite().optional(),
+  height: z59.number().finite().optional(),
+  outputType: PluginAIInspirationOutputKind.optional(),
+  sourceUrl: z59.string().optional()
+});
+var PluginAIInspirationListSourcesArgs = z59.object({
+  includeGenerated: z59.boolean().optional(),
+  includeSourceUrl: z59.boolean().optional()
+});
+var PluginAIInspirationListSourcesResult = z59.object({
+  sources: z59.array(PluginAIInspirationShapeRef)
+});
+var PluginAIInspirationGetSelectionResult = z59.object({
+  selectedShapeIds: z59.array(z59.string()),
+  sources: z59.array(PluginAIInspirationShapeRef)
+});
+var PluginAIInspirationPresetReferenceImage = z59.object({
+  url: z59.string(),
+  label: z59.string().optional(),
+  weight: z59.number().finite().optional()
+});
+var PluginAIInspirationPreset = z59.object({
+  id: z59.string(),
+  name: z59.string(),
+  source: z59.enum(["curated", "user"]),
+  modelId: z59.string(),
+  categoryId: z59.string().optional(),
+  categoryLabel: z59.string().optional(),
+  description: z59.string().optional(),
+  previewImageUrl: z59.string().optional(),
+  prompt: z59.string().optional(),
+  stylePrompt: z59.string().optional(),
+  tags: z59.array(z59.string()).optional(),
+  referenceImages: z59.array(PluginAIInspirationPresetReferenceImage).optional(),
+  siteDefaults: PluginAIInspirationAppliedPreset.shape.siteDefaults.optional()
+});
+var PluginAIInspirationPresetCategory = z59.object({
+  id: z59.string(),
+  label: z59.string(),
+  description: z59.string().optional()
+});
+var PluginAIInspirationGetPresetCatalogResult = z59.object({
+  categories: z59.array(PluginAIInspirationPresetCategory),
+  presets: z59.array(PluginAIInspirationPreset)
+});
+var PluginAIInspirationOutput = z59.object({
+  outputType: z59.enum(["image", "video"]),
+  shapeId: z59.string(),
+  assetId: z59.string(),
+  outputUrl: z59.string().optional(),
+  position: PluginAIInspirationPoint.optional()
+});
+var PluginAIInspirationDebugSummary = z59.record(z59.string(), JsonValue);
+var PluginAIInspirationRunMetadata = z59.object({
+  geometryFidelity: z59.string().optional(),
+  debugSummary: PluginAIInspirationDebugSummary.optional(),
+  streetViewComposite: z59.object({
+    used: z59.boolean(),
+    renderMode: z59.enum(["prompt_refs_default", "masked_composite_pilot"]),
+    backgroundLabel: z59.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(),
+  appliedPreset: PluginAIInspirationAppliedPreset.optional(),
+  site: PluginAIInspirationSiteOptions.optional(),
+  regionHint: PluginAIInspirationRegionHint.optional(),
+  sketchGuidance: PluginAIInspirationSketchGuidance.optional(),
+  video: PluginAIInspirationVideoOptions.optional(),
+  runMode: PluginAIInspirationRunMode.optional()
+});
+var PluginAIInspirationRunResult = z59.object({
+  jobId: z59.string().optional(),
+  output: PluginAIInspirationOutput.optional(),
+  outputs: z59.array(PluginAIInspirationOutput).optional(),
+  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(),
+  runMode: PluginAIInspirationRunMode.optional()
+});
+var PluginAIInspirationJobProgress = z59.object({
+  currentStep: z59.number().int().nonnegative().optional(),
+  totalSteps: z59.number().int().nonnegative().optional(),
+  message: z59.string().optional()
+});
+var PluginAIInspirationJob = z59.object({
+  jobId: z59.string(),
+  status: PluginAIInspirationJobStatus,
+  createdAt: z59.number(),
+  updatedAt: z59.number(),
+  completedAt: z59.number().optional(),
+  method: z59.string(),
+  progress: PluginAIInspirationJobProgress.optional(),
+  result: PluginAIInspirationRunResult.optional(),
+  error: z59.string().optional()
+});
+var PluginAIInspirationJobArgs = z59.object({
+  jobId: z59.string().min(1)
+});
+var PluginAIInspirationGetJobResult = z59.object({
+  job: PluginAIInspirationJob
+});
+var PluginAIInspirationCancelJobResult = z59.object({
+  job: PluginAIInspirationJob
+});
+var PluginAIInspirationListJobsResult = z59.object({
+  jobs: z59.array(PluginAIInspirationJob)
+});
+var PluginAIInspirationWorkflowVideoConfig = z59.object({
+  mode: z59.string().optional(),
+  motion: z59.string().optional(),
+  duration: z59.string().optional(),
+  endFrameShapeId: z59.string().optional()
+});
+var PluginAIInspirationGenerationInputSnapshot = z59.object({
+  version: z59.literal(1),
+  meta: z59.record(z59.string(), JsonValue),
+  regionHint: PluginAIInspirationRegionHint.optional(),
+  sketchGuidance: z59.record(z59.string(), JsonValue).optional(),
+  sourceCameraHeading: z59.number().finite().optional()
+});
+var PluginAIInspirationWorkflowOperation = z59.object({
+  type: z59.enum(["generate-image", "refine", "generate-video"]),
+  label: z59.string(),
+  prompt: z59.string().optional(),
+  modelId: z59.string().optional(),
+  presetId: z59.string().optional(),
+  presetName: z59.string().optional(),
+  refineFactor: z59.number().finite().optional(),
+  sourceRole: z59.enum(["primary", "end-frame"]).optional(),
+  video: PluginAIInspirationWorkflowVideoConfig.optional(),
+  generationInput: PluginAIInspirationGenerationInputSnapshot.optional()
+});
+var PluginAIInspirationWorkflowNode = z59.object({
+  id: z59.string(),
+  shapeId: z59.string(),
+  assetId: z59.string().optional(),
+  kind: PluginAIInspirationOutputKind,
+  state: z59.string(),
+  runState: PluginAIInspirationWorkflowRunState.optional(),
+  staleReason: z59.string().optional(),
+  incomingEdgeIds: z59.array(z59.string()),
+  outgoingEdgeIds: z59.array(z59.string()),
+  createdAt: z59.number(),
+  updatedAt: z59.number()
+});
+var PluginAIInspirationWorkflowEdge = z59.object({
+  id: z59.string(),
+  sourceNodeId: z59.string(),
+  targetNodeId: z59.string(),
+  arrowShapeId: z59.string().optional(),
+  operation: PluginAIInspirationWorkflowOperation,
+  state: z59.string(),
+  runState: PluginAIInspirationWorkflowRunState.optional(),
+  staleReason: z59.string().optional(),
+  supersededByEdgeId: z59.string().optional(),
+  createdAt: z59.number(),
+  updatedAt: z59.number()
+});
+var PluginAIInspirationWorkflow = z59.object({
+  id: z59.string(),
+  rootNodeIds: z59.array(z59.string()),
+  nodeIds: z59.array(z59.string()),
+  edgeIds: z59.array(z59.string()),
+  nodes: z59.record(z59.string(), PluginAIInspirationWorkflowNode),
+  edges: z59.record(z59.string(), PluginAIInspirationWorkflowEdge),
+  createdAt: z59.number(),
+  updatedAt: z59.number()
+});
+var PluginAIInspirationGetWorkflowForShapeArgs = z59.object({
+  shapeId: z59.string().min(1)
+});
+var PluginAIInspirationGetWorkflowForShapeResult = z59.object({
+  workflow: PluginAIInspirationWorkflow.nullable(),
+  node: PluginAIInspirationWorkflowNode.nullable()
+});
+var PluginAIInspirationRerunPlanResult = z59.discriminatedUnion(
+  "status",
+  [
+    z59.object({
+      status: z59.literal("ready"),
+      workflowId: z59.string(),
+      sourceNode: PluginAIInspirationWorkflowNode,
+      edgeIds: z59.array(z59.string()),
+      edges: z59.array(PluginAIInspirationWorkflowEdge),
+      recipe: z59.lazy(() => PluginAIInspirationRecipe),
+      needsEndFrame: z59.boolean(),
+      defaultEndFrameShapeId: z59.string().nullable()
+    }),
+    z59.object({
+      status: z59.literal("unavailable"),
+      reason: z59.enum([
+        "not-in-workflow",
+        "source-only",
+        "running",
+        "missing-input"
+      ])
+    })
+  ]
+);
+var PluginAIInspirationRerunSelectedBranchArgs = z59.object({
+  shapeId: z59.string().min(1),
+  endFrameShapeId: z59.string().optional(),
+  runMode: PluginAIInspirationRunMode.optional()
+});
+var PluginAIInspirationRecipeSlot = z59.object({
+  id: z59.string(),
+  type: z59.enum(["source-image", "end-frame"]),
+  label: z59.string(),
+  required: z59.boolean()
+});
+var PluginAIInspirationRecipeStep = z59.object({
+  id: z59.string(),
+  operation: PluginAIInspirationWorkflowOperation,
+  outputKind: z59.enum(["image", "video"])
+});
+var PluginAIInspirationRecipeDraft = z59.object({
+  name: z59.string(),
+  summary: z59.string(),
+  slots: z59.array(PluginAIInspirationRecipeSlot),
+  steps: z59.array(PluginAIInspirationRecipeStep).min(1).max(20),
+  outputKind: z59.enum(["image", "video"]),
+  thumbnailUrl: z59.string().optional()
+});
+var PluginAIInspirationRecipe = PluginAIInspirationRecipeDraft.extend({
+  version: z59.literal(1),
+  id: z59.string(),
+  fingerprint: z59.string().optional(),
+  createdAt: z59.number(),
+  updatedAt: z59.number()
+});
+var PluginAIInspirationExtractionResult = z59.discriminatedUnion(
+  "status",
+  [
+    z59.object({
+      status: z59.literal("ready"),
+      draft: PluginAIInspirationRecipeDraft
+    }),
+    z59.object({
+      status: z59.literal("unavailable"),
+      reason: z59.enum([
+        "not-in-workflow",
+        "source-only",
+        "missing-workflow",
+        "missing-node",
+        "missing-input",
+        "invalid-workflow"
+      ])
+    })
+  ]
+);
+var PluginAIInspirationListRecipesResult = z59.object({
+  recipes: z59.array(PluginAIInspirationRecipe)
+});
+var PluginAIInspirationSaveRecipeArgs = z59.object({
+  draft: PluginAIInspirationRecipeDraft,
+  name: z59.string().min(1)
+});
+var PluginAIInspirationSaveRecipeResult = z59.discriminatedUnion(
+  "status",
+  [
+    z59.object({ status: z59.literal("saved"), recipe: PluginAIInspirationRecipe }),
+    z59.object({
+      status: z59.literal("duplicate"),
+      recipe: PluginAIInspirationRecipe
+    }),
+    z59.object({ status: z59.literal("invalid-name"), recipe: z59.null() }),
+    z59.object({ status: z59.literal("failed"), recipe: z59.null() })
+  ]
+);
+var PluginAIInspirationDeleteRecipeArgs = z59.object({
+  recipeId: z59.string().min(1)
+});
+var PluginAIInspirationDeleteRecipeResult = z59.object({
+  deleted: z59.boolean()
+});
+var PluginAIInspirationExtractRecipeFromShapeArgs = z59.object({
+  shapeId: z59.string().min(1)
+});
+var PluginAIInspirationRunRecipeArgs = z59.object({
+  recipeId: z59.string().optional(),
+  recipe: PluginAIInspirationRecipe.optional(),
+  slotShapeIds: z59.record(z59.string(), z59.string()),
+  runMode: PluginAIInspirationRunMode.optional()
+});
+var PluginPresentationAIInspirationApi = class {
+  constructor() {
+  }
+};
+
+// src/api/presentation/index.ts
+var PluginPresentationApi = class {
+  constructor() {
+  }
+};
+
+// src/api/index.ts
+var PluginApi = class {
+  constructor() {
+  }
+};
+export {
+  ArcHandle,
+  BBoxComponents,
+  BooleanOptions,
+  BooleanOutcome,
+  BrepHandle,
+  CircleHandle,
+  CommentHandle,
+  ComponentHandle,
+  ContourHandle,
+  CurveHandle,
+  DEFAULT_ERASE_STRATEGIES,
+  EdgeHandle,
+  ErasableEdgeRef,
+  EraseStrategy,
+  FaceHandle,
+  HalfEdgeHandle,
+  LineHandle,
+  MassHandle,
+  MaterialHandle,
+  OffsetSplitOutcome,
+  PUnitType,
+  PluginAIInspirationAppliedPreset,
+  PluginAIInspirationCancelJobResult,
+  PluginAIInspirationDebugSummary,
+  PluginAIInspirationDeleteRecipeArgs,
+  PluginAIInspirationDeleteRecipeResult,
+  PluginAIInspirationExtractRecipeFromShapeArgs,
+  PluginAIInspirationExtractionResult,
+  PluginAIInspirationGenerateArgs,
+  PluginAIInspirationGenerationInputSnapshot,
+  PluginAIInspirationGetJobResult,
+  PluginAIInspirationGetModelCapabilitiesArgs,
+  PluginAIInspirationGetModelCapabilitiesResult,
+  PluginAIInspirationGetPresetCatalogResult,
+  PluginAIInspirationGetSelectionResult,
+  PluginAIInspirationGetWorkflowForShapeArgs,
+  PluginAIInspirationGetWorkflowForShapeResult,
+  PluginAIInspirationJob,
+  PluginAIInspirationJobArgs,
+  PluginAIInspirationJobProgress,
+  PluginAIInspirationJobStatus,
+  PluginAIInspirationListJobsResult,
+  PluginAIInspirationListModelsResult,
+  PluginAIInspirationListRecipesResult,
+  PluginAIInspirationListSourcesArgs,
+  PluginAIInspirationListSourcesResult,
+  PluginAIInspirationModel,
+  PluginAIInspirationModelCapability,
+  PluginAIInspirationModelOutput,
+  PluginAIInspirationOutput,
+  PluginAIInspirationOutputKind,
+  PluginAIInspirationPoint,
+  PluginAIInspirationPreset,
+  PluginAIInspirationPresetCategory,
+  PluginAIInspirationPresetReferenceImage,
+  PluginAIInspirationPromptStrategy,
+  PluginAIInspirationRecipe,
+  PluginAIInspirationRecipeDraft,
+  PluginAIInspirationRecipeSlot,
+  PluginAIInspirationRecipeStep,
+  PluginAIInspirationRefineArgs,
+  PluginAIInspirationRegionHint,
+  PluginAIInspirationRerunPlanResult,
+  PluginAIInspirationRerunSelectedBranchArgs,
+  PluginAIInspirationRunMetadata,
+  PluginAIInspirationRunMode,
+  PluginAIInspirationRunRecipeArgs,
+  PluginAIInspirationRunResult,
+  PluginAIInspirationRuntimeProvider,
+  PluginAIInspirationSaveRecipeArgs,
+  PluginAIInspirationSaveRecipeResult,
+  PluginAIInspirationShapeKind,
+  PluginAIInspirationShapeRef,
+  PluginAIInspirationSiteOptions,
+  PluginAIInspirationSketchGuidance,
+  PluginAIInspirationTextAnnotation,
+  PluginAIInspirationVideoDuration,
+  PluginAIInspirationVideoMode,
+  PluginAIInspirationVideoMotion,
+  PluginAIInspirationVideoOptions,
+  PluginAIInspirationWorkflow,
+  PluginAIInspirationWorkflowEdge,
+  PluginAIInspirationWorkflowNode,
+  PluginAIInspirationWorkflowOperation,
+  PluginAIInspirationWorkflowRunState,
+  PluginAIInspirationWorkflowVideoConfig,
+  PluginAdjacencyLevel,
+  PluginApi,
+  PluginAreaClass,
+  PluginAreaUnit,
+  PluginBuildableEnvelopeApi,
+  PluginBuildableEnvelopeCreateArgs,
+  PluginBuildableEnvelopeCreateResult,
+  PluginBuildableEnvelopePolygonVertex,
+  PluginBuildableEnvelopeSetbackTier,
+  PluginBuildableEnvelopeUpdateArgs,
+  PluginBuildableEnvelopeUpdateResult,
+  PluginBuildableEnvelopeVerticalCap,
+  PluginClassificationOption,
+  PluginCommentApi,
+  PluginCommentCreateArgs,
+  PluginCommentRefArgs,
+  PluginCommentTagArgs,
+  PluginCommentUpdateArgs,
+  PluginCopyMode,
+  PluginCoreApi,
+  PluginCoreAssignOutcome,
+  PluginCoreBuildingRef,
+  PluginCoreBuildingsApi,
+  PluginCoreBuildingsCopyArgs,
+  PluginCoreBuildingsCopyResult,
+  PluginCoreBuildingsCreateArgs,
+  PluginCoreBuildingsCreateResult,
+  PluginCoreBuildingsDeleteArgs,
+  PluginCoreBuildingsDeleteResult,
+  PluginCoreBuildingsGetActiveResult,
+  PluginCoreBuildingsGetArgs,
+  PluginCoreBuildingsGetResult,
+  PluginCoreBuildingsListResult,
+  PluginCoreBuildingsListStoreysArgs,
+  PluginCoreBuildingsListStoreysResult,
+  PluginCoreBuildingsSetActiveArgs,
+  PluginCoreBuildingsSetActiveResult,
+  PluginCoreBuildingsUpdateArgs,
+  PluginCoreBuildingsUpdateResult,
+  PluginCoreComponentTag,
+  PluginCoreGroupMember,
+  PluginCoreGroupRef,
+  PluginCoreGroupsApi,
+  PluginCoreGroupsCreateArgs,
+  PluginCoreGroupsCreateResult,
+  PluginCoreGroupsDeleteArgs,
+  PluginCoreGroupsDeleteResult,
+  PluginCoreGroupsGetArgs,
+  PluginCoreGroupsGetBoundsArgs,
+  PluginCoreGroupsGetBoundsResult,
+  PluginCoreGroupsGetForComponentArgs,
+  PluginCoreGroupsGetForComponentResult,
+  PluginCoreGroupsGetResult,
+  PluginCoreGroupsIsLockedArgs,
+  PluginCoreGroupsIsLockedResult,
+  PluginCoreGroupsListMembersArgs,
+  PluginCoreGroupsListMembersResult,
+  PluginCoreGroupsListResult,
+  PluginCoreGroupsUpdateArgs,
+  PluginCoreGroupsUpdateResult,
+  PluginCoreLayer,
+  PluginCoreLayerType,
+  PluginCoreLayersApi,
+  PluginCoreLayersGetActiveArgs,
+  PluginCoreLayersGetActiveResult,
+  PluginCoreLayersGetArgs,
+  PluginCoreLayersGetResult,
+  PluginCoreLayersListArgs,
+  PluginCoreLayersListResult,
+  PluginCoreLayersSetActiveArgs,
+  PluginCoreLayersSetActiveResult,
+  PluginCoreLayersUpdateArgs,
+  PluginCoreLayersUpdateResult,
+  PluginCoreTag,
+  PluginCoreTagCategory,
+  PluginCoreTagsApi,
+  PluginCoreTagsAssignArgs,
+  PluginCoreTagsAssignResult,
+  PluginCoreTagsCreateArgs,
+  PluginCoreTagsCreateCategoryArgs,
+  PluginCoreTagsCreateCategoryResult,
+  PluginCoreTagsCreateResult,
+  PluginCoreTagsDeleteArgs,
+  PluginCoreTagsDeleteCategoryArgs,
+  PluginCoreTagsDeleteCategoryResult,
+  PluginCoreTagsDeleteResult,
+  PluginCoreTagsGetArgs,
+  PluginCoreTagsGetCategoryArgs,
+  PluginCoreTagsGetCategoryResult,
+  PluginCoreTagsGetResult,
+  PluginCoreTagsGetTagsForComponentArgs,
+  PluginCoreTagsGetTagsForComponentResult,
+  PluginCoreTagsListArgs,
+  PluginCoreTagsListCategoriesResult,
+  PluginCoreTagsListComponentsArgs,
+  PluginCoreTagsListComponentsResult,
+  PluginCoreTagsListResult,
+  PluginCoreTagsUnassignArgs,
+  PluginCoreTagsUnassignResult,
+  PluginCoreTagsUpdateArgs,
+  PluginCoreTagsUpdateCategoryArgs,
+  PluginCoreTagsUpdateCategoryResult,
+  PluginCoreTagsUpdateResult,
+  PluginCreateSpaceItem,
+  PluginDepartmentId,
+  PluginDesignApi,
+  PluginDesignBooleanApi,
+  PluginDesignBooleanIntersectArgs,
+  PluginDesignBooleanSubtractArgs,
+  PluginDesignBooleanUnionArgs,
+  PluginDesignChangeResult,
+  PluginDesignCreateApi,
+  PluginDesignCreateBeamArgs,
+  PluginDesignCreateCeilingArgs,
+  PluginDesignCreateColumnArgs,
+  PluginDesignCreateCopyArgs,
+  PluginDesignCreateFloorArgs,
+  PluginDesignCreateFurnitureArgs,
+  PluginDesignCreateMassArgs,
+  PluginDesignCreateReferenceLinesArgs,
+  PluginDesignCreateRoofArgs,
+  PluginDesignCreateSlabArgs,
+  PluginDesignCreateSpaceArgs,
+  PluginDesignCreateStaircaseArgs,
+  PluginDesignCreateWallsArgs,
+  PluginDesignDeleteApi,
+  PluginDesignDeleteEntitiesArgs,
+  PluginDesignDoorArgs,
+  PluginDesignDoorMirrorArgs,
+  PluginDesignDoorSetHeightArgs,
+  PluginDesignDoorSetWidthArgs,
+  PluginDesignDoorsApi,
+  PluginDesignEditApi,
+  PluginDesignEraseApi,
+  PluginDesignEraseEdgeArgs,
+  PluginDesignEraseEdgeResult,
+  PluginDesignFurnitureApi,
+  PluginDesignFurnitureExistsArgs,
+  PluginDesignFurnitureGetCatalogItemArgs,
+  PluginDesignFurnitureListCatalogArgs,
+  PluginDesignIsLockedArgs,
+  PluginDesignListErasableEdgesArgs,
+  PluginDesignLockArgs,
+  PluginDesignMaterialsApi,
+  PluginDesignMaterialsApplyArgs,
+  PluginDesignMaterialsComponentArgs,
+  PluginDesignMaterialsCreateArgs,
+  PluginDesignMaterialsGetInfoArgs,
+  PluginDesignMaterialsListArgs,
+  PluginDesignMaterialsResetArgs,
+  PluginDesignMoveArgs,
+  PluginDesignOffsetSplitArgs,
+  PluginDesignQueryApi,
+  PluginDesignQueryComponentArgs,
+  PluginDesignQueryComponentsArgs,
+  PluginDesignQueryGeometryApi,
+  PluginDesignQueryGeometryGetBottomContourArgs,
+  PluginDesignQueryGeometryGetBrepArgs,
+  PluginDesignQueryGeometryGetCenterlineArgs,
+  PluginDesignQueryGetFootprintArgs,
+  PluginDesignQueryIdArgs,
+  PluginDesignQueryListByTypeArgs,
+  PluginDesignQuerySpacesApi,
+  PluginDesignQuerySpacesGetArgs,
+  PluginDesignQuerySpacesGetProperty,
+  PluginDesignQuerySpacesGetResult,
+  PluginDesignRotateArgs,
+  PluginDesignSelectionAddArgs,
+  PluginDesignSelectionApi,
+  PluginDesignSelectionRemoveArgs,
+  PluginDesignSelectionSetArgs,
+  PluginDesignTransformApi,
+  PluginDesignUnlockArgs,
+  PluginDesignUpdateApi,
+  PluginDesignWindowArgs,
+  PluginDesignWindowSetHeightArgs,
+  PluginDesignWindowSetWidthArgs,
+  PluginDesignWindowsApi,
+  PluginEntityApi,
+  PluginEntityFilter,
+  PluginEntityMeasurements,
+  PluginEntityProperties,
+  PluginEntityType,
+  PluginFurnitureCatalogItem,
+  PluginGeomApi,
+  PluginGeomCreateApi,
+  PluginGeomCreateArcArgs,
+  PluginGeomCreateCircleArgs,
+  PluginGeomCreateContourFromProfileArgs,
+  PluginGeomCreateContourFromProfilesArgs,
+  PluginGeomCreateLineArgs,
+  PluginGeomCreateProfileFromCurvesArgs,
+  PluginGeomCreateProfileFromLinePointsArgs,
+  PluginGeomDeleteApi,
+  PluginGeomDeleteContourArgs,
+  PluginGeomDeleteProfileArgs,
+  PluginGeomQueryApi,
+  PluginGeomQueryArcApi,
+  PluginGeomQueryArcGetAxisArgs,
+  PluginGeomQueryArcGetCentreArgs,
+  PluginGeomQueryArcGetRadiusArgs,
+  PluginGeomQueryArcGetSweepAngleArgs,
+  PluginGeomQueryArcIsValidArgs,
+  PluginGeomQueryBrepApi,
+  PluginGeomQueryBrepGetBoundingBoxArgs,
+  PluginGeomQueryBrepGetCentroidArgs,
+  PluginGeomQueryBrepGetEdgeArgs,
+  PluginGeomQueryBrepGetEdgeCountArgs,
+  PluginGeomQueryBrepGetFaceCountArgs,
+  PluginGeomQueryBrepGetHalfEdgeCountArgs,
+  PluginGeomQueryBrepGetVertexCountArgs,
+  PluginGeomQueryBrepGetVertexPositionArgs,
+  PluginGeomQueryBrepHasEdgeArgs,
+  PluginGeomQueryBrepIsEqualArgs,
+  PluginGeomQueryBrepListEdgesArgs,
+  PluginGeomQueryBrepListEdgesBetweenArgs,
+  PluginGeomQueryBrepListFacesArgs,
+  PluginGeomQueryBrepListHalfEdgesArgs,
+  PluginGeomQueryBrepListVertexPositionsArgs,
+  PluginGeomQueryBrepListVerticesArgs,
+  PluginGeomQueryCircleApi,
+  PluginGeomQueryCircleGetAxisArgs,
+  PluginGeomQueryCircleGetCentreArgs,
+  PluginGeomQueryCircleGetLengthArgs,
+  PluginGeomQueryCircleGetNearestPointArgs,
+  PluginGeomQueryCircleGetNormalArgs,
+  PluginGeomQueryCircleGetPointAtDistanceArgs,
+  PluginGeomQueryCircleGetRadiusArgs,
+  PluginGeomQueryCircleGetTangentArgs,
+  PluginGeomQueryCircleHasPointArgs,
+  PluginGeomQueryCircleIsEqualArgs,
+  PluginGeomQueryCircleIsValidArgs,
+  PluginGeomQueryCircleListPointsArgs,
+  PluginGeomQueryContourApi,
+  PluginGeomQueryContourGetAreaArgs,
+  PluginGeomQueryContourGetBoundingBoxArgs,
+  PluginGeomQueryContourGetHoleCountArgs,
+  PluginGeomQueryContourGetNearestPointArgs,
+  PluginGeomQueryContourGetNormalArgs,
+  PluginGeomQueryContourGetOuterProfileArgs,
+  PluginGeomQueryContourGetPerimeterArgs,
+  PluginGeomQueryContourHasPointArgs,
+  PluginGeomQueryContourIsClockwiseArgs,
+  PluginGeomQueryContourIsEmptyArgs,
+  PluginGeomQueryContourIsEqualArgs,
+  PluginGeomQueryContourIsOnBoundaryArgs,
+  PluginGeomQueryContourIsOrientationValidArgs,
+  PluginGeomQueryContourIsPlanarArgs,
+  PluginGeomQueryContourIsSelfIntersectingArgs,
+  PluginGeomQueryContourListHolesArgs,
+  PluginGeomQueryCurveApi,
+  PluginGeomQueryCurveGetChordLengthArgs,
+  PluginGeomQueryCurveGetCommonPartArgs,
+  PluginGeomQueryCurveGetCurvatureArgs,
+  PluginGeomQueryCurveGetDistanceAlongArgs,
+  PluginGeomQueryCurveGetDistanceBetweenArgs,
+  PluginGeomQueryCurveGetDistanceToPointArgs,
+  PluginGeomQueryCurveGetEndPointArgs,
+  PluginGeomQueryCurveGetLengthArgs,
+  PluginGeomQueryCurveGetMergedCurveArgs,
+  PluginGeomQueryCurveGetMidPointArgs,
+  PluginGeomQueryCurveGetNearestPointArgs,
+  PluginGeomQueryCurveGetNormalArgs,
+  PluginGeomQueryCurveGetParameterAtPointArgs,
+  PluginGeomQueryCurveGetPointAtDistanceArgs,
+  PluginGeomQueryCurveGetProjectionArgs,
+  PluginGeomQueryCurveGetShortestGapArgs,
+  PluginGeomQueryCurveGetStartPointArgs,
+  PluginGeomQueryCurveGetTangentArgs,
+  PluginGeomQueryCurveHasPointArgs,
+  PluginGeomQueryCurveIsContinuousArgs,
+  PluginGeomQueryCurveIsEqualArgs,
+  PluginGeomQueryCurveIsLinearArgs,
+  PluginGeomQueryCurveIsOnCurveArgs,
+  PluginGeomQueryCurveIsOverlappingArgs,
+  PluginGeomQueryCurveIsParallelArgs,
+  PluginGeomQueryCurveListIntersectionsArgs,
+  PluginGeomQueryCurveListPointsArgs,
+  PluginGeomQueryCurveListSubdivisionsArgs,
+  PluginGeomQueryEdgeApi,
+  PluginGeomQueryEdgeGetCurveArgs,
+  PluginGeomQueryEdgeGetHalfEdgeArgs,
+  PluginGeomQueryEdgeGetIndexArgs,
+  PluginGeomQueryEdgeListFacesArgs,
+  PluginGeomQueryEdgeListVerticesArgs,
+  PluginGeomQueryFaceApi,
+  PluginGeomQueryFaceGetHalfEdgeArgs,
+  PluginGeomQueryFaceGetHoleContainingHalfEdgeArgs,
+  PluginGeomQueryFaceGetHoleCountArgs,
+  PluginGeomQueryFaceGetIndexArgs,
+  PluginGeomQueryFaceGetMaterialIndexArgs,
+  PluginGeomQueryFaceHasHolesArgs,
+  PluginGeomQueryFaceListAdjacentFacesArgs,
+  PluginGeomQueryFaceListEdgesArgs,
+  PluginGeomQueryFaceListHalfEdgesArgs,
+  PluginGeomQueryFaceListHoleHalfEdgesArgs,
+  PluginGeomQueryFaceListHolesArgs,
+  PluginGeomQueryFaceListVertexPositionsArgs,
+  PluginGeomQueryFaceListVertexPositionsWithCurvesArgs,
+  PluginGeomQueryFaceListVerticesArgs,
+  PluginGeomQueryHalfEdgeApi,
+  PluginGeomQueryHalfEdgeGetEdgeArgs,
+  PluginGeomQueryHalfEdgeGetFaceArgs,
+  PluginGeomQueryHalfEdgeGetFlipArgs,
+  PluginGeomQueryHalfEdgeGetNextArgs,
+  PluginGeomQueryHalfEdgeGetPrevArgs,
+  PluginGeomQueryHalfEdgeGetVertexArgs,
+  PluginGeomQueryHalfEdgeIsForwardArgs,
+  PluginGeomQueryHalfEdgeIsOnBoundaryArgs,
+  PluginGeomQueryProfileApi,
+  PluginGeomQueryProfileGetAreaArgs,
+  PluginGeomQueryProfileGetBoundingBoxArgs,
+  PluginGeomQueryProfileGetNearestPointArgs,
+  PluginGeomQueryProfileGetNormalArgs,
+  PluginGeomQueryProfileGetPerimeterArgs,
+  PluginGeomQueryProfileHasPointArgs,
+  PluginGeomQueryProfileIsClockwiseArgs,
+  PluginGeomQueryProfileIsClosedArgs,
+  PluginGeomQueryProfileIsEmptyArgs,
+  PluginGeomQueryProfileIsEqualArgs,
+  PluginGeomQueryProfileIsOnBoundaryArgs,
+  PluginGeomQueryProfileIsPlanarArgs,
+  PluginGeomQueryProfileIsSelfIntersectingArgs,
+  PluginGeomQueryProfileListCurvesArgs,
+  PluginGeomQueryProfileListPointsArgs,
+  PluginGeomQueryVertexApi,
+  PluginGeomQueryVertexGetHalfEdgeArgs,
+  PluginGeomQueryVertexGetIndexArgs,
+  PluginGeomQueryVertexGetPositionArgs,
+  PluginGeomQueryVertexListEdgesArgs,
+  PluginGeomQueryVertexListFacesArgs,
+  PluginGeomQueryVertexListHalfEdgesArgs,
+  PluginGeomQueryVertexListNeighborsArgs,
+  PluginGeomUpdateApi,
+  PluginGeomUpdateContourAddHoleArgs,
+  PluginGeomUpdateContourApi,
+  PluginGeomUpdateContourMirrorArgs,
+  PluginGeomUpdateContourMoveArgs,
+  PluginGeomUpdateContourOffsetArgs,
+  PluginGeomUpdateContourRemoveHoleArgs,
+  PluginGeomUpdateContourRotateArgs,
+  PluginGeomUpdateContourScaleArgs,
+  PluginGeomUpdateCurveApi,
+  PluginGeomUpdateCurveExtendArgs,
+  PluginGeomUpdateCurveOffsetArgs,
+  PluginGeomUpdateCurveReverseArgs,
+  PluginGeomUpdateCurveSplitArgs,
+  PluginGeomUpdateCurveTrimArgs,
+  PluginGeomUpdateProfileAddArgs,
+  PluginGeomUpdateProfileApi,
+  PluginGeomUpdateProfileMirrorArgs,
+  PluginGeomUpdateProfileMoveArgs,
+  PluginGeomUpdateProfileOffsetArgs,
+  PluginGeomUpdateProfileRemoveArgs,
+  PluginGeomUpdateProfileReverseArgs,
+  PluginGeomUpdateProfileRotateArgs,
+  PluginGeomUpdateProfileScaleArgs,
+  PluginGeomUpdateProfileSimplifyArgs,
+  PluginGridApi,
+  PluginGridValueArgs,
+  PluginHistoryApi,
+  PluginHistoryStepArgs,
+  PluginHistoryStepResult,
+  PluginMassType,
+  PluginMaterialInfo,
+  PluginMaterialResult,
+  PluginMaterialSpec,
+  PluginMathApi,
+  PluginMirrorAxis,
+  PluginPresentationAIInspirationApi,
+  PluginPresentationApi,
+  PluginPresentationDiagramsApi,
+  PluginPresentationDiagramsPlaceArgs,
+  PluginPresentationDiagramsPlaceResult,
+  PluginPresentationImageFormat,
+  PluginPresentationImportApi,
+  PluginPresentationImportArgs,
+  PluginPresentationImportResult,
+  PluginPresentationSheet,
+  PluginPresentationSheetsApi,
+  PluginPresentationSheetsCreateArgs,
+  PluginPresentationSheetsGetArgs,
+  PluginPresentationSheetsGetResult,
+  PluginPresentationSheetsListResult,
+  PluginPresentationSheetsPlaceArgs,
+  PluginPresentationSheetsPlaceResult,
+  PluginPresentationView,
+  PluginPresentationViewType,
+  PluginPresentationViewsApi,
+  PluginPresentationViewsCaptureArgs,
+  PluginPresentationViewsCaptureResult,
+  PluginPresentationViewsCreateArgs,
+  PluginPresentationViewsCreateResult,
+  PluginPresentationViewsGetArgs,
+  PluginPresentationViewsGetResult,
+  PluginPresentationViewsListResult,
+  PluginPresentationViewsSetActiveArgs,
+  PluginPresentationViewsSetActiveResult,
+  PluginProgramAdjacencyApi,
+  PluginProgramAdjacencyComputeResult,
+  PluginProgramAdjacencyGetMatrixArgs,
+  PluginProgramAdjacencyGetMatrixResult,
+  PluginProgramApi,
+  PluginProgramAreaGroup,
+  PluginProgramAreaGroupBy,
+  PluginProgramAreaMember,
+  PluginProgramAreaSummary,
+  PluginProgramAreasApi,
+  PluginProgramAreasGetResult,
+  PluginProgramAreasListArgs,
+  PluginProgramAreasListMembersArgs,
+  PluginProgramAreasListMembersResult,
+  PluginProgramAreasListResult,
+  PluginProgramAreasUpdateArgs,
+  PluginProgramAreasUpdateResult,
+  PluginProgramClassificationApi,
+  PluginProgramClassificationListTagsArgs,
+  PluginProgramClassificationTagsResult,
+  PluginProgramClassificationTypesResult,
+  PluginProgramCore,
+  PluginProgramCoreSpec,
+  PluginProgramCoresApi,
+  PluginProgramCoresCreateArgs,
+  PluginProgramCoresCreateResult,
+  PluginProgramCoresIsCoreArgs,
+  PluginProgramCoresListResult,
+  PluginProgramDepartment,
+  PluginProgramDepartmentMetric,
+  PluginProgramDepartmentRecord,
+  PluginProgramDepartmentsApi,
+  PluginProgramDepartmentsAssignArgs,
+  PluginProgramDepartmentsAssignResult,
+  PluginProgramDepartmentsCreateArgs,
+  PluginProgramDepartmentsCreateResult,
+  PluginProgramDepartmentsDeleteArgs,
+  PluginProgramDepartmentsDeleteResult,
+  PluginProgramDepartmentsGetArgs,
+  PluginProgramDepartmentsGetResult,
+  PluginProgramDepartmentsListResult,
+  PluginProgramDepartmentsSetTargetAreaArgs,
+  PluginProgramDepartmentsSetTargetAreaResult,
+  PluginProgramDepartmentsUnassignArgs,
+  PluginProgramDepartmentsUnassignResult,
+  PluginProgramDepartmentsUpdateArgs,
+  PluginProgramDepartmentsUpdateResult,
+  PluginProgramLayoutApi,
+  PluginProgramLayoutRunResult,
+  PluginProgramMetricsApi,
+  PluginProgramMetricsSummary,
+  PluginProgramSiteApi,
+  PluginProgramSiteAreaResult,
+  PluginProgramSiteContext,
+  PluginProgramSiteContextResult,
+  PluginProgramSiteListGeoPolygonsResult,
+  PluginProgramSiteListPolygonsResult,
+  PluginProgramSiteSnapshot,
+  PluginProgramSpreadsheetAddChartArgs,
+  PluginProgramSpreadsheetAddChartResult,
+  PluginProgramSpreadsheetAddConditionalFormattingArgs,
+  PluginProgramSpreadsheetAddConditionalFormattingResult,
+  PluginProgramSpreadsheetApi,
+  PluginProgramSpreadsheetBindingsApi,
+  PluginProgramSpreadsheetBindingsCreateArgs,
+  PluginProgramSpreadsheetBindingsCreateResult,
+  PluginProgramSpreadsheetBindingsListResult,
+  PluginProgramSpreadsheetBindingsRefreshArgs,
+  PluginProgramSpreadsheetBindingsRefreshResult,
+  PluginProgramSpreadsheetCreateSheetArgs,
+  PluginProgramSpreadsheetCreateSheetResult,
+  PluginProgramSpreadsheetExportArgs,
+  PluginProgramSpreadsheetExportResult,
+  PluginProgramSpreadsheetGetAuditLogArgs,
+  PluginProgramSpreadsheetGetAuditLogResult,
+  PluginProgramSpreadsheetGetProgramResult,
+  PluginProgramSpreadsheetGetSheetDataArgs,
+  PluginProgramSpreadsheetGetSheetDataResult,
+  PluginProgramSpreadsheetGetTakeoffResult,
+  PluginProgramSpreadsheetHighlightCellsArgs,
+  PluginProgramSpreadsheetHighlightCellsResult,
+  PluginProgramSpreadsheetListSheetsResult,
+  PluginProgramSpreadsheetMergeCellsArgs,
+  PluginProgramSpreadsheetMergeCellsResult,
+  PluginProgramSpreadsheetPingResult,
+  PluginProgramSpreadsheetRecalculateArgs,
+  PluginProgramSpreadsheetRecalculateResult,
+  PluginProgramSpreadsheetRenderArgs,
+  PluginProgramSpreadsheetRenderDatasetArgs,
+  PluginProgramSpreadsheetRenderResult,
+  PluginProgramSpreadsheetRunScriptArgs,
+  PluginProgramSpreadsheetRunScriptResult,
+  PluginProgramSpreadsheetSetFormulasArgs,
+  PluginProgramSpreadsheetSetFormulasResult,
+  PluginProgramSpreadsheetSetStylesArgs,
+  PluginProgramSpreadsheetSetStylesResult,
+  PluginProgramSpreadsheetSetValuesArgs,
+  PluginProgramSpreadsheetSetValuesResult,
+  PluginProgramSpreadsheetTemplatesApi,
+  PluginProgramSpreadsheetTemplatesApplyArgs,
+  PluginProgramSpreadsheetTemplatesApplyResult,
+  PluginProgramSpreadsheetTemplatesCreateArgs,
+  PluginProgramSpreadsheetTemplatesCreateResult,
+  PluginProgramSpreadsheetTransactionArgs,
+  PluginProgramSpreadsheetTransactionResult,
+  PluginProjectApi,
+  PluginProjectSettingsApi,
+  PluginQuatApi,
+  PluginReferenceLineApi,
+  PluginReferenceLineCreateMultiArgs,
+  PluginReferenceLineCreateMultiResult,
+  PluginReferenceLineDeleteArgs,
+  PluginReferenceLineGetAllResult,
+  PluginReferenceLineGetArgs,
+  PluginReferenceLineGetProperty,
+  PluginReferenceLineGetResult,
+  PluginReferenceLineStyle,
+  PluginSheetPosition,
+  PluginSiteBounds,
+  PluginSiteContextParcel,
+  PluginSiteFootprintPoint,
+  PluginSiteGeoPoint,
+  PluginSiteLatLng,
+  PluginSitePolygon,
+  PluginSlabType,
+  PluginSnapValueArgs,
+  PluginSnapsApi,
+  PluginSpaceBulkCreateArgs,
+  PluginSpaceBulkCreateItem,
+  PluginSpaceBulkCreateResult,
+  PluginSpaceBulkDeleteArgs,
+  PluginSpaceBulkDeleteResult,
+  PluginSpaceBulkUpdateArgs,
+  PluginSpaceBulkUpdateItem,
+  PluginSpaceBulkUpdateResult,
+  PluginSpaceCreateFromProfileArgs,
+  PluginSpaceCreateFromProfileResult,
+  PluginSpaceCreateRectangularArgs,
+  PluginSpaceCreateRectangularResult,
+  PluginSpaceDeleteArgs,
+  PluginSpaceGeometryUpdate,
+  PluginSpaceGetAllResult,
+  PluginSpaceGetArgs,
+  PluginSpaceGetProperty,
+  PluginSpaceGetResult,
+  PluginSpacePropertyUpdates,
+  PluginSpaceTag,
+  PluginSpaceType,
+  PluginSpaceUpdateArgs,
+  PluginSpaceUpdateGeometryFromProfileArgs,
+  PluginSpaceUpdateGeometryFromProfileResult,
+  PluginSpaceUpdateResult,
+  PluginSpreadsheetAlign,
+  PluginSpreadsheetAuditEntry,
+  PluginSpreadsheetAuditStatus,
+  PluginSpreadsheetBinding,
+  PluginSpreadsheetBindingMode,
+  PluginSpreadsheetBindingRefresh,
+  PluginSpreadsheetBindingSource,
+  PluginSpreadsheetBindingTarget,
+  PluginSpreadsheetCell,
+  PluginSpreadsheetCellStyle,
+  PluginSpreadsheetChartType,
+  PluginSpreadsheetColumn,
+  PluginSpreadsheetConditionalRule,
+  PluginSpreadsheetConditionalRuleType,
+  PluginSpreadsheetExportFormat,
+  PluginSpreadsheetFontStyle,
+  PluginSpreadsheetFontWeight,
+  PluginSpreadsheetFormula,
+  PluginSpreadsheetHorizontalAlign,
+  PluginSpreadsheetProgramRow,
+  PluginSpreadsheetRangeStyle,
+  PluginSpreadsheetSheetInfo,
+  PluginSpreadsheetTakeoffRow,
+  PluginSpreadsheetTemplateScope,
+  PluginSpreadsheetTotal,
+  PluginSpreadsheetTransactionMethod,
+  PluginSpreadsheetTransactionOp,
+  PluginSpreadsheetVerticalAlign,
+  PluginSpreadsheetWhenExists,
+  PluginStaircasePreset,
+  PluginStoryApi,
+  PluginStoryCreateArgs,
+  PluginStoryCreateResult,
+  PluginStoryGetAllResult,
+  PluginStoryGetArgs,
+  PluginStoryGetProperty,
+  PluginStoryGetResult,
+  PluginStoryUpdateArgs,
+  PluginStoryUpdateResult,
+  PluginToleranceArgs,
+  PluginUnitsApi,
+  PluginUnitsConvertArgs,
+  PluginUnitsSetTypeArgs,
+  PluginUpdateSpaceItem,
+  PluginVec3Api,
+  PluginWellKnownDepartmentId,
+  PluginWindowDimensions,
+  PluginZoomApi,
+  ProfileHandle,
+  QuatComponents,
+  QuatHandle,
+  Vec3Components,
+  Vec3Handle,
+  VertexHandle,
+  handleSchema
+};
+//# sourceMappingURL=index.js.map