@snaptrude/plugin-core 0.2.4 → 0.2.5

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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,233 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,99 @@
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"department.d.ts","sourceRoot":"","sources":["../../../src/api/entity/department.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;GAQG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;;;;OAiBG;aACa,MAAM,CACpB,IAAI,EAAE,0BAA0B,GAC/B,eAAe,CAAC,4BAA4B,CAAC;IAEhD;;;;;;;;;;;;;;;OAeG;aACa,MAAM,IAAI,eAAe,CAAC,4BAA4B,CAAC;CACxE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,0BAA0B,CAClC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B;;;;;;iBAEvC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAA"}

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

@@ -0,0 +1,33 @@
+import { PluginBuildableEnvelopeApi } from "./buildableEnvelope";
+import { PluginDepartmentApi } from "./department";
+import { PluginReferenceLineApi } from "./referenceLine";
+import { PluginSpaceApi } from "./space";
+import { PluginStoryApi } from "./story";
+/**
+ * CRUD operations on Snaptrude building entities.
+ *
+ * - {@linkcode PluginEntityApi.space} — Create, query, and delete spaces (rooms/masses)
+ * - {@linkcode PluginEntityApi.story} — Create, query, and update stories (floors)
+ * - {@linkcode PluginEntityApi.referenceLine} — Create, query, and delete reference lines
+ * - {@linkcode PluginEntityApi.department} — Create and query departments
+ * - {@linkcode PluginEntityApi.buildableEnvelope} — Create or update parametric buildable envelopes
+ */
+export declare abstract class PluginEntityApi {
+    /** Space (room/mass) operations. See {@linkcode PluginSpaceApi}. */
+    abstract space: PluginSpaceApi;
+    /** Story (floor/storey) operations. See {@linkcode PluginStoryApi}. */
+    abstract story: PluginStoryApi;
+    /** Reference line operations. See {@linkcode PluginReferenceLineApi}. */
+    abstract referenceLine: PluginReferenceLineApi;
+    /** Department operations. See {@linkcode PluginDepartmentApi}. */
+    abstract department: PluginDepartmentApi;
+    /** Buildable Envelope operations. See {@linkcode PluginBuildableEnvelopeApi}. */
+    abstract buildableEnvelope: PluginBuildableEnvelopeApi;
+    constructor();
+}
+export * from "./buildableEnvelope";
+export * from "./department";
+export * from "./referenceLine";
+export * from "./space";
+export * from "./story";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/entity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;;;;GAQG;AACH,8BAAsB,eAAe;IACnC,oEAAoE;IACpE,SAAgB,KAAK,EAAE,cAAc,CAAA;IACrC,uEAAuE;IACvE,SAAgB,KAAK,EAAE,cAAc,CAAA;IACrC,yEAAyE;IACzE,SAAgB,aAAa,EAAE,sBAAsB,CAAA;IACrD,kEAAkE;IAClE,SAAgB,UAAU,EAAE,mBAAmB,CAAA;IAC/C,iFAAiF;IACjF,SAAgB,iBAAiB,EAAE,0BAA0B,CAAA;;CAG9D;AAED,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}