@snaptrude/plugin-core 0.2.3 → 0.2.4

package/dist/api/core/math/quat.d.ts

@@ -1,187 +0,0 @@
-import * as z from "zod";
-import type { PVec3 } from "./vec3";
-/**
- * Quaternion operations for 3D rotations.
- *
- * Quaternions avoid gimbal lock and provide smooth interpolation
- * compared to Euler angles. All methods are **pure** — they return
- * new {@linkcode PQuat} values without mutating the inputs.
- *
- * Accessed via `snaptrude.core.math.quat`.
- */
-export declare abstract class PluginQuatApi {
-    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: number, y: number, z: number, w: number): PQuat;
-    /**
-     * Create an identity quaternion representing no rotation.
-     *
-     * @returns `{ x: 0, y: 0, z: 0, w: 1 }`
-     */
-    identity(): PQuat;
-    /**
-     * 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: PVec3, angle: number): PQuat;
-    /**
-     * 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: number, y: number, z: number): PQuat;
-    /**
-     * 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: PQuat, b: PQuat): PQuat;
-    /**
-     * 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: PQuat): PQuat;
-    /**
-     * Compute the length (magnitude) of a quaternion.
-     *
-     * @param q - The quaternion
-     * @returns The magnitude `√(x² + y² + z² + w²)`
-     */
-    length(q: PQuat): number;
-    /**
-     * 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: PQuat): PQuat;
-    /**
-     * 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: PQuat): PQuat;
-    /**
-     * 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: PQuat, v: PVec3): PVec3;
-    /**
-     * 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: PQuat): {
-        axis: PVec3;
-        angle: number;
-    };
-    /**
-     * 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: PQuat, b: PQuat, t: number): PQuat;
-    /**
-     * 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: PQuat, b: PQuat): number;
-    /**
-     * 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: PQuat, b: PQuat): boolean;
-    /**
-     * 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: PQuat, b: PQuat, epsilon?: number): boolean;
-}
-/**
- * A quaternion with `x`, `y`, `z`, and `w` components.
- *
- * Used for representing 3D rotations without gimbal lock.
- * Equivalent to `BABYLON.Quaternion`.
- */
-export declare const PQuat: z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-    z: z.ZodNumber;
-    w: z.ZodNumber;
-}, z.core.$strip>;
-export type PQuat = z.infer<typeof PQuat>;
-//# sourceMappingURL=quat.d.ts.map

package/dist/api/core/math/quat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quat.d.ts","sourceRoot":"","sources":["../../../../src/api/core/math/quat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAEnC;;;;;;;;GAQG;AACH,8BAAsB,aAAa;;IAGjC;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAItD;;;;OAIG;IACH,QAAQ,IAAI,KAAK;IAIjB;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK;IAahD;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAejD;;;;;;;;;OASG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;IASnC;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK;IAI1B;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAIxB;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK;IAM1B;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK;IAMxB;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;IAOrC;;;;;;;;OAQG;IACH,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG;QAAE,IAAI,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAarD;;;;;;;;;OASG;IACH,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAsB3C;;;;;;;;;OASG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM;IAI/B;;;;;;;;OAQG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO;IAInC;;;;;;;OAOG;IACH,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO;CAQlE;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;iBAKhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAA"}

package/dist/api/core/math/vec3.d.ts

