@snaptrude/plugin-core 0.3.0 → 0.6.0

package/dist/index.js

@@ -1,984 +1,3731 @@
 // src/api/core/math/vec3.ts
-import * as z from "zod";
 var PluginVec3Api = class {
   constructor() {
   }
-  /**
-   * Create a new 3D vector.
-   *
-   * @param x - The X component
-   * @param y - The Y component
-   * @param z - The Z component
-   * @returns A new {@linkcode PVec3}
-   *
-   * # Example
-   * ```ts
-   * const position = snaptrude.core.math.vec3.new(1, 2, 3)
-   * // { x: 1, y: 2, z: 3 }
-   * ```
-   */
-  new(x, y, z17) {
-    return { x, y, z: z17 };
-  }
-  /**
-   * Add two vectors component-wise.
-   *
-   * @param a - First vector
-   * @param b - Second vector
-   * @returns A new {@linkcode PVec3} where each component is `a[i] + b[i]`
-   */
-  add(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-  }
-  /**
-   * Subtract vector {@linkcode b} from vector {@linkcode a} component-wise.
-   *
-   * @param a - Vector to subtract from
-   * @param b - Vector to subtract
-   * @returns A new {@linkcode PVec3} where each component is `a[i] - b[i]`
-   */
-  subtract(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-  }
-  /**
-   * Scale a vector by a scalar value.
-   *
-   * @param v - The vector to scale
-   * @param scalar - The scalar multiplier
-   * @returns A new {@linkcode PVec3} where each component is `v[i] * scalar`
-   */
-  scale(v, scalar) {
-    return { x: v.x * scalar, y: v.y * scalar, z: v.z * scalar };
-  }
-  /**
-   * Compute the dot product of two vectors.
-   *
-   * The dot product equals `|a| * |b| * cos(θ)` where `θ` is the angle
-   * between the vectors. Useful for checking orthogonality (result = 0)
-   * or projection.
-   *
-   * @param a - First vector
-   * @param b - Second vector
-   * @returns The scalar dot product
-   */
-  dot(a, b) {
-    return a.x * b.x + a.y * b.y + a.z * b.z;
-  }
-  /**
-   * Compute the cross product of two vectors.
-   *
-   * The result is a vector perpendicular to both inputs, with magnitude
-   * equal to the area of the parallelogram they span. Useful for computing
-   * surface normals.
-   *
-   * @param a - First vector
-   * @param b - Second vector
-   * @returns A new {@linkcode PVec3} perpendicular to both {@linkcode a} and {@linkcode b}
-   */
-  cross(a, b) {
-    return {
-      x: a.y * b.z - a.z * b.y,
-      y: a.z * b.x - a.x * b.z,
-      z: a.x * b.y - a.y * b.x
-    };
-  }
-  /**
-   * Compute the length (magnitude) of a vector.
-   *
-   * @param v - The vector
-   * @returns The Euclidean length `√(x² + y² + z²)`
-   */
-  length(v) {
-    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-  }
-  /**
-   * Compute the squared length of a vector.
-   *
-   * Avoids the `sqrt` call — prefer this over {@linkcode PluginVec3Api.length}
-   * when comparing relative magnitudes.
-   *
-   * @param v - The vector
-   * @returns The squared length `x² + y² + z²`
-   */
-  lengthSquared(v) {
-    return v.x * v.x + v.y * v.y + v.z * v.z;
-  }
-  /**
-   * Normalize a vector to unit length.
-   *
-   * @param v - The vector to normalize
-   * @returns A new unit-length {@linkcode PVec3} in the same direction,
-   *   or a zero vector `(0, 0, 0)` if the input has zero length
-   */
-  normalize(v) {
-    const len = this.length(v);
-    if (len === 0) return { x: 0, y: 0, z: 0 };
-    return { x: v.x / len, y: v.y / len, z: v.z / len };
-  }
-  /**
-   * Compute the Euclidean distance between two points.
-   *
-   * @param a - First point
-   * @param b - Second point
-   * @returns The distance `|a - b|`
-   */
-  distance(a, b) {
-    return this.length(this.subtract(a, b));
-  }
-  /**
-   * Linearly interpolate between two vectors.
-   *
-   * @param a - Start vector (returned when `t = 0`)
-   * @param b - End vector (returned when `t = 1`)
-   * @param t - Interpolation factor, typically in `[0, 1]`
-   * @returns A new {@linkcode PVec3} at `a + (b - a) * t`
-   */
-  lerp(a, b, t) {
-    return {
-      x: a.x + (b.x - a.x) * t,
-      y: a.y + (b.y - a.y) * t,
-      z: a.z + (b.z - a.z) * t
-    };
-  }
-  /**
-   * Negate a vector (reverse its direction).
-   *
-   * @param v - The vector to negate
-   * @returns A new {@linkcode PVec3} with all components negated
-   */
-  negate(v) {
-    return { x: -v.x, y: -v.y, z: -v.z };
-  }
-  /**
-   * Check if two vectors are exactly equal (strict equality per component).
-   *
-   * For floating-point comparisons, prefer {@linkcode PluginVec3Api.equalsApprox}.
-   *
-   * @param a - First vector
-   * @param b - Second vector
-   * @returns `true` if all components match exactly
-   */
-  equals(a, b) {
-    return a.x === b.x && a.y === b.y && a.z === b.z;
-  }
-  /**
-   * Check if two vectors are approximately equal within a tolerance.
-   *
-   * @param a - First vector
-   * @param b - Second vector
-   * @param epsilon - Maximum allowed difference per component (default `1e-6`)
-   * @returns `true` if `|a[i] - b[i]| < epsilon` for all components
-   */
-  equalsApprox(a, b, epsilon = 1e-6) {
-    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon;
-  }
-};
-var PVec3 = z.object({
+};
+
+// 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 UnderlayHandle = z.string().min(1).transform((s) => s);
+var TerrainHandle = z.string().min(1).transform((s) => s);
+var ImportJobHandle = z.string().min(1).transform((s) => s);
+var Vec3Handle = handleSchema("vec3");
+var QuatHandle = handleSchema("quat");
+var LineHandle = handleSchema("line");
+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()
+  z: z.number(),
+  w: z.number()
 });
+var BBoxComponents = z.object({ min: Vec3Components, max: Vec3Components });
 
-// src/api/core/math/quat.ts
-import * as z2 from "zod";
-var PluginQuatApi = class {
+// src/api/core/geom/create/index.ts
+var PluginGeomCreateApi = class {
   constructor() {
   }
-  /**
-   * Create a new quaternion from raw components.
-   *
-   * For most use cases prefer {@linkcode PluginQuatApi.fromAxisAngle}
-   * or {@linkcode PluginQuatApi.fromEuler} instead.
-   *
-   * @param x - The X component
-   * @param y - The Y component
-   * @param z - The Z component
-   * @param w - The W (scalar) component
-   * @returns A new {@linkcode PQuat}
-   */
-  new(x, y, z17, w) {
-    return { x, y, z: z17, w };
-  }
-  /**
-   * Create an identity quaternion representing no rotation.
-   *
-   * @returns `{ x: 0, y: 0, z: 0, w: 1 }`
-   */
-  identity() {
-    return { x: 0, y: 0, z: 0, w: 1 };
-  }
-  /**
-   * Create a quaternion from an axis and an angle.
-   *
-   * @param axis - The rotation axis as a {@linkcode PVec3} (will be normalized internally)
-   * @param angle - The rotation angle in **radians**
-   * @returns A new unit {@linkcode PQuat}, or identity if {@linkcode axis} has zero length
-   *
-   * # Example
-   * ```ts
-   * const { vec3, quat } = snaptrude.core.math
-   * // 90° rotation around the Y axis
-   * const rot = quat.fromAxisAngle(vec3.new(0, 1, 0), Math.PI / 2)
-   * ```
-   */
-  fromAxisAngle(axis, angle) {
-    const halfAngle = angle / 2;
-    const s = Math.sin(halfAngle);
-    const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
-    if (len === 0) return { x: 0, y: 0, z: 0, w: 1 };
-    return {
-      x: axis.x / len * s,
-      y: axis.y / len * s,
-      z: axis.z / len * s,
-      w: Math.cos(halfAngle)
-    };
-  }
-  /**
-   * Create a quaternion from Euler angles in **XYZ** rotation order.
-   *
-   * @param x - Rotation around X axis in **radians**
-   * @param y - Rotation around Y axis in **radians**
-   * @param z - Rotation around Z axis in **radians**
-   * @returns A new {@linkcode PQuat}
-   */
-  fromEuler(x, y, z17) {
-    const cx = Math.cos(x / 2);
-    const sx = Math.sin(x / 2);
-    const cy = Math.cos(y / 2);
-    const sy = Math.sin(y / 2);
-    const cz = Math.cos(z17 / 2);
-    const sz = Math.sin(z17 / 2);
-    return {
-      x: sx * cy * cz + cx * sy * sz,
-      y: cx * sy * cz - sx * cy * sz,
-      z: cx * cy * sz + sx * sy * cz,
-      w: cx * cy * cz - sx * sy * sz
-    };
-  }
-  /**
-   * Multiply two quaternions, combining their rotations.
-   *
-   * Quaternion multiplication is **not commutative**: `a * b ≠ b * a`.
-   * The result applies rotation {@linkcode b} first, then {@linkcode a}.
-   *
-   * @param a - First quaternion (applied second)
-   * @param b - Second quaternion (applied first)
-   * @returns A new {@linkcode PQuat} representing the combined rotation
-   */
-  multiply(a, b) {
-    return {
-      x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
-      y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
-      z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
-      w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
-    };
-  }
-  /**
-   * Compute the conjugate of a quaternion.
-   *
-   * For unit quaternions the conjugate equals the inverse.
-   *
-   * @param q - The quaternion
-   * @returns A new {@linkcode PQuat} with negated vector part `(-x, -y, -z, w)`
-   */
-  conjugate(q) {
-    return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
-  }
-  /**
-   * Compute the length (magnitude) of a quaternion.
-   *
-   * @param q - The quaternion
-   * @returns The magnitude `√(x² + y² + z² + w²)`
-   */
-  length(q) {
-    return Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
-  }
-  /**
-   * Normalize a quaternion to unit length.
-   *
-   * @param q - The quaternion to normalize
-   * @returns A new unit-length {@linkcode PQuat}, or identity if the input has zero length
-   */
-  normalize(q) {
-    const len = this.length(q);
-    if (len === 0) return { x: 0, y: 0, z: 0, w: 1 };
-    return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
-  }
-  /**
-   * Compute the inverse of a quaternion.
-   *
-   * The inverse satisfies `q * inverse(q) = identity`.
-   *
-   * @param q - The quaternion to invert
-   * @returns A new {@linkcode PQuat} that is the multiplicative inverse,
-   *   or identity if the input has zero length
-   */
-  inverse(q) {
-    const lenSq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
-    if (lenSq === 0) return { x: 0, y: 0, z: 0, w: 1 };
-    return { x: -q.x / lenSq, y: -q.y / lenSq, z: -q.z / lenSq, w: q.w / lenSq };
-  }
-  /**
-   * Rotate a 3D vector by a quaternion.
-   *
-   * Computes `q * v * conjugate(q)` using the Hamilton product.
-   *
-   * @param q - The rotation quaternion (should be unit-length)
-   * @param v - The vector to rotate as a {@linkcode PVec3}
-   * @returns A new rotated {@linkcode PVec3}
-   *
-   * # Example
-   * ```ts
-   * const { vec3, quat } = snaptrude.core.math
-   * const rot = quat.fromAxisAngle(vec3.new(0, 1, 0), Math.PI / 2)
-   * const rotated = quat.rotateVec3(rot, vec3.new(1, 0, 0))
-   * // ≈ { x: 0, y: 0, z: -1 }
-   * ```
-   */
-  rotateVec3(q, v) {
-    const vq = { x: v.x, y: v.y, z: v.z, w: 0 };
-    const conj = this.conjugate(q);
-    const result = this.multiply(this.multiply(q, vq), conj);
-    return { x: result.x, y: result.y, z: result.z };
-  }
-  /**
-   * Convert a quaternion to axis-angle representation.
-   *
-   * @param q - The quaternion to convert
-   * @returns An object with:
-   *   - `axis` — The rotation axis as a unit {@linkcode PVec3}
-   *     (defaults to `(1, 0, 0)` when angle is zero)
-   *   - `angle` — The rotation angle in **radians**
-   */
-  toAxisAngle(q) {
-    const nq = this.normalize(q);
-    const angle = 2 * Math.acos(Math.min(1, Math.max(-1, nq.w)));
-    const s = Math.sin(angle / 2);
-    if (s < 1e-6) {
-      return { axis: { x: 1, y: 0, z: 0 }, angle: 0 };
-    }
-    return {
-      axis: { x: nq.x / s, y: nq.y / s, z: nq.z / s },
-      angle
-    };
-  }
-  /**
-   * Spherical linear interpolation between two quaternions.
-   *
-   * Produces smooth constant-speed rotation between {@linkcode a} and {@linkcode b}.
-   *
-   * @param a - Start quaternion (returned when `t = 0`)
-   * @param b - End quaternion (returned when `t = 1`)
-   * @param t - Interpolation factor, typically in `[0, 1]`
-   * @returns A new interpolated {@linkcode PQuat}
-   */
-  slerp(a, b, t) {
-    let cosHalf = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
-    let bx = b.x, by = b.y, bz = b.z, bw = b.w;
-    if (cosHalf < 0) {
-      cosHalf = -cosHalf;
-      bx = -bx;
-      by = -by;
-      bz = -bz;
-      bw = -bw;
-    }
-    if (cosHalf >= 1) {
-      return { x: a.x, y: a.y, z: a.z, w: a.w };
-    }
-    const halfAngle = Math.acos(cosHalf);
-    const sinHalf = Math.sin(halfAngle);
-    const ratioA = Math.sin((1 - t) * halfAngle) / sinHalf;
-    const ratioB = Math.sin(t * halfAngle) / sinHalf;
-    return {
-      x: a.x * ratioA + bx * ratioB,
-      y: a.y * ratioA + by * ratioB,
-      z: a.z * ratioA + bz * ratioB,
-      w: a.w * ratioA + bw * ratioB
-    };
-  }
-  /**
-   * Compute the dot product of two quaternions.
-   *
-   * A value close to `1` or `-1` indicates similar orientations;
-   * a value close to `0` indicates maximally different orientations.
-   *
-   * @param a - First quaternion
-   * @param b - Second quaternion
-   * @returns The scalar dot product
-   */
-  dot(a, b) {
-    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
-  }
-  /**
-   * Check if two quaternions are exactly equal (strict equality per component).
-   *
-   * For floating-point comparisons, prefer {@linkcode PluginQuatApi.equalsApprox}.
-   *
-   * @param a - First quaternion
-   * @param b - Second quaternion
-   * @returns `true` if all components match exactly
-   */
-  equals(a, b) {
-    return a.x === b.x && a.y === b.y && a.z === b.z && a.w === b.w;
-  }
-  /**
-   * Check if two quaternions are approximately equal within a tolerance.
-   *
-   * @param a - First quaternion
-   * @param b - Second quaternion
-   * @param epsilon - Maximum allowed difference per component (default `1e-6`)
-   * @returns `true` if `|a[i] - b[i]| < epsilon` for all components
-   */
-  equalsApprox(a, b, epsilon = 1e-6) {
-    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon && Math.abs(a.w - b.w) < epsilon;
-  }
-};
-var PQuat = z2.object({
-  x: z2.number(),
-  y: z2.number(),
-  z: z2.number(),
-  w: z2.number()
+};
+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/io/import/index.ts
+import * as z25 from "zod";
+var ImportSource = z25.string().min(1).refine((s) => s.startsWith("https://") || s.startsWith("data:"), {
+  message: "source must be an https:// URL or a data: URL"
+});
+var PluginCoreIoImportApi = class {
+  constructor() {
+  }
+};
+var ModelFormat = z25.enum(["skp", "fbx", "obj", "3ds", "zip"]);
+var CadJsonInput = z25.object({
+  unit: z25.string().optional(),
+  geometry: z25.array(z25.record(z25.string(), z25.unknown())).optional()
+}).passthrough();
+var PluginImportImageArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  scale: z25.number().positive().optional(),
+  opacity: z25.number().min(0).max(1).optional(),
+  label: z25.string().optional()
+});
+var PluginImportPdfArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  page: z25.number().int().positive().optional(),
+  scale: z25.string().optional(),
+  opacity: z25.number().min(0).max(1).optional()
+});
+var PluginImportDwgArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional()
+});
+var PluginImportCadJsonArgs = z25.object({
+  cad: CadJsonInput,
+  storey: z25.number().int().optional()
+});
+var PluginImportModelArgs = z25.object({
+  source: ImportSource,
+  storey: z25.number().int().optional(),
+  format: ModelFormat.optional(),
+  position: Vec3Handle.optional(),
+  label: z25.string().optional()
+});
+var PluginImportTerrainArgs = z25.object({
+  lat: z25.number().min(-90).max(90),
+  lng: z25.number().min(-180).max(180),
+  width: z25.number().positive().finite(),
+  length: z25.number().positive().finite(),
+  elevation: z25.boolean().optional(),
+  satellite: z25.boolean().optional(),
+  neighborhood: z25.boolean().optional(),
+  parcels: z25.boolean().optional()
+});
+
+// src/api/core/io/job/index.ts
+import * as z26 from "zod";
+var PluginCoreIoJobApi = class {
+  constructor() {
+  }
+};
+var ImportJobStatus = z26.enum(["pending", "processing", "complete", "failed"]);
+var PluginImportJobArgs = z26.object({
+  job: ImportJobHandle
+});
+
+// src/api/core/io/underlay/index.ts
+import * as z27 from "zod";
+var PluginCoreIoUnderlayApi = class {
+  constructor() {
+  }
+};
+var PluginUnderlayListArgs = z27.object({
+  storey: z27.number().int().optional()
+});
+var PluginUnderlayPlanSize = z27.object({
+  planSize: z27.number().positive()
+});
+var PluginUnderlaySetScaleValue = z27.union([
+  z27.number().positive(),
+  PluginUnderlayPlanSize
+]);
+var PluginUnderlaySetScaleArgs = z27.object({
+  underlay: UnderlayHandle,
+  scale: PluginUnderlaySetScaleValue
+});
+var PluginUnderlaySetOpacityArgs = z27.object({
+  underlay: UnderlayHandle,
+  opacity: z27.number().min(0).max(1)
+});
+var PluginUnderlayRefArgs = z27.object({
+  underlay: UnderlayHandle
+});
+
+// src/api/core/io/terrain/index.ts
+import * as z28 from "zod";
+var PluginCoreIoTerrainApi = class {
+  constructor() {
+  }
+};
+var TerrainReport = z28.object({
+  cutVolume: z28.number(),
+  fillVolume: z28.number(),
+  netVolume: z28.number()
+});
+var PluginTerrainSetDatumArgs = z28.object({ offset: z28.number().finite() });
+var PluginTerrainSetOpacityArgs = z28.object({ opacity: z28.number().min(0).max(1) });
+
+// src/api/core/io/query/index.ts
+import * as z29 from "zod";
+var PluginCoreIoQueryApi = class {
+  constructor() {
+  }
+};
+var PluginQueryPdfPageCountArgs = z29.object({ source: z29.string().min(1) });
+var PluginQueryCadLayersArgs = z29.object({ cad: CadJsonInput });
+
+// src/api/core/io/index.ts
+var PluginCoreIoApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/index.ts
+var PluginCoreApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/create/index.ts
+import * as z31 from "zod";
+
+// src/api/entity/space.ts
+import * as z30 from "zod";
+var PluginSpaceCreateRectangularArgs = z30.object({
+  position: Vec3Handle,
+  dimensions: z30.object({
+    width: z30.number(),
+    height: z30.number(),
+    depth: z30.number()
+  })
+});
+var PluginSpaceCreateRectangularResult = z30.object({
+  spaceId: z30.string()
+});
+var PluginSpaceCreateFromProfileArgs = z30.object({
+  profile: ProfileHandle,
+  innerProfiles: z30.array(ProfileHandle).optional(),
+  extrudeHeight: z30.number(),
+  position: Vec3Handle
+});
+var PluginSpaceCreateFromProfileResult = z30.object({
+  spaceId: z30.string()
+});
+var PluginSpaceUpdateGeometryFromProfileArgs = z30.object({
+  spaceId: z30.string(),
+  profile: ProfileHandle,
+  extrudeHeight: z30.number()
+});
+var PluginSpaceUpdateGeometryFromProfileResult = z30.object({
+  spaceId: z30.string()
+});
+var PluginSpaceGetProperty = z30.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 = z30.object({
+  spaceId: z30.string(),
+  properties: z30.array(PluginSpaceGetProperty)
+});
+var PluginSpaceType = z30.enum([
+  "Room",
+  "Program Block",
+  "Balcony",
+  "Road",
+  "Garden",
+  "Deck",
+  "Pool",
+  "Walkway",
+  "Envelope",
+  "Parking"
+]);
+var PluginAreaClass = z30.enum(["NET", "GROSS", "EXCLUDED"]);
+var PluginSpaceGetResult = z30.object({
+  // Basic
+  id: z30.string(),
+  type: z30.string(),
+  room_type: z30.string(),
+  name: z30.string(),
+  // Derived from parametric data
+  area: z30.number(),
+  breadth: z30.number(),
+  depth: z30.number(),
+  height: z30.number(),
+  massType: z30.string().nullable(),
+  spaceType: PluginSpaceType.nullable(),
+  areaClass: PluginAreaClass,
+  storey: z30.number().nullable(),
+  departmentId: z30.string().nullable(),
+  departmentName: z30.string(),
+  departmentColor: z30.string(),
+  // Derived from mesh
+  position: Vec3Components,
+  absolutePosition: Vec3Components,
+  rotation: Vec3Components,
+  rotationQuaternion: QuatComponents.nullable(),
+  // Derived from brep
+  planPoints: z30.array(Vec3Components),
+  profile: z30.array(CurveHandle),
+  innerProfiles: z30.array(z30.array(CurveHandle)),
+  innerPlanPoints: z30.array(z30.array(Vec3Components)),
+  // Derived from adjacency manager.
+  // value: 2 = Direct (required), 1 = Indirect or physical contact, -1 = Restricted;
+  // 0 (no relationship) entries are filtered out. Empty array when adjacency has
+  // never been computed — run program.adjacency.compute() first for fresh data.
+  adjacency: z30.array(z30.object({
+    spaceId: z30.string(),
+    value: z30.number()
+  }))
+}).partial();
+var PluginSpaceGetAllResult = z30.object({
+  spacesIds: z30.array(z30.string())
+});
+var PluginSpaceDeleteArgs = z30.object({
+  spaceId: z30.string()
+});
+var PluginMassType = z30.enum([
+  "Plinth",
+  "Void",
+  "Pergola",
+  "Furniture",
+  "Facade element",
+  "Generic mass",
+  "Room",
+  "Department",
+  "Building",
+  "Revit Import",
+  "Mass",
+  "Site"
+]);
+var PluginWellKnownDepartmentId = z30.enum([
+  "DEFAULT",
+  "SITE",
+  "ENVELOPE",
+  "CORE"
+]);
+var PluginDepartmentId = z30.union([
+  PluginWellKnownDepartmentId,
+  z30.uuid()
+]);
+var PluginSpaceUpdateArgs = z30.object({
+  spaceId: z30.string(),
+  properties: z30.object({
+    room_type: z30.string().optional(),
+    massType: PluginMassType.optional(),
+    spaceType: PluginSpaceType.optional(),
+    areaClass: PluginAreaClass.optional(),
+    departmentId: PluginDepartmentId.optional()
+  })
+});
+var PluginSpaceUpdateResult = z30.object({
+  spaceId: z30.string(),
+  room_type: z30.string().optional(),
+  massType: z30.string().optional(),
+  spaceType: z30.string().optional(),
+  areaClass: PluginAreaClass.optional(),
+  departmentId: z30.string().nullable().optional()
+});
+var PluginSpaceBulkCreateItem = z30.discriminatedUnion("kind", [
+  z30.object({
+    kind: z30.literal("rectangular"),
+    position: Vec3Handle,
+    dimensions: z30.object({
+      width: z30.number(),
+      height: z30.number(),
+      depth: z30.number()
+    }),
+    room_type: z30.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional()
+  }),
+  z30.object({
+    kind: z30.literal("profile"),
+    profile: ProfileHandle,
+    innerProfiles: z30.array(ProfileHandle).optional(),
+    extrudeHeight: z30.number(),
+    position: Vec3Handle,
+    room_type: z30.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional()
+  })
+]);
+var PluginSpaceBulkCreateArgs = z30.object({
+  items: z30.array(PluginSpaceBulkCreateItem)
+});
+var PluginSpaceBulkCreateResult = z30.object({
+  spaceIds: z30.array(z30.string())
+});
+var PluginSpaceBulkUpdateItem = z30.object({
+  spaceId: z30.string(),
+  profile: ProfileHandle.optional(),
+  extrudeHeight: z30.number().optional(),
+  properties: z30.object({
+    room_type: z30.string().optional(),
+    massType: PluginMassType.optional(),
+    spaceType: PluginSpaceType.optional(),
+    areaClass: PluginAreaClass.optional(),
+    departmentId: PluginDepartmentId.optional()
+  }).optional()
+});
+var PluginSpaceBulkUpdateArgs = z30.object({
+  items: z30.array(PluginSpaceBulkUpdateItem)
+});
+var PluginSpaceBulkUpdateResult = z30.object({
+  spaces: z30.array(PluginSpaceUpdateResult)
+});
+var PluginSpaceBulkDeleteArgs = z30.object({
+  spaceIds: z30.array(z30.string())
+});
+var PluginSpaceBulkDeleteResult = z30.object({
+  deletedSpaceIds: z30.array(z30.string())
+});
+
+// src/api/design/create/index.ts
+var PluginDesignCreateApi = class {
+  constructor() {
+  }
+};
+var PluginReferenceLineStyle = z31.enum(["SOLID", "DASHED", "DOT_DASH"]);
+var PluginSlabType = z31.enum([
+  "Intermediate Slab",
+  "Basement Slab",
+  "Plinth",
+  "Roof"
+]);
+var PluginStaircasePreset = z31.enum([
+  "straight",
+  "straightWoLanding",
+  "straightFlightWoMidLanding",
+  "dogLegged",
+  "openWell",
+  "lShaped",
+  "3StepLShaped",
+  "square",
+  "singleStep",
+  "plinthLevel",
+  "amphitheatre",
+  "connectingStepsToAmphitheatre",
+  "mezzanineFloorStraight",
+  "mezzanineFloorDogLegged",
+  "mezzanineFloorLShaped",
+  "custom"
+]);
+var PluginDesignCreateSpaceArgs = z31.object({
+  contour: ContourHandle,
+  height: z31.number(),
+  label: z31.string().optional(),
+  position: Vec3Handle.optional(),
+  spaceType: PluginSpaceType.optional(),
+  massType: PluginMassType.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+var PluginDesignCreateMassArgs = z31.object({
+  contour: ContourHandle,
+  height: z31.number(),
+  label: z31.string().optional(),
+  position: Vec3Handle.optional(),
+  massType: PluginMassType.optional()
+});
+var PluginDesignCreateSlabArgs = z31.object({
+  contour: ContourHandle,
+  thickness: z31.number(),
+  direction: z31.enum(["up", "down"]).optional(),
+  slabType: PluginSlabType.optional()
+});
+var PluginDesignCreateFloorArgs = z31.object({
+  contour: ContourHandle,
+  thickness: z31.number(),
+  position: Vec3Handle.optional()
+});
+var PluginDesignCreateRoofArgs = z31.object({
+  contour: ContourHandle,
+  thickness: z31.number()
+});
+var PluginDesignCreateCeilingArgs = z31.object({
+  contour: ContourHandle,
+  thickness: z31.number(),
+  heightFromFloor: z31.number().optional()
+});
+var PluginDesignCreateColumnArgs = z31.object({
+  position: Vec3Handle,
+  crossSection: ContourHandle,
+  height: z31.number(),
+  directionUp: Vec3Handle.optional()
+});
+var PluginDesignCreateBeamArgs = z31.object({
+  section: ContourHandle,
+  length: z31.number(),
+  direction: Vec3Handle.optional()
+});
+var PluginDesignCreateWallsArgs = z31.object({
+  profile: ProfileHandle,
+  height: z31.number().optional(),
+  thickness: z31.number().optional()
+});
+var PluginDesignCreateStaircaseArgs = z31.object({
+  preset: PluginStaircasePreset,
+  position: Vec3Handle,
+  label: z31.string().optional(),
+  structureId: z31.string().optional(),
+  level: z31.string().optional()
+});
+var PluginDesignCreateFurnitureArgs = z31.object({
+  catalogId: z31.string().min(1),
+  position: Vec3Handle,
+  label: z31.string().optional(),
+  createNewSourceMesh: z31.boolean().optional()
+});
+var PluginDesignCreateReferenceLinesArgs = z31.object({
+  profile: ProfileHandle,
+  color: z31.string().optional(),
+  thickness: z31.number().optional(),
+  style: PluginReferenceLineStyle.optional(),
+  gridTag: z31.string().optional()
+});
+var PluginCopyMode = z31.enum(["instance", "unique"]);
+var PluginDesignCreateCopyArgs = z31.object({
+  components: z31.array(ComponentHandle).min(1),
+  displacement: Vec3Handle,
+  count: z31.number().int().positive().optional(),
+  mode: PluginCopyMode.optional()
+});
+var PluginCreateSpaceItem = z31.object({
+  contour: ContourHandle,
+  height: z31.number(),
+  label: z31.string().optional(),
+  position: Vec3Handle.optional(),
+  spaceType: PluginSpaceType.optional(),
+  massType: PluginMassType.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+
+// src/api/design/query/index.ts
+import * as z34 from "zod";
+
+// src/api/design/query/geometry/index.ts
+import * as z32 from "zod";
+var PluginDesignQueryGeometryApi = class {
+  constructor() {
+  }
+};
+var PluginDesignQueryGeometryGetBrepArgs = z32.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryGeometryGetBottomContourArgs = z32.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryGeometryGetCenterlineArgs = z32.object({
+  component: ComponentHandle
+});
+
+// src/api/design/query/spaces.ts
+import * as z33 from "zod";
+var PluginDesignQuerySpacesApi = class {
+  constructor() {
+  }
+};
+var PluginDesignQueryGetFootprintArgs = z33.object({
+  space: ComponentHandle
+});
+var PluginDesignQuerySpacesGetProperty = PluginSpaceGetProperty.exclude(["adjacency"]);
+var PluginDesignQuerySpacesGetArgs = z33.object({
+  space: ComponentHandle,
+  properties: z33.array(PluginDesignQuerySpacesGetProperty)
+});
+var PluginDesignQuerySpacesGetResult = PluginSpaceGetResult.omit({
+  adjacency: true
+});
+
+// src/api/design/query/index.ts
+var PluginEntityType = z34.enum([
+  "wall",
+  "space",
+  "mass",
+  "door",
+  "window",
+  "floor",
+  "slab",
+  "roof",
+  "column",
+  "beam",
+  "ceiling",
+  "staircase",
+  "furniture",
+  "referenceLine",
+  "curtainWall",
+  "mullion",
+  "panel"
+]);
+var PluginEntityFilter = z34.object({
+  types: z34.array(PluginEntityType).optional(),
+  storeys: z34.array(z34.number()).optional(),
+  buildingIds: z34.array(z34.string()).optional(),
+  structureIds: z34.array(z34.string()).optional(),
+  label: z34.string().optional(),
+  massTypes: z34.array(PluginMassType).optional(),
+  spaceTypes: z34.array(PluginSpaceType).optional(),
+  departmentId: PluginDepartmentId.optional(),
+  isSelected: z34.boolean().optional(),
+  isLocked: z34.boolean().optional(),
+  isHidden: z34.boolean().optional(),
+  within: BBoxComponents.optional(),
+  overlaps: ComponentHandle.optional(),
+  ids: z34.array(ComponentHandle).optional()
+});
+var PluginDesignQueryListByTypeArgs = PluginEntityFilter.extend({
+  type: PluginEntityType
+});
+var PluginDesignQueryComponentArgs = z34.object({
+  component: ComponentHandle
+});
+var PluginDesignQueryIdArgs = z34.object({
+  id: ComponentHandle
+});
+var PluginDesignQueryComponentsArgs = z34.object({
+  components: z34.array(ComponentHandle)
+});
+var PluginEntityProperties = z34.object({
+  id: z34.string(),
+  type: PluginEntityType,
+  label: z34.string(),
+  storey: z34.number(),
+  buildingId: z34.string(),
+  structureId: z34.string(),
+  massType: z34.string(),
+  spaceType: PluginSpaceType,
+  areaClass: PluginAreaClass,
+  departmentId: z34.string(),
+  isLocked: z34.boolean(),
+  isHidden: z34.boolean(),
+  isSelected: z34.boolean(),
+  boundingBox: BBoxComponents,
+  adjacency: z34.array(z34.object({ spaceId: z34.string(), value: z34.number() }))
+}).partial();
+var PluginEntityMeasurements = z34.object({
+  area: z34.number().optional(),
+  volume: z34.number().optional(),
+  length: z34.number().optional(),
+  boundingBox: BBoxComponents
+});
+var PluginDesignQueryApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/selection/index.ts
+import * as z35 from "zod";
+var PluginSelectionEntityType = z35.enum([
+  "wall",
+  "slab",
+  "floor",
+  "door",
+  "window",
+  "beam",
+  "column",
+  "ceiling",
+  "roof",
+  "staircase",
+  "furniture",
+  "pergola",
+  "sunshade",
+  "referenceLine",
+  "space",
+  "site",
+  "terrain",
+  "cad",
+  "pdf",
+  "image",
+  "dimensionLine",
+  "model3d",
+  "neighborhoodBuilding",
+  "programBlock"
+]);
+var PluginSelectionFilter = z35.object({
+  storeys: z35.array(z35.number()).optional(),
+  types: z35.array(PluginSelectionEntityType).optional()
+}).refine((f) => (f.storeys?.length ?? 0) + (f.types?.length ?? 0) > 0, {
+  message: "PluginSelectionFilter requires at least one non-empty field (storeys or types); use design.selection.clear() to deselect everything"
+});
+var PluginDesignSelectionApi = class {
+  constructor() {
+  }
+};
+var PluginDesignSelectionSetArgs = z35.object({
+  components: z35.array(ComponentHandle)
+});
+var PluginDesignSelectionAddArgs = PluginDesignSelectionSetArgs;
+var PluginDesignSelectionRemoveArgs = PluginDesignSelectionSetArgs;
+
+// src/api/design/doors/index.ts
+import * as z36 from "zod";
+var PluginDesignDoorsApi = class {
+  constructor() {
+  }
+};
+var PluginDesignDoorArgs = z36.object({
+  door: ComponentHandle
+});
+var PluginMirrorAxis = z36.enum(["x", "y", "z"]);
+var PluginDesignDoorMirrorArgs = z36.object({
+  door: ComponentHandle,
+  axis: PluginMirrorAxis.optional()
+});
+var PluginDesignDoorSetWidthArgs = z36.object({
+  doors: z36.array(ComponentHandle),
+  width: z36.number()
+});
+var PluginDesignDoorSetHeightArgs = z36.object({
+  doors: z36.array(ComponentHandle),
+  height: z36.number()
+});
+
+// src/api/design/windows/index.ts
+import * as z37 from "zod";
+var PluginDesignWindowsApi = class {
+  constructor() {
+  }
+};
+var PluginDesignWindowArgs = z37.object({
+  window: ComponentHandle
+});
+var PluginWindowDimensions = z37.object({
+  width: z37.number(),
+  height: z37.number(),
+  thickness: z37.number()
+});
+var PluginDesignWindowSetWidthArgs = z37.object({
+  window: ComponentHandle,
+  width: z37.number()
+});
+var PluginDesignWindowSetHeightArgs = z37.object({
+  window: ComponentHandle,
+  height: z37.number()
+});
+
+// src/api/design/furniture/index.ts
+import * as z38 from "zod";
+var PluginDesignFurnitureApi = class {
+  constructor() {
+  }
+};
+var PluginFurnitureCatalogItem = z38.object({
+  id: z38.string(),
+  name: z38.string(),
+  source: z38.enum(["team", "general"]),
+  subType: z38.string().optional(),
+  cost: z38.number().optional(),
+  familyName: z38.string().optional()
+});
+var PluginDesignFurnitureListCatalogArgs = z38.object({
+  source: z38.enum(["team", "general"]).optional()
+});
+var PluginDesignFurnitureGetCatalogItemArgs = z38.object({
+  id: z38.string()
+});
+var PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs;
+
+// src/api/design/materials/index.ts
+import * as z39 from "zod";
+var PluginDesignMaterialsApi = class {
+  constructor() {
+  }
+};
+var PluginMaterialInfo = z39.object({
+  name: z39.string(),
+  id: z39.string(),
+  colorHex: z39.string(),
+  alpha: z39.number(),
+  materialType: z39.string().optional(),
+  textureUrl: z39.string().optional()
+});
+var PluginMaterialSpec = z39.object({
+  name: z39.string().optional(),
+  color: z39.string().optional(),
+  textureUrl: z39.string().optional(),
+  alpha: z39.number().optional(),
+  materialType: z39.string().optional()
+});
+var PluginMaterialResult = z39.object({ count: z39.number() });
+var PluginDesignMaterialsListArgs = z39.object({
+  scope: z39.enum(["project", "preset"]).optional()
+});
+var PluginDesignMaterialsGetInfoArgs = z39.object({ material: MaterialHandle });
+var PluginDesignMaterialsComponentArgs = z39.object({ component: ComponentHandle });
+var PluginDesignMaterialsApplyArgs = z39.object({
+  targets: z39.array(ComponentHandle),
+  material: z39.union([MaterialHandle, PluginMaterialSpec]),
+  save: z39.boolean().optional()
+});
+var PluginDesignMaterialsResetArgs = z39.object({
+  components: z39.array(ComponentHandle),
+  save: z39.boolean().optional()
+});
+var PluginDesignMaterialsCreateArgs = z39.object({ spec: PluginMaterialSpec });
+
+// src/api/design/lock.ts
+import * as z40 from "zod";
+var PluginDesignChangeResult = z40.object({
+  affected: z40.array(ComponentHandle)
+});
+var PluginDesignLockArgs = z40.object({
+  components: z40.array(ComponentHandle)
+});
+var PluginDesignUnlockArgs = PluginDesignLockArgs;
+var PluginDesignIsLockedArgs = z40.object({
+  component: ComponentHandle,
+  includeInherited: z40.boolean().optional()
+});
+
+// src/api/design/erase/index.ts
+import * as z41 from "zod";
+var EraseStrategy = z41.enum(["DirectDelete", "DirectUnion", "SplitAndUnion"]);
+var DEFAULT_ERASE_STRATEGIES = ["DirectDelete", "DirectUnion"];
+var ErasableEdgeRef = z41.object({
+  /** Opaque bottom-graph edge id (engine form `"e-<n>"`). Do not mutate. Pass verbatim to {@linkcode PluginDesignEraseApi.edge}. */
+  id: z41.string().min(1),
+  /** What erasing this edge would do: `DirectDelete` drops a mass; `DirectUnion` merges two adjacent masses. */
+  strategy: EraseStrategy,
+  /** Bottom-graph edge weight: `1` = external boundary edge, `>=2` = internal edge shared between components. */
+  edgeWeight: z41.number(),
+  /** The components this edge is incident to — one for external (DirectDelete); two or more for internal (DirectUnion; 3+ at T-junctions where several masses share the edge). */
+  components: z41.array(ComponentHandle),
+  /** A representative point on the edge (its head endpoint). Diagnostic only. */
+  snapPoint: Vec3Handle
+});
+var PluginDesignListErasableEdgesArgs = z41.object({
+  components: z41.array(ComponentHandle).optional(),
+  strategies: z41.array(EraseStrategy).optional()
+});
+var PluginDesignEraseEdgeArgs = z41.object({
+  edge: ErasableEdgeRef
+});
+var PluginDesignEraseEdgeResult = z41.object({ ok: z41.literal(true) });
+var PluginDesignEraseApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/delete/index.ts
+import * as z42 from "zod";
+var PluginDesignDeleteEntitiesArgs = z42.object({
+  components: z42.array(ComponentHandle).min(1)
+});
+var PluginDesignDeleteApi = class {
+  constructor() {
+  }
+};
+
+// src/api/design/shared.ts
+import * as z43 from "zod";
+var BooleanOutcome = z43.object({
+  created: z43.array(ComponentHandle),
+  deleted: z43.array(ComponentHandle)
+});
+var OffsetSplitOutcome = z43.object({
+  createdIds: z43.array(ComponentHandle),
+  deletedIds: z43.array(ComponentHandle),
+  offsetValue: z43.number()
+});
+
+// src/api/design/boolean/index.ts
+import * as z44 from "zod";
+var PluginDesignBooleanApi = class {
+  constructor() {
+  }
+};
+var BooleanOptions = z44.object({
+  offset: Vec3Handle.optional()
+});
+var PluginDesignBooleanUnionArgs = z44.object({
+  components: z44.array(ComponentHandle).min(2),
+  options: BooleanOptions.optional()
+});
+var PluginDesignBooleanSubtractArgs = z44.object({
+  target: ComponentHandle,
+  tools: z44.array(ComponentHandle).min(1),
+  options: BooleanOptions.optional()
+});
+var PluginDesignBooleanIntersectArgs = z44.object({
+  components: z44.array(ComponentHandle).length(2),
+  options: BooleanOptions.optional()
+});
+
+// src/api/design/transform/index.ts
+import * as z45 from "zod";
+var PluginDesignTransformApi = class {
+  constructor() {
+  }
+};
+var PluginDesignMoveArgs = z45.object({
+  components: z45.array(ComponentHandle).min(1),
+  displacement: Vec3Handle,
+  is2D: z45.boolean().optional(),
+  trackParentChange: z45.boolean().optional()
+});
+var PluginDesignRotateArgs = z45.object({
+  components: z45.array(ComponentHandle).min(1),
+  angleInDegrees: z45.number(),
+  axis: Vec3Handle.optional(),
+  is2D: z45.boolean().optional()
+});
+
+// src/api/design/edit/index.ts
+import * as z46 from "zod";
+var PluginDesignEditApi = class {
+  constructor() {
+  }
+};
+var PluginDesignOffsetSplitArgs = z46.object({
+  component: ComponentHandle,
+  offsetDistance: z46.number(),
+  profilePickPoint: Vec3Handle.optional()
+});
+
+// src/api/design/update/index.ts
+import * as z47 from "zod";
+var PluginSpacePropertyUpdates = z47.object({
+  room_type: z47.string().optional(),
+  massType: PluginMassType.optional(),
+  spaceType: PluginSpaceType.optional(),
+  areaClass: PluginAreaClass.optional(),
+  departmentId: PluginDepartmentId.optional()
+});
+var PluginSpaceGeometryUpdate = z47.object({
+  profile: ProfileHandle,
+  extrudeHeight: z47.number()
+});
+var PluginUpdateSpaceItem = z47.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 z48 from "zod";
+var PluginBuildableEnvelopeApi = class {
+  constructor() {
+  }
+};
+var PluginBuildableEnvelopePolygonVertex = z48.union([
+  z48.object({ x: z48.number().finite(), z: z48.number().finite() }).strict(),
+  z48.tuple([z48.number().finite(), z48.number().finite()])
+]);
+var PluginBuildableEnvelopeVerticalCap = z48.discriminatedUnion("kind", [
+  z48.object({
+    kind: z48.literal("max_height"),
+    maxHeight: z48.number().finite().positive()
+  }).strict(),
+  z48.object({
+    kind: z48.literal("max_floors"),
+    maxFloors: z48.number().finite().int().positive()
+  }).strict()
+]);
+var PluginBuildableEnvelopeSetbackTier = z48.object({
+  aboveHeight: z48.number().finite().nonnegative(),
+  front: z48.number().finite().nonnegative(),
+  side: z48.number().finite().nonnegative(),
+  rear: z48.number().finite().nonnegative()
+}).strict();
+function refineSetbackTiers(args, ctx) {
+  const tiers = args.setbacks;
+  if (tiers.length === 0) return;
+  if (tiers[0].aboveHeight !== 0) {
+    ctx.addIssue({
+      code: z48.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: z48.ZodIssueCode.custom,
+        path: ["setbacks", i, "aboveHeight"],
+        message: "Setback tiers must be ordered by strictly increasing aboveHeight."
+      });
+    }
+  }
+}
+var PluginBuildableEnvelopeCreateArgs = z48.object({
+  sitePolygon: z48.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z48.union([z48.literal("ft"), z48.literal("m")]),
+  setbacks: z48.array(PluginBuildableEnvelopeSetbackTier).min(1),
+  verticalCap: PluginBuildableEnvelopeVerticalCap,
+  floorToFloor: z48.number().finite().positive(),
+  farRatio: z48.number().finite().positive().optional(),
+  lotCoverageMaxPct: z48.number().finite().min(0).max(100).optional()
+}).strict().superRefine(refineSetbackTiers);
+var PluginBuildableEnvelopeCreateResult = z48.object({
+  buildableEnvelopeId: z48.string().min(1)
+}).strict();
+var PluginBuildableEnvelopeUpdateArgs = z48.object({
+  buildableEnvelopeId: z48.string().min(1),
+  sitePolygon: z48.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z48.union([z48.literal("ft"), z48.literal("m")]),
+  setbacks: z48.array(PluginBuildableEnvelopeSetbackTier).min(1),
+  verticalCap: PluginBuildableEnvelopeVerticalCap,
+  floorToFloor: z48.number().finite().positive(),
+  farRatio: z48.number().finite().positive().optional(),
+  lotCoverageMaxPct: z48.number().finite().min(0).max(100).optional()
+}).strict().superRefine(refineSetbackTiers);
+var PluginBuildableEnvelopeUpdateResult = z48.object({
+  buildableEnvelopeId: z48.string().min(1)
+}).strict();
+
+// src/api/entity/referenceLine.ts
+import * as z49 from "zod";
+var PluginReferenceLineApi = class {
+  constructor() {
+  }
+};
+var PluginReferenceLineCreateMultiArgs = z49.object({
+  profile: ProfileHandle
+});
+var PluginReferenceLineCreateMultiResult = z49.object({
+  referenceLineIds: z49.array(z49.string())
+});
+var PluginReferenceLineGetProperty = z49.enum([
+  "curve"
+]);
+var PluginReferenceLineGetArgs = z49.object({
+  referenceLineId: z49.string(),
+  properties: z49.array(PluginReferenceLineGetProperty)
+});
+var PluginReferenceLineGetResult = z49.object({
+  curve: CurveHandle
+}).partial();
+var PluginReferenceLineGetAllResult = z49.object({
+  referenceLineIds: z49.array(z49.string())
+});
+var PluginReferenceLineDeleteArgs = z49.object({
+  referenceLineId: z49.string()
+});
+
+// src/api/entity/story.ts
+import * as z50 from "zod";
+var PluginStoryApi = class {
+  constructor() {
+  }
+};
+var PluginStoryGetProperty = z50.enum([
+  "value",
+  "id",
+  "name",
+  "height",
+  "base",
+  "hidden",
+  "spacesCount",
+  "totalArea"
+]);
+var PluginStoryGetArgs = z50.object({
+  storyValue: z50.number().int(),
+  properties: z50.array(PluginStoryGetProperty)
+});
+var PluginStoryGetResult = z50.object({
+  value: z50.number(),
+  id: z50.string(),
+  name: z50.string(),
+  height: z50.number(),
+  base: z50.number(),
+  hidden: z50.boolean(),
+  spacesCount: z50.number(),
+  totalArea: z50.number()
+}).partial();
+var PluginStoryGetAllResult = z50.object({
+  stories: z50.array(
+    z50.object({
+      value: z50.number(),
+      id: z50.string(),
+      name: z50.string()
+    })
+  )
+});
+var PluginStoryCreateArgs = z50.object({
+  storyValue: z50.number().int(),
+  height: z50.number().optional()
+});
+var PluginStoryCreateResult = z50.object({
+  storyId: z50.string(),
+  storyValue: z50.number()
+});
+var PluginStoryUpdateArgs = z50.object({
+  storyValue: z50.number().int(),
+  height: z50.number()
+});
+var PluginStoryUpdateResult = z50.object({
+  storyValue: z50.number(),
+  height: z50.number()
+});
+
+// src/api/entity/index.ts
+var PluginEntityApi = class {
+  constructor() {
+  }
+};
+
+// src/api/program/departments.ts
+import * as z52 from "zod";
+
+// src/api/program/metrics.ts
+import * as z51 from "zod";
+var PluginProgramMetricsApi = class {
+  constructor() {
+  }
+};
+var PluginAreaUnit = z51.enum(["ft2", "m2"]);
+var PluginProgramDepartmentMetric = z51.object({
+  departmentId: z51.string(),
+  name: z51.string(),
+  targetArea: z51.number().nullable(),
+  allocatedArea: z51.number()
+});
+var PluginProgramMetricsSummary = z51.object({
+  units: PluginAreaUnit,
+  totalTargetArea: z51.number(),
+  totalAllocatedArea: z51.number(),
+  unassignedArea: z51.number(),
+  departments: z51.array(PluginProgramDepartmentMetric)
+}).refine(
+  (s) => {
+    const summed = s.unassignedArea + s.departments.reduce((acc, d) => acc + d.allocatedArea, 0);
+    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 = z52.object({
+  id: z52.string(),
+  name: z52.string(),
+  color: z52.string(),
+  targetArea: z52.number().nullable()
+});
+var PluginProgramDepartmentsListResult = z52.object({
+  units: PluginAreaUnit,
+  departments: z52.array(PluginProgramDepartment)
+});
+var PluginProgramDepartmentsGetArgs = z52.object({
+  departmentId: z52.string()
+});
+var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
+  {
+    units: PluginAreaUnit
+  }
+).nullable();
+var PluginProgramDepartmentRecord = PluginProgramDepartment.extend({
+  units: PluginAreaUnit
+});
+var PluginProgramDepartmentsCreateArgs = z52.object({
+  name: z52.string(),
+  color: z52.string()
+});
+var PluginProgramDepartmentsCreateResult = z52.object({
+  departmentId: z52.string()
+});
+var PluginProgramDepartmentsUpdateArgs = z52.object({
+  departmentId: z52.string(),
+  name: z52.string().optional(),
+  color: z52.string().optional()
+});
+var PluginProgramDepartmentsUpdateResult = PluginProgramDepartmentRecord;
+var PluginProgramDepartmentsAssignArgs = z52.object({
+  departmentId: z52.string(),
+  spaceIds: z52.array(ComponentHandle).min(1)
+});
+var PluginProgramDepartmentsAssignResult = z52.object({
+  departmentId: z52.string(),
+  spaceIds: z52.array(ComponentHandle)
+});
+var PluginProgramDepartmentsUnassignArgs = z52.object({
+  spaceIds: z52.array(ComponentHandle).min(1)
+});
+var PluginProgramDepartmentsUnassignResult = z52.object({
+  spaceIds: z52.array(ComponentHandle)
+});
+var PluginProgramDepartmentsSetTargetAreaArgs = z52.object({
+  departmentId: z52.string(),
+  targetArea: z52.number(),
+  units: PluginAreaUnit.optional()
+});
+var PluginProgramDepartmentsSetTargetAreaResult = PluginProgramDepartmentRecord;
+var PluginProgramDepartmentsDeleteArgs = z52.object({
+  departmentId: z52.string()
+});
+var PluginProgramDepartmentsDeleteResult = z52.object({
+  departmentId: z52.string(),
+  reassignedSpaceIds: z52.array(ComponentHandle)
 });
 
-// src/api/core/math/index.ts
-var PluginMathApi = class {
+// src/api/program/adjacency.ts
+import * as z53 from "zod";
+var PluginProgramAdjacencyApi = class {
   constructor() {
   }
 };
+var PluginAdjacencyLevel = z53.enum(["department", "space"]);
+var PluginProgramAdjacencyGetMatrixArgs = z53.object({
+  level: PluginAdjacencyLevel,
+  ids: z53.array(z53.string()).optional()
+});
+var PluginProgramAdjacencyGetMatrixResult = z53.object({
+  ids: z53.array(z53.string()),
+  departmentIds: z53.array(z53.string().nullable()).optional(),
+  matrix: z53.array(z53.array(z53.number()))
+});
+var PluginProgramAdjacencyComputeResult = z53.object({
+  success: z53.boolean(),
+  error: z53.string().optional()
+});
 
-// src/api/core/geom/line.ts
-import * as z3 from "zod";
-var PluginLineApi = class {
-  constructor() {
-  }
-  /**
-   * Create a new line segment between two points.
-   *
-   * @param startPoint - The start point as a {@linkcode PVec3}
-   * @param endPoint - The end point as a {@linkcode PVec3}
-   * @returns A new {@linkcode PLine}
-   *
-   * # Example
-   * ```ts
-   * const { vec3 } = snaptrude.core.math
-   * const { line } = snaptrude.core.geom
-   *
-   * const edge = line.new(vec3.new(0, 0, 0), vec3.new(5, 0, 0))
-   * ```
-   */
-  new(startPoint, endPoint) {
-    return { curveType: "Line", startPoint, endPoint };
-  }
-};
-var PLine = z3.object({
-  curveType: z3.literal("Line"),
-  startPoint: PVec3,
-  endPoint: PVec3
-});
-
-// src/api/core/geom/arc.ts
-import * as z4 from "zod";
-var PluginArcApi = class {
-  constructor() {
-  }
-  /**
-   * Create a new arc from start, end, centre, and axis.
-   *
-   * The arc sweeps from {@linkcode startPoint} to {@linkcode endPoint}
-   * along the circle centred at {@linkcode centrePoint}, in the
-   * direction determined by the right-hand rule around {@linkcode axis}.
-   *
-   * @param startPoint - The start point as a {@linkcode PVec3}
-   * @param endPoint - The end point as a {@linkcode PVec3}
-   * @param centrePoint - The centre of the arc's circle as a {@linkcode PVec3}
-   * @param axis - The arc's rotation axis as a {@linkcode PVec3}
-   *   (perpendicular to the arc's plane)
-   * @returns A new {@linkcode PArc}
-   *
-   * # Example
-   * ```ts
-   * const { vec3 } = snaptrude.core.math
-   * const { arc } = snaptrude.core.geom
-   *
-   * // Quarter-circle arc on the XZ plane
-   * const a = arc.new(
-   *   vec3.new(1, 0, 0),  // start
-   *   vec3.new(0, 0, 1),  // end
-   *   vec3.new(0, 0, 0),  // centre
-   *   vec3.new(0, 1, 0),  // Y-up axis
-   * )
-   * ```
-   */
-  new(startPoint, endPoint, centrePoint, axis) {
-    return { curveType: "Arc", startPoint, endPoint, centrePoint, axis };
-  }
-};
-var PArc = z4.object({
-  curveType: z4.literal("Arc"),
-  startPoint: PVec3,
-  endPoint: PVec3,
-  centrePoint: PVec3,
-  axis: PVec3
-});
-
-// src/api/core/geom/curve.ts
-import * as z5 from "zod";
-var PluginCurveApi = class {
+// src/api/program/layout.ts
+import * as z54 from "zod";
+var PluginProgramLayoutApi = class {
   constructor() {
   }
-  /**
-   * Wrap a {@linkcode PLine} or {@linkcode PArc} as a {@linkcode PCurve}.
-   *
-   * This is an identity operation — it simply returns the input unchanged.
-   * It exists for type-level clarity when building mixed curve lists.
-   *
-   * @param curve - A {@linkcode PLine} or {@linkcode PArc} to wrap
-   * @returns The same value typed as {@linkcode PCurve}
-   */
-  new(curve) {
-    return curve;
-  }
 };
-var PCurve = z5.discriminatedUnion("curveType", [PLine, PArc]);
+var PluginProgramLayoutRunResult = z54.object({
+  success: z54.boolean(),
+  error: z54.string().optional()
+});
 
-// src/api/core/geom/profile.ts
-import * as z6 from "zod";
-var PluginProfileApi = class {
+// src/api/program/spreadsheet.ts
+import * as z55 from "zod";
+var PluginProgramSpreadsheetApi = class {
+  constructor() {
+  }
+};
+var PluginProgramSpreadsheetTemplatesApi = class {
   constructor() {
   }
-  /**
-   * Create a profile from an ordered list of curves.
-   *
-   * The curves should form a closed loop — the end point of each curve
-   * should coincide with the start point of the next.
-   *
-   * @param curves - An ordered array of {@linkcode PCurve}s forming a closed loop
-   * @returns A new {@linkcode PProfile}
-   */
-  new(curves) {
-    return { curves };
+};
+var PluginProgramSpreadsheetBindingsApi = class {
+  constructor() {
   }
 };
-var PluginProfileFromLinePointsArgs = z6.object({
-  points: z6.array(PVec3)
+var PluginSpreadsheetCell = z55.union([
+  z55.string(),
+  z55.number(),
+  z55.boolean(),
+  z55.null()
+]);
+var PluginSpreadsheetAlign = z55.enum(["left", "center", "right"]);
+var PluginSpreadsheetColumn = z55.object({
+  key: z55.string(),
+  header: z55.string(),
+  width: z55.number().optional(),
+  format: z55.string().optional(),
+  align: PluginSpreadsheetAlign.optional()
+});
+var PluginSpreadsheetTotal = z55.object({
+  column: z55.string(),
+  fn: z55.enum(["sum", "avg", "count", "min", "max"]),
+  label: z55.string().optional()
+});
+var PluginProgramSpreadsheetRenderArgs = z55.object({
+  sheetName: z55.string(),
+  columns: z55.array(PluginSpreadsheetColumn),
+  rows: z55.array(z55.record(z55.string(), PluginSpreadsheetCell)),
+  title: z55.string().optional(),
+  startCell: z55.string().optional(),
+  whenExists: z55.enum(["replace", "error"]).optional(),
+  asTable: z55.boolean().optional(),
+  freezeHeader: z55.boolean().optional(),
+  totals: z55.array(PluginSpreadsheetTotal).optional()
+});
+var PluginProgramSpreadsheetRenderResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  headerRange: z55.string(),
+  rowCount: z55.number(),
+  colCount: z55.number(),
+  tableName: z55.string().nullable(),
+  replaced: z55.boolean()
+});
+var PluginProgramSpreadsheetRenderDatasetArgs = z55.object({
+  sheetName: z55.string().optional(),
+  title: z55.string().optional(),
+  filter: z55.string().optional()
+});
+var PluginSpreadsheetExportFormat = z55.enum(["xlsx", "pdf", "csv"]);
+var PluginProgramSpreadsheetExportArgs = z55.object({
+  format: PluginSpreadsheetExportFormat,
+  fileName: z55.string().optional()
+});
+var PluginProgramSpreadsheetExportResult = z55.object({
+  format: PluginSpreadsheetExportFormat,
+  fileName: z55.string(),
+  mimeType: z55.string(),
+  dataBase64: z55.string()
+});
+var PluginSpreadsheetSheetInfo = z55.object({
+  name: z55.string(),
+  index: z55.number(),
+  visible: z55.boolean(),
+  rowCount: z55.number(),
+  colCount: z55.number()
+});
+var PluginProgramSpreadsheetListSheetsResult = z55.object({
+  sheets: z55.array(PluginSpreadsheetSheetInfo),
+  activeSheet: z55.string().nullable()
+});
+var PluginProgramSpreadsheetGetSheetDataArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string().optional(),
+  header: z55.boolean().optional()
+});
+var PluginProgramSpreadsheetGetSheetDataResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  values: z55.array(z55.array(PluginSpreadsheetCell)),
+  records: z55.array(z55.record(z55.string(), PluginSpreadsheetCell)).optional()
+});
+var PluginSpreadsheetChartType = z55.enum([
+  "column",
+  "bar",
+  "line",
+  "pie",
+  "area",
+  "scatter"
+]);
+var PluginProgramSpreadsheetAddChartArgs = z55.object({
+  sheetName: z55.string(),
+  chartType: PluginSpreadsheetChartType,
+  dataRange: z55.string(),
+  title: z55.string().optional(),
+  position: z55.object({ x: z55.number(), y: z55.number() }).optional(),
+  size: z55.object({ width: z55.number(), height: z55.number() }).optional()
+});
+var PluginProgramSpreadsheetAddChartResult = z55.object({
+  chartId: z55.string()
+});
+var PluginProgramSpreadsheetHighlightCellsArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  color: z55.string().optional(),
+  bold: z55.boolean().optional()
+});
+var PluginProgramSpreadsheetHighlightCellsResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string()
+});
+var PluginSpreadsheetProgramRow = z55.object({
+  departmentId: z55.string(),
+  name: z55.string(),
+  targetArea: z55.number().nullable(),
+  allocatedArea: z55.number(),
+  variance: z55.number().nullable()
+});
+var PluginProgramSpreadsheetGetProgramResult = z55.object({
+  units: PluginAreaUnit,
+  rows: z55.array(PluginSpreadsheetProgramRow),
+  totalTargetArea: z55.number(),
+  totalAllocatedArea: z55.number(),
+  generatedAt: z55.string()
+});
+var PluginSpreadsheetTakeoffRow = z55.object({
+  objectType: z55.string(),
+  category: z55.string(),
+  family: z55.string(),
+  quantity: z55.number(),
+  unit: z55.string()
+});
+var PluginProgramSpreadsheetGetTakeoffResult = z55.object({
+  rows: z55.array(PluginSpreadsheetTakeoffRow),
+  rowCount: z55.number(),
+  generatedAt: z55.string()
+});
+var PluginSpreadsheetWhenExists = z55.enum(["reuse", "replace", "error"]);
+var PluginProgramSpreadsheetCreateSheetArgs = z55.object({
+  name: z55.string(),
+  whenExists: PluginSpreadsheetWhenExists.optional()
+});
+var PluginProgramSpreadsheetCreateSheetResult = z55.object({
+  sheetName: z55.string(),
+  replaced: z55.boolean(),
+  sheetIndex: z55.number().nullable()
+});
+var PluginProgramSpreadsheetSetValuesArgs = z55.object({
+  sheetName: z55.string(),
+  values: z55.array(z55.array(PluginSpreadsheetCell)),
+  startCell: z55.string().optional()
+});
+var PluginProgramSpreadsheetSetValuesResult = z55.object({
+  sheetName: z55.string(),
+  startCell: z55.string(),
+  rowCount: z55.number(),
+  colCount: z55.number()
+});
+var PluginSpreadsheetFormula = z55.object({
+  cell: z55.string(),
+  formula: z55.string()
+});
+var PluginProgramSpreadsheetSetFormulasArgs = z55.object({
+  sheetName: z55.string(),
+  formulas: z55.array(PluginSpreadsheetFormula)
+});
+var PluginProgramSpreadsheetSetFormulasResult = z55.object({
+  sheetName: z55.string(),
+  count: z55.number()
+});
+var PluginSpreadsheetFontWeight = z55.enum(["normal", "bold"]);
+var PluginSpreadsheetFontStyle = z55.enum(["normal", "italic"]);
+var PluginSpreadsheetHorizontalAlign = z55.enum([
+  "left",
+  "center",
+  "right",
+  "general"
+]);
+var PluginSpreadsheetVerticalAlign = z55.enum([
+  "top",
+  "center",
+  "bottom"
+]);
+var PluginSpreadsheetCellStyle = z55.object({
+  backColor: z55.string().optional(),
+  foreColor: z55.string().optional(),
+  font: z55.string().optional(),
+  fontFamily: z55.string().optional(),
+  fontSize: z55.number().optional(),
+  fontWeight: PluginSpreadsheetFontWeight.optional(),
+  fontStyle: PluginSpreadsheetFontStyle.optional(),
+  formatter: z55.string().optional(),
+  horizontalAlign: PluginSpreadsheetHorizontalAlign.optional(),
+  verticalAlign: PluginSpreadsheetVerticalAlign.optional()
+});
+var PluginSpreadsheetRangeStyle = z55.object({
+  range: z55.string(),
+  style: PluginSpreadsheetCellStyle
+});
+var PluginProgramSpreadsheetSetStylesArgs = z55.object({
+  sheetName: z55.string(),
+  ranges: z55.array(PluginSpreadsheetRangeStyle)
+});
+var PluginProgramSpreadsheetSetStylesResult = z55.object({
+  sheetName: z55.string(),
+  count: z55.number()
+});
+var PluginProgramSpreadsheetMergeCellsArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  value: PluginSpreadsheetCell.optional()
+});
+var PluginProgramSpreadsheetMergeCellsResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string()
+});
+var PluginSpreadsheetConditionalRuleType = z55.enum(["dataBar"]);
+var PluginSpreadsheetConditionalRule = z55.object({
+  type: PluginSpreadsheetConditionalRuleType,
+  color: z55.string().optional()
+});
+var PluginProgramSpreadsheetAddConditionalFormattingArgs = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  rule: PluginSpreadsheetConditionalRule
+});
+var PluginProgramSpreadsheetAddConditionalFormattingResult = z55.object({
+  sheetName: z55.string(),
+  range: z55.string(),
+  created: z55.boolean()
+});
+var PluginProgramSpreadsheetRecalculateArgs = z55.object({
+  sheetName: z55.string().optional()
+});
+var PluginProgramSpreadsheetRecalculateResult = z55.object({
+  scope: z55.enum(["sheet", "workbook"]),
+  sheetName: z55.string().nullable()
+});
+var PluginSpreadsheetTransactionMethod = z55.enum([
+  "createSheet",
+  "setValues",
+  "setFormulas",
+  "setStyles",
+  "mergeCells"
+]);
+var PluginSpreadsheetTransactionOp = z55.object({
+  method: PluginSpreadsheetTransactionMethod,
+  args: z55.unknown()
+});
+var PluginProgramSpreadsheetTransactionArgs = z55.object({
+  operations: z55.array(PluginSpreadsheetTransactionOp),
+  label: z55.string().optional()
+});
+var PluginProgramSpreadsheetTransactionResult = z55.object({
+  label: z55.string(),
+  operationCount: z55.number(),
+  results: z55.array(z55.unknown())
+});
+var PluginProgramSpreadsheetRunScriptArgs = z55.object({
+  script: z55.string()
+});
+var PluginProgramSpreadsheetRunScriptResult = z55.object({
+  result: z55.unknown()
+});
+var PluginSpreadsheetAuditStatus = z55.enum(["success", "error"]);
+var PluginSpreadsheetAuditEntry = z55.object({
+  id: z55.string(),
+  pluginId: z55.string(),
+  method: z55.string(),
+  label: z55.string().optional(),
+  sheetName: z55.string().optional(),
+  timestamp: z55.string(),
+  status: PluginSpreadsheetAuditStatus,
+  summary: z55.string().optional()
 });