@@ -1,156 +0,0 @@
-import * as z from "zod";
-/**
- * 3D vector operations for positions, directions, and displacements.
- *
- * All methods are **pure** — they return new {@linkcode PVec3} values
- * without mutating the inputs.
- *
- * Accessed via `snaptrude.core.math.vec3`.
- */
-export declare abstract class PluginVec3Api {
-    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: number, y: number, z: number): PVec3;
-    /**
-     * 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: PVec3, b: PVec3): PVec3;
-    /**
-     * 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: PVec3, b: PVec3): PVec3;
-    /**
-     * 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: PVec3, scalar: number): PVec3;
-    /**
-     * 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: PVec3, b: PVec3): number;
-    /**
-     * 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: PVec3, b: PVec3): PVec3;
-    /**
-     * Compute the length (magnitude) of a vector.
-     *
-     * @param v - The vector
-     * @returns The Euclidean length `√(x² + y² + z²)`
-     */
-    length(v: PVec3): number;
-    /**
-     * 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: PVec3): number;
-    /**
-     * 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: PVec3): PVec3;
-    /**
-     * Compute the Euclidean distance between two points.
-     *
-     * @param a - First point
-     * @param b - Second point
-     * @returns The distance `|a - b|`
-     */
-    distance(a: PVec3, b: PVec3): number;
-    /**
-     * 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: PVec3, b: PVec3, t: number): PVec3;
-    /**
-     * Negate a vector (reverse its direction).
-     *
-     * @param v - The vector to negate
-     * @returns A new {@linkcode PVec3} with all components negated
-     */
-    negate(v: PVec3): PVec3;
-    /**
-     * 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: PVec3, b: PVec3): boolean;
-    /**
-     * 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: PVec3, b: PVec3, epsilon?: number): boolean;
-}
-/**
- * A 3D vector with `x`, `y`, and `z` components.
- *
- * Used throughout the plugin API for positions, directions, displacements,
- * and Euler rotation angles. Equivalent to `BABYLON.Vector3`.
- */
-export declare const PVec3: z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-    z: z.ZodNumber;
-}, z.core.$strip>;
-export type PVec3 = z.infer<typeof PVec3>;
-//# sourceMappingURL=vec3.d.ts.map

package/dist/api/core/math/vec3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vec3.d.ts","sourceRoot":"","sources":["../../../../src/api/core/math/vec3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB;;;;;;;GAOG;AACH,8BAAsB,aAAa;;IAGjC;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAI3C;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;IAI9B;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;IAInC;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK;IAItC;;;;;;;;;;OAUG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM;IAI/B;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;IAQhC;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAIxB;;;;;;;;OAQG;IACH,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAI/B;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK;IAM1B;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM;IAIpC;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAQ1C;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK;IAIvB;;;;;;;;OAQG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO;IAInC;;;;;;;OAOG;IACH,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO;CAOlE;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;iBAIhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAA"}

package/dist/api/entity/buildableEnvelope.d.ts