-var PProfile = z6.object({
-  curves: z6.array(PCurve)
+var PluginProgramSpreadsheetGetAuditLogArgs = z55.object({
+  limit: z55.number().optional()
+});
+var PluginProgramSpreadsheetGetAuditLogResult = z55.object({
+  entries: z55.array(PluginSpreadsheetAuditEntry)
+});
+var PluginProgramSpreadsheetPingResult = z55.object({
+  pong: z55.boolean()
+});
+var PluginSpreadsheetTemplateScope = z55.enum(["project", "global"]);
+var PluginProgramSpreadsheetTemplatesCreateArgs = z55.object({
+  name: z55.string(),
+  sheetName: z55.string(),
+  scope: PluginSpreadsheetTemplateScope.optional()
+});
+var PluginProgramSpreadsheetTemplatesCreateResult = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  scope: PluginSpreadsheetTemplateScope,
+  sheetName: z55.string()
+});
+var PluginProgramSpreadsheetTemplatesApplyArgs = z55.object({
+  name: z55.string(),
+  targetSheetName: z55.string()
+});
+var PluginProgramSpreadsheetTemplatesApplyResult = z55.object({
+  name: z55.string(),
+  targetSheetName: z55.string()
+});
+var PluginSpreadsheetBindingSource = z55.object({
+  dataset: z55.enum(["takeoff"])
+});
+var PluginSpreadsheetBindingMode = z55.enum(["replaceRange"]);
+var PluginSpreadsheetBindingTarget = z55.object({
+  sheetName: z55.string(),
+  startCell: z55.string().optional()
+});
+var PluginSpreadsheetBinding = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  pluginId: z55.string(),
+  source: PluginSpreadsheetBindingSource,
+  target: z55.object({
+    sheetName: z55.string(),
+    startCell: z55.string()
+  }),
+  mode: PluginSpreadsheetBindingMode,
+  createdAt: z55.string(),
+  updatedAt: z55.string()
+});
+var PluginSpreadsheetBindingRefresh = z55.object({
+  id: z55.string(),
+  name: z55.string(),
+  sheetName: z55.string(),
+  rowCount: z55.number()
+});
+var PluginProgramSpreadsheetBindingsCreateArgs = z55.object({
+  name: z55.string(),
+  source: PluginSpreadsheetBindingSource,
+  target: PluginSpreadsheetBindingTarget,
+  mode: PluginSpreadsheetBindingMode.optional()
+});
+var PluginProgramSpreadsheetBindingsCreateResult = PluginSpreadsheetBinding.extend({
+  refresh: PluginSpreadsheetBindingRefresh
+});
+var PluginProgramSpreadsheetBindingsRefreshArgs = z55.object({
+  name: z55.string().optional()
+});
+var PluginProgramSpreadsheetBindingsRefreshResult = z55.object({
+  refreshed: z55.array(PluginSpreadsheetBindingRefresh)
+});
+var PluginProgramSpreadsheetBindingsListResult = z55.object({
+  bindings: z55.array(PluginSpreadsheetBinding)
 });
 
-// src/api/core/geom/index.ts
-var PluginGeomApi = class {
+// src/api/program/site.ts
+import * as z56 from "zod";
+var PluginProgramSiteApi = class {
   constructor() {
   }
 };
+var PluginSiteFootprintPoint = z56.object({
+  x: z56.number(),
+  z: z56.number()
+});
+var PluginSiteGeoPoint = z56.object({
+  lat: z56.number(),
+  lng: z56.number(),
+  alt: z56.number()
+});
+var PluginSitePolygon = z56.object({
+  id: z56.string(),
+  area: z56.number(),
+  label: z56.string(),
+  footprint: z56.array(PluginSiteFootprintPoint)
+});
+var PluginProgramSiteSnapshot = z56.object({
+  units: PluginAreaUnit,
+  totalArea: z56.number(),
+  polygonCount: z56.number(),
+  polygons: z56.array(PluginSitePolygon)
+});
+var PluginProgramSiteAreaResult = z56.object({
+  units: PluginAreaUnit,
+  area: z56.number()
+});
+var PluginProgramSiteListPolygonsResult = z56.object({
+  units: PluginAreaUnit,
+  polygons: z56.array(PluginSitePolygon)
+});
+var PluginProgramSiteListGeoPolygonsResult = z56.object({
+  polygons: z56.array(z56.array(PluginSiteGeoPoint))
+});
+var PluginSiteLatLng = z56.object({
+  lat: z56.number(),
+  lng: z56.number()
+});
+var PluginSiteBounds = z56.object({
+  north: z56.number(),
+  south: z56.number(),
+  east: z56.number(),
+  west: z56.number()
+});
+var PluginSiteContextParcel = z56.object({
+  footprint: z56.array(PluginSiteLatLng),
+  area: z56.number()
+});
+var PluginProgramSiteContext = z56.object({
+  center: PluginSiteLatLng,
+  bounds: PluginSiteBounds,
+  widthInM: z56.number(),
+  heightInM: z56.number(),
+  zoom: z56.number(),
+  parcels: z56.array(PluginSiteContextParcel)
+});
+var PluginProgramSiteContextResult = PluginProgramSiteContext.nullable();
+var PluginProgramSiteLocation = z56.object({
+  latitude: z56.number(),
+  longitude: z56.number()
+});
+var PluginProgramSiteLocationResult = PluginProgramSiteLocation.nullable();
+var PluginProgramSiteNorthAngleResult = z56.number().nullable();
 
-// src/api/core/index.ts
-var PluginCoreApi = class {
+// src/api/program/cores.ts
+import * as z57 from "zod";
+var PluginProgramCoresApi = class {
   constructor() {
   }
 };
+var PluginProgramCore = z57.object({
+  id: z57.string(),
+  groupId: z57.string(),
+  storey: z57.number()
+});
+var PluginProgramCoresListResult = z57.object({
+  cores: z57.array(PluginProgramCore)
+});
+var PluginProgramCoresIsCoreArgs = z57.object({
+  id: z57.string()
+});
+var PluginProgramCoreSpec = z57.object({
+  type: z57.string().optional(),
+  position: z57.object({ x: z57.number(), y: z57.number(), z: z57.number() }),
+  width: z57.number(),
+  depth: z57.number(),
+  fromStorey: z57.number().optional(),
+  toStorey: z57.number().optional()
+});
+var PluginProgramCoresCreateArgs = z57.object({
+  cores: z57.array(PluginProgramCoreSpec),
+  lengthUnit: z57.enum(["mm", "m", "ft"]).optional()
+});
+var PluginProgramCoresCreateResult = z57.object({
+  createdCount: z57.number()
+});
 
-// src/api/entity/department.ts
-import * as z7 from "zod";
-var PluginDepartmentApi = class {
+// src/api/program/classification.ts
+import * as z58 from "zod";
+var PluginProgramClassificationApi = class {
   constructor() {
   }
 };
-var PluginDepartmentCreateArgs = z7.object({
-  name: z7.string(),
-  color: z7.string()
+var PluginClassificationOption = z58.object({
+  value: z58.string(),
+  label: z58.string()
 });
-var PluginDepartmentCreateResult = z7.object({
-  departmentId: z7.string()
+var PluginProgramClassificationTypesResult = z58.object({
+  spaceTypes: z58.array(PluginClassificationOption),
+  areaClasses: z58.array(PluginClassificationOption),
+  massTypes: z58.array(PluginClassificationOption)
 });
-var PluginDepartmentEntry = z7.object({
-  id: z7.string(),
-  name: z7.string(),
-  color: z7.string()
+var PluginProgramClassificationListTagsArgs = z58.object({
+  id: z58.string()
 });
-var PluginDepartmentGetAllResult = z7.object({
-  departments: z7.array(PluginDepartmentEntry)
+var PluginSpaceTag = z58.object({
+  tagId: z58.string(),
+  tagName: z58.string(),
+  color: z58.string(),
+  categoryId: z58.string()
+});
+var PluginProgramClassificationTagsResult = z58.object({
+  tagIds: z58.array(z58.string()),
+  tagsByCategory: z58.record(z58.string(), PluginSpaceTag)
 });
 
-// src/api/entity/referenceLine.ts
-import * as z8 from "zod";
-var PluginReferenceLineApi = class {
+// src/api/program/areas.ts
+import * as z59 from "zod";
+var PluginProgramAreasApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineCreateMultiArgs = z8.object({
-  profile: PProfile
+var PluginProgramAreaSummary = z59.object({
+  count: z59.number().int(),
+  hiddenCount: z59.number().int(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  farBuiltUp: z59.number(),
+  siteArea: z59.number(),
+  achievedFar: z59.number().nullable(),
+  targetFar: z59.number(),
+  deviation: z59.number(),
+  areaUnit: PluginAreaUnit
 });
-var PluginReferenceLineCreateMultiResult = z8.object({
-  referenceLineIds: z8.array(z8.string())
+var PluginProgramAreaGroup = z59.object({
+  groupId: z59.string(),
+  name: z59.string(),
+  color: z59.string(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  count: z59.number().int(),
+  targetArea: z59.number(),
+  targetUnit: PluginAreaUnit
 });
-var PluginReferenceLineGetProperty = z8.enum([
-  "curve"
+var PluginProgramAreaMember = z59.object({
+  id: ComponentHandle,
+  label: z59.string(),
+  carpet: z59.number(),
+  builtUp: z59.number(),
+  excluded: z59.number(),
+  isVisible: z59.boolean()
+});
+var PluginProgramAreaGroupBy = z59.enum([
+  "labels",
+  "storeys",
+  "buildings",
+  "departments",
+  "tagCategories"
 ]);
-var PluginReferenceLineGetArgs = z8.object({
-  referenceLineId: z8.string(),
-  properties: z8.array(PluginReferenceLineGetProperty)
+var PluginProgramAreasGetResult = PluginProgramAreaSummary;
+var PluginProgramAreasListArgs = z59.object({
+  groupBy: PluginProgramAreaGroupBy,
+  categoryId: z59.string().optional()
+}).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
+  message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginReferenceLineGetResult = z8.object({
-  curve: PCurve
-}).partial();
-var PluginReferenceLineGetAllResult = z8.object({
-  referenceLineIds: z8.array(z8.string())
+var PluginProgramAreasListResult = z59.object({
+  groups: z59.array(PluginProgramAreaGroup)
+});
+var PluginProgramAreasListMembersArgs = z59.object({
+  groupBy: PluginProgramAreaGroupBy,
+  groupId: z59.string(),
+  categoryId: z59.string().optional()
+}).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
+  message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginReferenceLineDeleteArgs = z8.object({
-  referenceLineId: z8.string()
+var PluginProgramAreasListMembersResult = z59.object({
+  members: z59.array(PluginProgramAreaMember)
 });
+var PluginProgramAreasUpdateArgs = z59.object({
+  targetFar: z59.number().min(0).optional(),
+  siteArea: z59.number().positive().optional(),
+  deviation: z59.number().min(0).max(100).optional()
+});
+var PluginProgramAreasUpdateResult = PluginProgramAreaSummary;
 
-// src/api/entity/space.ts
-import * as z9 from "zod";
-var PluginSpaceApi = class {
+// src/api/program/index.ts
+var PluginProgramApi = class {
   constructor() {
   }
 };
-var PluginSpaceCreateRectangularArgs = z9.object({
-  position: PVec3,
-  dimensions: z9.object({
-    width: z9.number(),
-    height: z9.number(),
-    depth: z9.number()
-  })
-});
-var PluginSpaceCreateRectangularResult = z9.object({
-  spaceId: z9.string()
+
+// src/api/presentation/views.ts
+import * as z60 from "zod";
+var PluginPresentationViewsApi = class {
+  constructor() {
+  }
+};
+var PluginPresentationViewType = z60.enum(["2d", "3d"]);
+var PluginPresentationView = z60.object({
+  id: z60.string(),
+  name: z60.string(),
+  type: PluginPresentationViewType,
+  isActive: z60.boolean()
 });
-var PluginSpaceCreateFromProfileArgs = z9.object({
-  profile: PProfile,
-  extrudeHeight: z9.number(),
-  position: PVec3
+var PluginPresentationViewsListResult = z60.object({
+  views: z60.array(PluginPresentationView)
 });
-var PluginSpaceCreateFromProfileResult = z9.object({
-  spaceId: z9.string()
+var PluginPresentationViewsGetArgs = z60.object({
+  id: z60.string()
 });
-var PluginSpaceGetProperty = z9.enum([
-  // Basic
-  "id",
-  "type",
-  "room_type",
-  "name",
-  // Derived from parametric data
-  "area",
-  "breadth",
-  "depth",
-  "height",
-  "massType",
-  "spaceType",
-  "storey",
-  "departmentId",
-  "departmentName",
-  "departmentColor",
-  // Derived from mesh
-  "position",
-  "absolutePosition",
-  "rotation",
-  "rotationQuaternion",
-  // Derived from brep
-  "planPoints"
-]);
-var PluginSpaceGetArgs = z9.object({
-  spaceId: z9.string(),
-  properties: z9.array(PluginSpaceGetProperty)
+var PluginPresentationViewsGetResult = PluginPresentationView.nullable();
+var PluginPresentationImageFormat = z60.enum(["png", "jpeg"]);
+var PluginPresentationViewsCaptureArgs = z60.object({
+  viewId: z60.string().optional(),
+  format: PluginPresentationImageFormat.optional(),
+  resolution: z60.string().optional()
 });
-var PluginSpaceType = z9.enum([
-  "Room",
-  "Program Block",
-  "Balcony",
-  "Road",
-  "Garden",
-  "Deck",
-  "Pool",
-  "Walkway",
-  "Envelope",
-  "Parking"
-]);
-var PluginSpaceGetResult = z9.object({
-  // Basic
-  id: z9.string(),
-  type: z9.string(),
-  room_type: z9.string(),
-  name: z9.string(),
-  // Derived from parametric data
-  area: z9.number(),
-  breadth: z9.number(),
-  depth: z9.number(),
-  height: z9.number(),
-  massType: z9.string().nullable(),
-  spaceType: PluginSpaceType.nullable(),
-  storey: z9.number().nullable(),
-  departmentId: z9.string().nullable(),
-  departmentName: z9.string(),
-  departmentColor: z9.string(),
-  // Derived from mesh
-  position: PVec3,
-  absolutePosition: PVec3,
-  rotation: PVec3,
-  rotationQuaternion: PQuat.nullable(),
-  // Derived from brep
-  planPoints: z9.array(PVec3)
-}).partial();
-var PluginSpaceGetAllResult = z9.object({
-  spacesIds: z9.array(z9.string())
+var PluginPresentationViewsCaptureResult = z60.object({
+  image: z60.string()
 });
-var PluginSpaceDeleteArgs = z9.object({
-  spaceId: z9.string()
+var PluginPresentationViewsSetActiveArgs = z60.object({
+  id: z60.string()
 });
-var PluginMassType = z9.enum([
-  "Plinth",
-  "Void",
-  "Pergola",
-  "Furniture",
-  "Facade element",
-  "Generic mass",
-  "Room",
-  "Department",
-  "Building",
-  "Revit Import",
-  "Mass",
-  "Site"
-]);
-var PluginWellKnownDepartmentId = z9.enum([
-  "DEFAULT",
-  "SITE",
-  "ENVELOPE",
-  "CORE"
-]);
-var PluginDepartmentId = z9.union([
-  PluginWellKnownDepartmentId,
-  z9.uuid()
-]);
-var PluginSpaceUpdateArgs = z9.object({
-  spaceId: z9.string(),
-  properties: z9.object({
-    room_type: z9.string().optional(),
-    massType: PluginMassType.optional(),
-    spaceType: PluginSpaceType.optional(),
-    departmentId: PluginDepartmentId.optional()
-  })
+var PluginPresentationViewsSetActiveResult = z60.object({
+  id: z60.string()
 });
-var PluginSpaceUpdateResult = z9.object({
-  spaceId: z9.string(),
-  room_type: z9.string().optional(),
-  massType: z9.string().optional(),
-  spaceType: z9.string().optional(),
-  departmentId: z9.string().nullable().optional()
+var PluginPresentationViewsCreateArgs = z60.object({
+  name: z60.string().optional(),
+  kind: z60.enum(["view", "sitePlan"]).optional()
 });
+var PluginPresentationViewsCreateResult = PluginPresentationView;
 
-// src/api/entity/story.ts
-import * as z10 from "zod";
-var PluginStoryApi = class {
+// src/api/presentation/sheets.ts
+import * as z61 from "zod";
+var PluginPresentationSheetsApi = class {
   constructor() {
   }
 };
-var PluginStoryGetProperty = z10.enum([
-  "value",
-  "id",
-  "name",
-  "height",
-  "base",
-  "hidden",
-  "spacesCount",
-  "totalArea"
-]);
-var PluginStoryGetArgs = z10.object({
-  storyValue: z10.number().int(),
-  properties: z10.array(PluginStoryGetProperty)
-});
-var PluginStoryGetResult = z10.object({
-  value: z10.number(),
-  id: z10.string(),
-  name: z10.string(),
-  height: z10.number(),
-  base: z10.number(),
-  hidden: z10.boolean(),
-  spacesCount: z10.number(),
-  totalArea: z10.number()
-}).partial();
-var PluginStoryGetAllResult = z10.object({
-  stories: z10.array(
-    z10.object({
-      value: z10.number(),
-      id: z10.string(),
-      name: z10.string()
-    })
-  )
+var PluginPresentationSheet = z61.object({
+  id: z61.string(),
+  name: z61.string()
+});
+var PluginSheetPosition = z61.object({
+  x: z61.number(),
+  y: z61.number()
+});
+var PluginPresentationSheetsListResult = z61.object({
+  sheets: z61.array(PluginPresentationSheet)
 });
-var PluginStoryCreateArgs = z10.object({
-  storyValue: z10.number().int(),
-  height: z10.number().optional()
+var PluginPresentationSheetsGetArgs = z61.object({
+  id: z61.string()
 });
-var PluginStoryCreateResult = z10.object({
-  storyId: z10.string(),
-  storyValue: z10.number()
+var PluginPresentationSheetsGetResult = PluginPresentationSheet.nullable();
+var PluginPresentationSheetsCreateArgs = z61.object({
+  name: z61.string().optional()
 });
-var PluginStoryUpdateArgs = z10.object({
-  storyValue: z10.number().int(),
-  height: z10.number()
+var PluginPresentationSheetsPlaceArgs = z61.object({
+  sheetId: z61.string(),
+  viewId: z61.string(),
+  position: PluginSheetPosition.optional()
 });
-var PluginStoryUpdateResult = z10.object({
-  storyValue: z10.number(),
-  height: z10.number()
+var PluginPresentationSheetsPlaceResult = z61.object({
+  shapeId: z61.string()
 });
 
-// src/api/entity/index.ts
-var PluginEntityApi = class {
+// src/api/presentation/diagrams.ts
+import * as z62 from "zod";
+var PluginPresentationDiagramsApi = class {
   constructor() {
   }
 };
+var PluginPresentationDiagramsPlaceArgs = z62.object({
+  sheetId: z62.string(),
+  urls: z62.array(z62.string()),
+  position: z62.object({ x: z62.number(), y: z62.number() }).optional()
+});
+var PluginPresentationDiagramsPlaceResult = z62.object({
+  shapeIds: z62.array(z62.string())
+});
 
-// src/api/tools/copy.ts
-import * as z11 from "zod";
-var PluginCopyMode = z11.enum(["instance", "unique"]);
-var PluginCopyArgs = z11.object({
-  componentIds: z11.array(z11.string()).min(1),
-  displacement: PVec3,
-  count: z11.number().int().positive().optional(),
-  copyMode: PluginCopyMode.optional()
+// src/api/presentation/import.ts
+import * as z63 from "zod";
+var PluginPresentationImportApi = class {
+  constructor() {
+  }
+};
+var PluginPresentationImportArgs = z63.object({
+  url: z63.string().optional(),
+  dataUrl: z63.string().optional(),
+  position: z63.object({ x: z63.number(), y: z63.number() }).optional()
+}).refine((a) => Boolean(a.url) || Boolean(a.dataUrl), {
+  message: "Provide a url or a dataUrl"
 });
-var PluginCopyResult = z11.object({
-  copiedIds: z11.array(z11.string())
+var PluginPresentationImportResult = z63.object({
+  shapeIds: z63.array(z63.string())
 });
 
-// src/api/tools/offset.ts
-import * as z12 from "zod";
-var PluginOffsetArgs = z12.object({
-  componentId: z12.string().min(1),
-  distance: z12.number(),
-  profilePickPoint: PVec3.optional()
+// src/api/presentation/aiInspiration.ts
+import * as z64 from "zod";
+var JsonPrimitive = z64.union([z64.string(), z64.number(), z64.boolean(), z64.null()]);
+var JsonValue = z64.lazy(
+  () => z64.union([JsonPrimitive, z64.array(JsonValue), z64.record(z64.string(), JsonValue)])
+);
+var PluginAIInspirationOutputKind = z64.enum([
+  "source",
+  "image",
+  "video"
+]);
+var PluginAIInspirationModelOutput = z64.enum(["image", "video"]);
+var PluginAIInspirationShapeKind = z64.enum(["image", "view", "video"]);
+var PluginAIInspirationVideoMode = z64.enum([
+  "animate",
+  "references",
+  "keyframes"
+]);
+var PluginAIInspirationVideoMotion = z64.enum([
+  "auto",
+  "slow-dolly",
+  "subtle-orbit",
+  "reveal"
+]);
+var PluginAIInspirationVideoDuration = z64.enum(["4s", "6s", "8s"]);
+var PluginAIInspirationRegionHint = z64.object({
+  x: z64.number().finite(),
+  y: z64.number().finite(),
+  w: z64.number().finite().positive(),
+  h: z64.number().finite().positive()
+});
+var PluginAIInspirationPoint = z64.object({
+  x: z64.number().finite(),
+  y: z64.number().finite()
+});
+var PluginAIInspirationTextAnnotation = z64.object({
+  text: z64.string().min(1),
+  x: z64.number().finite().optional(),
+  y: z64.number().finite().optional()
+});
+var PluginAIInspirationSketchGuidance = z64.object({
+  visualShapeIds: z64.array(z64.string()).optional(),
+  textAnnotations: z64.array(PluginAIInspirationTextAnnotation).optional()
+});
+var PluginAIInspirationSiteOptions = z64.object({
+  includeSatellite: z64.boolean().optional(),
+  includeStreetView: z64.boolean().optional(),
+  includeAerial: z64.boolean().optional(),
+  aerialBearing: z64.number().finite().optional(),
+  aerialPitch: z64.number().finite().optional(),
+  selectedDiagramIds: z64.array(z64.string()).optional(),
+  location: z64.object({
+    lat: z64.number().finite(),
+    lng: z64.number().finite()
+  }).optional()
+});
+var PluginAIInspirationAppliedPreset = z64.object({
+  source: z64.enum(["curated", "user"]),
+  presetId: z64.string().min(1),
+  name: z64.string().min(1),
+  savedPresetKind: z64.enum(["prompt", "style"]).optional(),
+  stylePrompt: z64.string().optional(),
+  modelId: z64.string().optional(),
+  referenceImages: z64.array(
+    z64.object({
+      url: z64.string().min(1),
+      label: z64.string().optional(),
+      weight: z64.number().finite().optional()
+    })
+  ).optional(),
+  siteDefaults: z64.object({
+    includeSatellite: z64.boolean().optional(),
+    includeStreetView: z64.boolean().optional(),
+    includeAerial: z64.boolean().optional()
+  }).optional()
+});
+var PluginAIInspirationVideoOptions = z64.object({
+  mode: PluginAIInspirationVideoMode.optional(),
+  endFrameShapeId: z64.string().optional(),
+  motion: PluginAIInspirationVideoMotion.optional(),
+  duration: PluginAIInspirationVideoDuration.optional()
+});
+var PluginAIInspirationModel = z64.object({
+  id: z64.string(),
+  label: z64.string(),
+  supportsMultiImage: z64.boolean(),
+  output: PluginAIInspirationModelOutput,
+  isDefault: z64.boolean().optional()
+});
+var PluginAIInspirationListModelsResult = z64.object({
+  defaultModelId: z64.string(),
+  models: z64.array(PluginAIInspirationModel)
+});
+var PluginAIInspirationShapeRef = z64.object({
+  shapeId: z64.string(),
+  assetId: z64.string().optional(),
+  kind: PluginAIInspirationShapeKind,
+  name: z64.string().optional(),
+  width: z64.number().finite().optional(),
+  height: z64.number().finite().optional(),
+  outputType: PluginAIInspirationOutputKind.optional(),
+  sourceUrl: z64.string().optional()
+});
+var PluginAIInspirationListSourcesArgs = z64.object({
+  includeGenerated: z64.boolean().optional(),
+  includeSourceUrl: z64.boolean().optional()
+});
+var PluginAIInspirationListSourcesResult = z64.object({
+  sources: z64.array(PluginAIInspirationShapeRef)
 });
-var PluginOffsetResult = z12.object({
-  createdIds: z12.array(z12.string()),
-  deletedIds: z12.array(z12.string())
+var PluginAIInspirationOutput = z64.object({
+  outputType: z64.enum(["image", "video"]),
+  shapeId: z64.string(),
+  assetId: z64.string(),
+  outputUrl: z64.string().optional(),
+  position: PluginAIInspirationPoint.optional()
 });
+var PluginAIInspirationDebugSummary = z64.record(z64.string(), JsonValue);
+var PluginAIInspirationRunMetadata = z64.object({
+  geometryFidelity: z64.string().optional(),
+  debugSummary: PluginAIInspirationDebugSummary.optional(),
+  streetViewComposite: z64.object({
+    used: z64.boolean(),
+    renderMode: z64.enum(["prompt_refs_default", "masked_composite_pilot"]),
+    backgroundLabel: z64.string().optional()
+  }).optional()
+});
+var PluginAIInspirationGenerateArgs = z64.object({
+  sourceShapeId: z64.string().min(1),
+  prompt: z64.string().min(1).max(8e3),
+  modelId: z64.string().optional(),
+  referenceShapeIds: z64.array(z64.string()).max(12).optional(),
+  referenceStrength: z64.enum(["low", "medium", "high"]).optional(),
+  appliedPreset: PluginAIInspirationAppliedPreset.optional(),
+  site: PluginAIInspirationSiteOptions.optional(),
+  regionHint: PluginAIInspirationRegionHint.optional(),
+  sketchGuidance: PluginAIInspirationSketchGuidance.optional(),
+  video: PluginAIInspirationVideoOptions.optional()
+});
+var PluginAIInspirationRunResult = z64.object({
+  outputs: z64.array(PluginAIInspirationOutput).min(1),
+  metadata: PluginAIInspirationRunMetadata.optional()
+});
+var PluginAIInspirationRefineArgs = z64.object({
+  sourceShapeId: z64.string().min(1),
+  upscaleFactor: z64.union([z64.literal(1.5), z64.literal(2), z64.literal(4)]).optional()
+});
+var PluginPresentationAIInspirationApi = class {
+  constructor() {
+  }
+};
 
-// src/api/tools/selection.ts
-import * as z13 from "zod";
-var PluginSelectionApi = class {
+// src/api/presentation/index.ts
+var PluginPresentationApi = class {
   constructor() {
   }
 };
-var PluginSelectionGetResult = z13.object({
-  selected: z13.array(z13.string())
-});
 
-// src/api/tools/transform.ts
-import * as z14 from "zod";
-var PluginTransformApi = class {
+// src/api/analysis/sunpath.ts
+var PluginAnalysisSunpathApi = class {
+  constructor() {
+  }
+};
+
+// src/api/analysis/shadows.ts
+import * as z65 from "zod";
+var PluginAnalysisShadowsApi = class {
   constructor() {
   }
 };
-var PluginMoveArgs = z14.object({
-  componentIds: z14.array(z14.string()),
-  displacement: PVec3
+var PluginAnalysisShadowsEnableOptions = z65.object({
+  dateTime: z65.string().optional()
 });
-var PluginRotateArgs = z14.object({
-  componentIds: z14.array(z14.string()),
-  angle: z14.number(),
-  axis: PVec3,
-  pivot: PVec3
+var PluginAnalysisShadowsSetDateTimeArgs = z65.object({
+  dateTime: z65.string()
 });
+var PluginAnalysisShadowsDateTimeResult = z65.string();
 
-// src/api/tools/material.ts
-import * as z15 from "zod";
-var PluginMaterialApi = class {
+// src/api/analysis/sunlightHours.ts
+import * as z66 from "zod";
+var PluginAnalysisSunlightHoursApi = class {
   constructor() {
   }
 };
-var DEFAULT_MATERIALS = /* @__PURE__ */ ((DEFAULT_MATERIALS2) => {
-  DEFAULT_MATERIALS2["GLASS"] = "glass";
-  DEFAULT_MATERIALS2["WOOD"] = "wood";
-  DEFAULT_MATERIALS2["METAL"] = "metal";
-  DEFAULT_MATERIALS2["STONE"] = "stone";
-  DEFAULT_MATERIALS2["TILES"] = "tiles";
-  DEFAULT_MATERIALS2["CONCRETE"] = "concrete";
-  DEFAULT_MATERIALS2["BRICK"] = "brick";
-  return DEFAULT_MATERIALS2;
-})(DEFAULT_MATERIALS || {});
-var PluginMaterialArgs = z15.object({
-  materialName: z15.enum(Object.values(DEFAULT_MATERIALS)),
-  componentIds: z15.array(z15.string())
+var PluginAnalysisComputeResult = z66.object({
+  success: z66.boolean(),
+  error: z66.string().optional()
 });
+var PluginAnalysisJobStatus = z66.enum([
+  "running",
+  "active",
+  "inactive"
+]);
+var PluginAnalysisJobState = z66.object({
+  status: PluginAnalysisJobStatus,
+  startDate: z66.string(),
+  endDate: z66.string()
+});
+var PluginAnalysisJobStateResult = PluginAnalysisJobState.nullable();
 
-// src/api/tools/index.ts
-var PluginToolsApi = class {
+// src/api/analysis/illuminance.ts
+var PluginAnalysisIlluminanceApi = class {
   constructor() {
   }
 };
 
-// src/api/units/index.ts
-import * as z16 from "zod";
-var PluginUnitsApi = class {
+// src/api/analysis/heatmaps.ts
+import * as z67 from "zod";
+var PluginAnalysisHeatmapsApi = class {
   constructor() {
   }
 };
-var PUnitType = z16.enum([
-  "meters",
-  "feet-inches",
-  "inches",
-  "centimeters",
-  "millimeters",
-  "kilometers",
-  "miles"
-]);
-var PluginUnitsConvertFromArgs = z16.object({
-  unit: PUnitType,
-  value: z16.number(),
-  degree: z16.number().int().min(1).max(3).optional()
+var PluginAnalysisHeatmapSpaceEntry = z67.object({
+  space: ComponentHandle,
+  value: z67.number().finite()
 });
-var PluginUnitsConvertFromResult = z16.object({
-  value: z16.number()
+var PluginAnalysisHeatmapGridCell = z67.object({
+  position: Vec3Components,
+  value: z67.number().finite()
 });
-var PluginUnitsConvertToArgs = z16.object({
-  unit: PUnitType,
-  value: z16.number(),
-  degree: z16.number().int().min(1).max(3).optional()
+var PluginAnalysisHeatmapOptions = z67.object({
+  title: z67.string().optional(),
+  unit: z67.string().optional(),
+  min: z67.number().finite().optional(),
+  max: z67.number().finite().optional(),
+  colors: z67.array(z67.string().regex(/^#?[0-9a-fA-F]{6}$/, 'expected a 6-digit hex colour like "#0000ff"')).min(1).optional()
 });
-var PluginUnitsConvertToResult = z16.object({
-  value: z16.number()
+var PluginAnalysisHeatmapsRenderResult = z67.object({
+  success: z67.literal(true)
 });
 
+// src/api/analysis/index.ts
+var PluginAnalysisApi = class {
+  constructor() {
+  }
+};
+
 // src/api/index.ts
 var PluginApi = class {
   constructor() {
   }
 };
 export {
-  PArc,
-  PCurve,
-  PLine,
-  PProfile,
-  PQuat,
+  ArcHandle,
+  BBoxComponents,
+  BooleanOptions,
+  BooleanOutcome,
+  BrepHandle,
+  CadJsonInput,
+  CircleHandle,
+  CommentHandle,
+  ComponentHandle,
+  ContourHandle,
+  CurveHandle,
+  DEFAULT_ERASE_STRATEGIES,
+  EdgeHandle,
+  ErasableEdgeRef,
+  EraseStrategy,
+  FaceHandle,
+  HalfEdgeHandle,
+  ImportJobHandle,
+  ImportJobStatus,
+  ImportSource,
+  LineHandle,
+  MassHandle,
+  MaterialHandle,
+  ModelFormat,
+  OffsetSplitOutcome,
   PUnitType,
-  PVec3,
+  PluginAIInspirationAppliedPreset,
+  PluginAIInspirationDebugSummary,
+  PluginAIInspirationGenerateArgs,
+  PluginAIInspirationListModelsResult,
+  PluginAIInspirationListSourcesArgs,
+  PluginAIInspirationListSourcesResult,
+  PluginAIInspirationModel,
+  PluginAIInspirationModelOutput,
+  PluginAIInspirationOutput,
+  PluginAIInspirationOutputKind,
+  PluginAIInspirationPoint,
+  PluginAIInspirationRefineArgs,
+  PluginAIInspirationRegionHint,
+  PluginAIInspirationRunMetadata,
+  PluginAIInspirationRunResult,
+  PluginAIInspirationShapeKind,
+  PluginAIInspirationShapeRef,
+  PluginAIInspirationSiteOptions,
+  PluginAIInspirationSketchGuidance,
+  PluginAIInspirationTextAnnotation,
+  PluginAIInspirationVideoDuration,
+  PluginAIInspirationVideoMode,
+  PluginAIInspirationVideoMotion,
+  PluginAIInspirationVideoOptions,
+  PluginAdjacencyLevel,
+  PluginAnalysisApi,
+  PluginAnalysisComputeResult,
+  PluginAnalysisHeatmapGridCell,
+  PluginAnalysisHeatmapOptions,
+  PluginAnalysisHeatmapSpaceEntry,
+  PluginAnalysisHeatmapsApi,
+  PluginAnalysisHeatmapsRenderResult,
+  PluginAnalysisIlluminanceApi,
+  PluginAnalysisJobState,
+  PluginAnalysisJobStateResult,
+  PluginAnalysisJobStatus,
+  PluginAnalysisShadowsApi,
+  PluginAnalysisShadowsDateTimeResult,
+  PluginAnalysisShadowsEnableOptions,
+  PluginAnalysisShadowsSetDateTimeArgs,
+  PluginAnalysisSunlightHoursApi,
+  PluginAnalysisSunpathApi,
   PluginApi,
-  PluginArcApi,
-  PluginCopyArgs,
+  PluginAreaClass,
+  PluginAreaUnit,
+  PluginBuildableEnvelopeApi,
+  PluginBuildableEnvelopeCreateArgs,
+  PluginBuildableEnvelopeCreateResult,
+  PluginBuildableEnvelopePolygonVertex,
+  PluginBuildableEnvelopeSetbackTier,
+  PluginBuildableEnvelopeUpdateArgs,
+  PluginBuildableEnvelopeUpdateResult,
+  PluginBuildableEnvelopeVerticalCap,
+  PluginClassificationOption,
+  PluginCommentApi,
+  PluginCommentCreateArgs,
+  PluginCommentRefArgs,
+  PluginCommentTagArgs,
+  PluginCommentUpdateArgs,
   PluginCopyMode,
-  PluginCopyResult,
   PluginCoreApi,
-  PluginCurveApi,
-  PluginDepartmentApi,
-  PluginDepartmentCreateArgs,
-  PluginDepartmentCreateResult,
-  PluginDepartmentEntry,
-  PluginDepartmentGetAllResult,
+  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,
+  PluginCoreIoApi,
+  PluginCoreIoImportApi,
+  PluginCoreIoJobApi,
+  PluginCoreIoQueryApi,
+  PluginCoreIoTerrainApi,
+  PluginCoreIoUnderlayApi,
+  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,
-  PluginLineApi,
+  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,
+  PluginImportCadJsonArgs,
+  PluginImportDwgArgs,
+  PluginImportImageArgs,
+  PluginImportJobArgs,
+  PluginImportModelArgs,
+  PluginImportPdfArgs,
+  PluginImportTerrainArgs,
   PluginMassType,
-  PluginMaterialApi,
-  PluginMaterialArgs,
+  PluginMaterialInfo,
+  PluginMaterialResult,
+  PluginMaterialSpec,
   PluginMathApi,
-  PluginMoveArgs,
-  PluginOffsetArgs,
-  PluginOffsetResult,
-  PluginProfileApi,
-  PluginProfileFromLinePointsArgs,
+  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,
+  PluginProgramSiteLocation,
+  PluginProgramSiteLocationResult,
+  PluginProgramSiteNorthAngleResult,
+  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,
+  PluginQueryCadLayersArgs,
+  PluginQueryPdfPageCountArgs,
   PluginReferenceLineApi,
   PluginReferenceLineCreateMultiArgs,
   PluginReferenceLineCreateMultiResult,
@@ -987,22 +3734,74 @@ export {
   PluginReferenceLineGetArgs,
   PluginReferenceLineGetProperty,
   PluginReferenceLineGetResult,
-  PluginRotateArgs,
-  PluginSelectionApi,
-  PluginSelectionGetResult,
-  PluginSpaceApi,
+  PluginReferenceLineStyle,
+  PluginSelectionEntityType,
+  PluginSelectionFilter,
+  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,
@@ -1012,14 +3811,32 @@ export {
   PluginStoryGetResult,
   PluginStoryUpdateArgs,
   PluginStoryUpdateResult,
-  PluginToolsApi,
-  PluginTransformApi,
+  PluginTerrainSetDatumArgs,
+  PluginTerrainSetOpacityArgs,
+  PluginToleranceArgs,
+  PluginUnderlayListArgs,
+  PluginUnderlayPlanSize,
+  PluginUnderlayRefArgs,
+  PluginUnderlaySetOpacityArgs,
+  PluginUnderlaySetScaleArgs,
+  PluginUnderlaySetScaleValue,
   PluginUnitsApi,
-  PluginUnitsConvertFromArgs,
-  PluginUnitsConvertFromResult,
-  PluginUnitsConvertToArgs,
-  PluginUnitsConvertToResult,
+  PluginUnitsConvertArgs,
+  PluginUnitsSetTypeArgs,
+  PluginUpdateSpaceItem,
   PluginVec3Api,
-  PluginWellKnownDepartmentId
+  PluginWellKnownDepartmentId,
+  PluginWindowDimensions,
+  PluginZoomApi,
+  ProfileHandle,
+  QuatComponents,
+  QuatHandle,
+  TerrainHandle,
+  TerrainReport,
+  UnderlayHandle,
+  Vec3Components,
+  Vec3Handle,
+  VertexHandle,
+  handleSchema
 };
 //# sourceMappingURL=index.js.map