@@ -1,233 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Buildable Envelope management — create and update parametric zoning envelopes.
- *
- * A **buildable envelope** is the regulated volume inside which a building may
- * be massed. The host owns envelope identity: {@linkcode PluginBuildableEnvelopeApi.create create}
- * mints a `buildableEnvelopeId` and returns it; {@linkcode PluginBuildableEnvelopeApi.update update}
- * requires that id to target the existing envelope.
- *
- * Accessed via `snaptrude.entity.buildableEnvelope`.
- */
-export declare abstract class PluginBuildableEnvelopeApi {
-    constructor();
-    /**
-     * Create a new parametric buildable envelope.
-     *
-     * @param args - A {@linkcode PluginBuildableEnvelopeCreateArgs} object.
-     * @returns A {@linkcode PluginBuildableEnvelopeCreateResult} with the
-     *   `buildableEnvelopeId` of the created envelope.
-     * @throws If validation fails or generation produces no renderable geometry.
-     *
-     * # Example
-     * ```ts
-     * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.create({
-     *   sitePolygon: [
-     *     { x: 0, z: 0 },
-     *     { x: 100, z: 0 },
-     *     { x: 100, z: 80 },
-     *     { x: 0, z: 80 },
-     *   ],
-     *   lengthUnit: "ft",
-     *   setbacks: [
-     *     { aboveHeight: 0, front: 10, side: 5, rear: 10 },
-     *     { aboveHeight: 100, front: 20, side: 10, rear: 20 },
-     *   ],
-     *   verticalCap: { kind: "max_height", maxHeight: 150 },
-     *   floorToFloor: 12,
-     * })
-     * ```
-     */
-    abstract create(args: PluginBuildableEnvelopeCreateArgs): PluginApiReturn<PluginBuildableEnvelopeCreateResult>;
-    /**
-     * Update an existing parametric buildable envelope.
-     *
-     * @param args - A {@linkcode PluginBuildableEnvelopeUpdateArgs} object.
-     *   `buildableEnvelopeId` is required and must match an existing envelope on
-     *   the canvas.
-     * @returns A {@linkcode PluginBuildableEnvelopeUpdateResult} with the
-     *   `buildableEnvelopeId` of the updated envelope.
-     * @throws If validation fails, the envelope does not exist, or generation
-     *   produces no renderable geometry.
-     *
-     * # Example
-     * ```ts
-     * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.update({
-     *   buildableEnvelopeId: existingId,
-     *   sitePolygon: [
-     *     { x: 0, z: 0 },
-     *     { x: 100, z: 0 },
-     *     { x: 100, z: 80 },
-     *     { x: 0, z: 80 },
-     *   ],
-     *   lengthUnit: "ft",
-     *   setbacks: [{ aboveHeight: 0, front: 10, side: 5, rear: 10 }],
-     *   verticalCap: { kind: "max_height", maxHeight: 175 },
-     *   floorToFloor: 12,
-     * })
-     * ```
-     */
-    abstract update(args: PluginBuildableEnvelopeUpdateArgs): PluginApiReturn<PluginBuildableEnvelopeUpdateResult>;
-}
-/**
- * Site polygon vertex in the request `lengthUnit`.
- *
- * Vertices may be passed as `{x, z}` objects or `[x, z]` tuples. Numeric
- * values must be finite (no `NaN` or `±Infinity`).
- */
-export declare const PluginBuildableEnvelopePolygonVertex: z.ZodUnion<readonly [z.ZodObject<{
-    x: z.ZodNumber;
-    z: z.ZodNumber;
-}, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
-export type PluginBuildableEnvelopePolygonVertex = z.infer<typeof PluginBuildableEnvelopePolygonVertex>;
-/**
- * Vertical cap for a buildable envelope.
- *
- * Use exactly one shape:
- * - `{ kind: "max_height", maxHeight }`
- * - `{ kind: "max_floors", maxFloors }`
- *
- * Floor-to-floor height is not nested here; it is always supplied as the
- * top-level `floorToFloor` argument.
- */
-export declare const PluginBuildableEnvelopeVerticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"max_height">;
-    maxHeight: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"max_floors">;
-    maxFloors: z.ZodNumber;
-}, z.core.$strict>], "kind">;
-export type PluginBuildableEnvelopeVerticalCap = z.infer<typeof PluginBuildableEnvelopeVerticalCap>;
-/**
- * One tier of a buildable envelope's setback profile.
- *
- * Tiers are ordered by `aboveHeight`. The first tier (index 0) must have
- * `aboveHeight: 0` and describes the ground footprint; each subsequent tier
- * describes the complete setback at a strictly greater height. Each tier
- * carries its own `front`, `side`, and `rear` values — there is no
- * inheritance from earlier tiers.
- *
- * All numeric values must be finite and nonnegative, in the request
- * `lengthUnit`.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `aboveHeight` | `number` | Height at or above which this tier applies; the ground tier uses `0` |
- * | `front` | `number` | Front setback for this tier |
- * | `side` | `number` | Side setback for this tier |
- * | `rear` | `number` | Rear setback for this tier |
- */
-export declare const PluginBuildableEnvelopeSetbackTier: z.ZodObject<{
-    aboveHeight: z.ZodNumber;
-    front: z.ZodNumber;
-    side: z.ZodNumber;
-    rear: z.ZodNumber;
-}, z.core.$strict>;
-export type PluginBuildableEnvelopeSetbackTier = z.infer<typeof PluginBuildableEnvelopeSetbackTier>;
-/**
- * Arguments for {@linkcode PluginBuildableEnvelopeApi.create}.
- *
- * Strict schema. The host owns identity — no `buildableEnvelopeId` is accepted
- * on create; the id is minted by the host and returned in
- * {@linkcode PluginBuildableEnvelopeCreateResult}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
- * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
- * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
- * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
- * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
- * | `farRatio` | `number?` | Optional FAR value, positive when provided |
- * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
- */
-export declare const PluginBuildableEnvelopeCreateArgs: z.ZodObject<{
-    sitePolygon: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        x: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
-    lengthUnit: z.ZodUnion<readonly [z.ZodLiteral<"ft">, z.ZodLiteral<"m">]>;
-    setbacks: z.ZodArray<z.ZodObject<{
-        aboveHeight: z.ZodNumber;
-        front: z.ZodNumber;
-        side: z.ZodNumber;
-        rear: z.ZodNumber;
-    }, z.core.$strict>>;
-    verticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"max_height">;
-        maxHeight: z.ZodNumber;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"max_floors">;
-        maxFloors: z.ZodNumber;
-    }, z.core.$strict>], "kind">;
-    floorToFloor: z.ZodNumber;
-    farRatio: z.ZodOptional<z.ZodNumber>;
-    lotCoverageMaxPct: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type PluginBuildableEnvelopeCreateArgs = z.infer<typeof PluginBuildableEnvelopeCreateArgs>;
-/**
- * Result of {@linkcode PluginBuildableEnvelopeApi.create}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the created buildable envelope |
- */
-export declare const PluginBuildableEnvelopeCreateResult: z.ZodObject<{
-    buildableEnvelopeId: z.ZodString;
-}, z.core.$strict>;
-export type PluginBuildableEnvelopeCreateResult = z.infer<typeof PluginBuildableEnvelopeCreateResult>;
-/**
- * Arguments for {@linkcode PluginBuildableEnvelopeApi.update}.
- *
- * Strict schema. `buildableEnvelopeId` is required and identifies the prior
- * envelope on the canvas to update.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `buildableEnvelopeId` | `string` | Existing envelope ID to update; non-empty |
- * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
- * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
- * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
- * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
- * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
- * | `farRatio` | `number?` | Optional FAR value, positive when provided |
- * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
- */
-export declare const PluginBuildableEnvelopeUpdateArgs: z.ZodObject<{
-    buildableEnvelopeId: z.ZodString;
-    sitePolygon: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        x: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
-    lengthUnit: z.ZodUnion<readonly [z.ZodLiteral<"ft">, z.ZodLiteral<"m">]>;
-    setbacks: z.ZodArray<z.ZodObject<{
-        aboveHeight: z.ZodNumber;
-        front: z.ZodNumber;
-        side: z.ZodNumber;
-        rear: z.ZodNumber;
-    }, z.core.$strict>>;
-    verticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"max_height">;
-        maxHeight: z.ZodNumber;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"max_floors">;
-        maxFloors: z.ZodNumber;
-    }, z.core.$strict>], "kind">;
-    floorToFloor: z.ZodNumber;
-    farRatio: z.ZodOptional<z.ZodNumber>;
-    lotCoverageMaxPct: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type PluginBuildableEnvelopeUpdateArgs = z.infer<typeof PluginBuildableEnvelopeUpdateArgs>;
-/**
- * Result of {@linkcode PluginBuildableEnvelopeApi.update}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the updated buildable envelope |
- */
-export declare const PluginBuildableEnvelopeUpdateResult: z.ZodObject<{
-    buildableEnvelopeId: z.ZodString;
-}, z.core.$strict>;
-export type PluginBuildableEnvelopeUpdateResult = z.infer<typeof PluginBuildableEnvelopeUpdateResult>;
-//# sourceMappingURL=buildableEnvelope.d.ts.map

package/dist/api/entity/buildableEnvelope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildableEnvelope.d.ts","sourceRoot":"","sources":["../../../src/api/entity/buildableEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;GASG;AACH,8BAAsB,0BAA0B;;IAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;aACa,MAAM,CACpB,IAAI,EAAE,iCAAiC,GACtC,eAAe,CAAC,mCAAmC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,MAAM,CACpB,IAAI,EAAE,iCAAiC,GACtC,eAAe,CAAC,mCAAmC,CAAC;CACxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC;;;kEAG/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC;;;;;;4BAS7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kCAAkC;;;;;kBAKpC,CAAA;AAEX,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AA+BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;kBAWZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;kBAYZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA"}

package/dist/api/entity/department.d.ts

@@ -1,99 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-/**
- * Department management — create and query departments.
- *
- * A **department** is a named, colored grouping applied to spaces.
- * Departments are used to categorize spaces by function (e.g. "FOH",
- * "Emergency", "Residential") and control their visual appearance.
- *
- * Accessed via `snaptrude.entity.department`.
- */
-export declare abstract class PluginDepartmentApi {
-    constructor();
-    /**
-     * Create a new department.
-     *
-     * @param args - An object containing:
-     *   - {@linkcode PluginDepartmentCreateArgs.name args.name} — Display name
-     *   - {@linkcode PluginDepartmentCreateArgs.color args.color} — CSS hex color string (e.g. `"#b5e1dc"`)
-     * @returns A {@linkcode PluginDepartmentCreateResult} with the `departmentId`
-     *   of the created department
-     * @throws If department creation fails
-     *
-     * # Example
-     * ```ts
-     * const { departmentId } = await snaptrude.entity.department.create({
-     *   name: "Emergency",
-     *   color: "#f5e68b",
-     * })
-     * ```
-     */
-    abstract create(args: PluginDepartmentCreateArgs): PluginApiReturn<PluginDepartmentCreateResult>;
-    /**
-     * Get all departments in the current project.
-     *
-     * Returns every department including well-known ones (Default, Site, etc.)
-     * and user-created departments.
-     *
-     * @returns A {@linkcode PluginDepartmentGetAllResult} with a `departments` array
-     *
-     * # Example
-     * ```ts
-     * const { departments } = await snaptrude.entity.department.getAll()
-     * for (const dept of departments) {
-     *   console.log(dept.id, dept.name, dept.color)
-     * }
-     * ```
-     */
-    abstract getAll(): PluginApiReturn<PluginDepartmentGetAllResult>;
-}
-/**
- * Arguments for {@linkcode PluginDepartmentApi.create}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `name` | `string` | Display name of the department |
- * | `color` | `string` | CSS hex color string (e.g. `"#b5e1dc"`) |
- */
-export declare const PluginDepartmentCreateArgs: z.ZodObject<{
-    name: z.ZodString;
-    color: z.ZodString;
-}, z.core.$strip>;
-export type PluginDepartmentCreateArgs = z.infer<typeof PluginDepartmentCreateArgs>;
-/**
- * Result of {@linkcode PluginDepartmentApi.create}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `departmentId` | `string` | Unique ID of the created department |
- */
-export declare const PluginDepartmentCreateResult: z.ZodObject<{
-    departmentId: z.ZodString;
-}, z.core.$strip>;
-export type PluginDepartmentCreateResult = z.infer<typeof PluginDepartmentCreateResult>;
-/**
- * A single department entry returned by {@linkcode PluginDepartmentApi.getAll}.
- */
-export declare const PluginDepartmentEntry: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    color: z.ZodString;
-}, z.core.$strip>;
-export type PluginDepartmentEntry = z.infer<typeof PluginDepartmentEntry>;
-/**
- * Result of {@linkcode PluginDepartmentApi.getAll}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `departments` | {@linkcode PluginDepartmentEntry}`[]` | All departments in the project |
- */
-export declare const PluginDepartmentGetAllResult: z.ZodObject<{
-    departments: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        color: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PluginDepartmentGetAllResult = z.infer<typeof PluginDepartmentGetAllResult>;
-//# sourceMappingURL=department.d.ts.map