@pascal-app/core 1.0.4 → 1.0.5

package/dist/schema/nodes/item.d.ts

@@ -12,9 +12,9 @@ declare const sliderControlSchema: z.ZodObject<{
     step: z.ZodDefault<z.ZodNumber>;
     unit: z.ZodOptional<z.ZodString>;
     displayMode: z.ZodDefault<z.ZodEnum<{
+        dial: "dial";
         slider: "slider";
         stepper: "stepper";
-        dial: "dial";
     }>>;
     default: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -41,9 +41,9 @@ declare const controlSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     step: z.ZodDefault<z.ZodNumber>;
     unit: z.ZodOptional<z.ZodString>;
     displayMode: z.ZodDefault<z.ZodEnum<{
+        dial: "dial";
         slider: "slider";
         stepper: "stepper";
-        dial: "dial";
     }>>;
     default: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
@@ -109,9 +109,9 @@ declare const interactiveSchema: z.ZodObject<{
         step: z.ZodDefault<z.ZodNumber>;
         unit: z.ZodOptional<z.ZodString>;
         displayMode: z.ZodDefault<z.ZodEnum<{
+            dial: "dial";
             slider: "slider";
             stepper: "stepper";
-            dial: "dial";
         }>>;
         default: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -160,16 +160,16 @@ declare const assetSchema: z.ZodObject<{
     thumbnail: z.ZodString;
     floorPlanUrl: z.ZodOptional<z.ZodString>;
     source: z.ZodDefault<z.ZodEnum<{
-        library: "library";
         community: "community";
+        library: "library";
         mine: "mine";
     }>>;
     isDraft: z.ZodOptional<z.ZodBoolean>;
     src: z.ZodString;
     dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     attachTo: z.ZodOptional<z.ZodEnum<{
-        wall: "wall";
         ceiling: "ceiling";
+        wall: "wall";
         "wall-side": "wall-side";
     }>>;
     recessed: z.ZodOptional<z.ZodBoolean>;
@@ -194,9 +194,9 @@ declare const assetSchema: z.ZodObject<{
             step: z.ZodDefault<z.ZodNumber>;
             unit: z.ZodOptional<z.ZodString>;
             displayMode: z.ZodDefault<z.ZodEnum<{
+                dial: "dial";
                 slider: "slider";
                 stepper: "stepper";
-                dial: "dial";
             }>>;
             default: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
@@ -242,8 +242,8 @@ export declare const ItemNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -254,23 +254,23 @@ export declare const ItemNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
@@ -281,18 +281,18 @@ export declare const ItemNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
-        front: "front";
         back: "back";
+        front: "front";
     }>>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     wallId: z.ZodOptional<z.ZodString>;
     wallT: z.ZodOptional<z.ZodNumber>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     roofFace: z.ZodOptional<z.ZodEnum<{
+        back: "back";
+        front: "front";
         left: "left";
         right: "right";
-        front: "front";
-        back: "back";
     }>>;
     blockFaceId: z.ZodOptional<z.ZodString>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -307,8 +307,8 @@ export declare const ItemNode: z.ZodObject<{
             parent: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         language: z.ZodDefault<z.ZodEnum<{
-            three: "three";
             bpy: "bpy";
+            three: "three";
         }>>;
         script: z.ZodString;
         params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
@@ -322,9 +322,9 @@ export declare const ItemNode: z.ZodObject<{
                 id: z.ZodString;
                 label: z.ZodOptional<z.ZodString>;
                 kind: z.ZodEnum<{
-                    string: "string";
-                    number: "number";
                     boolean: "boolean";
+                    number: "number";
+                    string: "string";
                 }>;
                 default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
                 min: z.ZodOptional<z.ZodNumber>;
@@ -379,10 +379,10 @@ export declare const ItemNode: z.ZodObject<{
             }, z.core.$strip>>>;
             cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 host: z.ZodEnum<{
-                    wall: "wall";
-                    slab: "slab";
                     ceiling: "ceiling";
                     mounted: "mounted";
+                    slab: "slab";
+                    wall: "wall";
                 }>;
                 polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
                 minY: z.ZodNumber;
@@ -391,6 +391,11 @@ export declare const ItemNode: z.ZodObject<{
             cutout: z.ZodDefault<z.ZodBoolean>;
             collider: z.ZodDefault<z.ZodBoolean>;
             triangles: z.ZodNumber;
+            coverage: z.ZodOptional<z.ZodNumber>;
+            uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         images: z.ZodOptional<z.ZodObject<{
             artifact: z.ZodString;
@@ -405,16 +410,16 @@ export declare const ItemNode: z.ZodObject<{
         thumbnail: z.ZodString;
         floorPlanUrl: z.ZodOptional<z.ZodString>;
         source: z.ZodDefault<z.ZodEnum<{
-            library: "library";
             community: "community";
+            library: "library";
             mine: "mine";
         }>>;
         isDraft: z.ZodOptional<z.ZodBoolean>;
         src: z.ZodString;
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
-            wall: "wall";
             ceiling: "ceiling";
+            wall: "wall";
             "wall-side": "wall-side";
         }>>;
         recessed: z.ZodOptional<z.ZodBoolean>;
@@ -439,9 +444,9 @@ export declare const ItemNode: z.ZodObject<{
                 step: z.ZodDefault<z.ZodNumber>;
                 unit: z.ZodOptional<z.ZodString>;
                 displayMode: z.ZodDefault<z.ZodEnum<{
+                    dial: "dial";
                     slider: "slider";
                     stepper: "stepper";
-                    dial: "dial";
                 }>>;
                 default: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>, z.ZodObject<{

package/dist/schema/nodes/item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAezB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAezB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}

package/dist/schema/nodes/lean-to-extension.d.ts

@@ -1,23 +1,23 @@
 import { z } from 'zod';
 export declare const LeanToConnectionMode: z.ZodEnum<{
-    manual: "manual";
     auto: "auto";
+    manual: "manual";
 }>;
 export declare const LeanToCanopyForm: z.ZodEnum<{
+    butterfly: "butterfly";
     gable: "gable";
     mono: "mono";
-    butterfly: "butterfly";
 }>;
 export declare const LeanToHostKind: z.ZodEnum<{
-    wall: "wall";
-    "slab-edge": "slab-edge";
-    freestanding: "freestanding";
     "conical-roof": "conical-roof";
+    freestanding: "freestanding";
+    "slab-edge": "slab-edge";
+    wall: "wall";
 }>;
 export declare const LeanToRoofEdge: z.ZodEnum<{
     "+X": "+X";
-    "-X": "-X";
     "+Z": "+Z";
+    "-X": "-X";
     "-Z": "-Z";
 }>;
 export declare const LeanToResizeLock: z.ZodEnum<{
@@ -26,33 +26,33 @@ export declare const LeanToResizeLock: z.ZodEnum<{
     "preserve-pitch": "preserve-pitch";
 }>;
 export declare const LeanToEndCondition: z.ZodEnum<{
+    joined: "joined";
     open: "open";
     "wall-abutment": "wall-abutment";
-    joined: "joined";
 }>;
 export declare const LeanToFramingStrategy: z.ZodEnum<{
+    "covering-specific": "covering-specific";
     hidden: "hidden";
-    rafters: "rafters";
     purlins: "purlins";
-    "covering-specific": "covering-specific";
+    rafters: "rafters";
 }>;
 export declare const LeanToHighSideMode: z.ZodEnum<{
-    "wall-ledger": "wall-ledger";
     "independent-high-beam": "independent-high-beam";
+    "wall-ledger": "wall-ledger";
 }>;
 export declare const LeanToPostLayoutMode: z.ZodEnum<{
     count: "count";
     "target-spacing": "target-spacing";
 }>;
 export declare const LeanToFootingStyle: z.ZodEnum<{
-    none: "none";
     "base-plate": "base-plate";
     "concrete-pad": "concrete-pad";
+    none: "none";
 }>;
 export declare const LeanToCoveringType: z.ZodEnum<{
     generic: "generic";
-    shingle: "shingle";
     "metal-panel": "metal-panel";
+    shingle: "shingle";
 }>;
 export type LeanToConnectionMode = z.infer<typeof LeanToConnectionMode>;
 export type LeanToCanopyForm = z.infer<typeof LeanToCanopyForm>;
@@ -66,8 +66,8 @@ export declare const LeanToExtensionNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -78,23 +78,23 @@ export declare const LeanToExtensionNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
@@ -105,15 +105,15 @@ export declare const LeanToExtensionNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>]>>>;
     canopyForm: z.ZodDefault<z.ZodEnum<{
+        butterfly: "butterfly";
         gable: "gable";
         mono: "mono";
-        butterfly: "butterfly";
     }>>;
     hostKind: z.ZodDefault<z.ZodEnum<{
-        wall: "wall";
-        "slab-edge": "slab-edge";
-        freestanding: "freestanding";
         "conical-roof": "conical-roof";
+        freestanding: "freestanding";
+        "slab-edge": "slab-edge";
+        wall: "wall";
     }>>;
     hostHeightOffset: z.ZodDefault<z.ZodNumber>;
     hostSlabId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>>;
@@ -133,14 +133,14 @@ export declare const LeanToExtensionNode: z.ZodObject<{
         "preserve-pitch": "preserve-pitch";
     }>>;
     leftEndCondition: z.ZodDefault<z.ZodEnum<{
+        joined: "joined";
         open: "open";
         "wall-abutment": "wall-abutment";
-        joined: "joined";
     }>>;
     rightEndCondition: z.ZodDefault<z.ZodEnum<{
+        joined: "joined";
         open: "open";
         "wall-abutment": "wall-abutment";
-        joined: "joined";
     }>>;
     autoMiterCorners: z.ZodDefault<z.ZodBoolean>;
     sideFlashing: z.ZodDefault<z.ZodBoolean>;
@@ -148,30 +148,30 @@ export declare const LeanToExtensionNode: z.ZodObject<{
     flashingHeight: z.ZodDefault<z.ZodNumber>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     highSideMode: z.ZodDefault<z.ZodEnum<{
-        "wall-ledger": "wall-ledger";
         "independent-high-beam": "independent-high-beam";
+        "wall-ledger": "wall-ledger";
     }>>;
     ledgerVerticalOffset: z.ZodDefault<z.ZodNumber>;
     lowBeamInset: z.ZodDefault<z.ZodNumber>;
     gutterEnabled: z.ZodDefault<z.ZodBoolean>;
     gutterProfile: z.ZodDefault<z.ZodEnum<{
         box: "box";
-        "k-style": "k-style";
         "half-round": "half-round";
+        "k-style": "k-style";
     }>>;
     gutterSize: z.ZodDefault<z.ZodNumber>;
     downspoutEnabled: z.ZodDefault<z.ZodBoolean>;
     downspoutPosition: z.ZodDefault<z.ZodNumber>;
     connectionMode: z.ZodDefault<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     hostRoofId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>>;
     hostRoofSegmentId: z.ZodOptional<z.ZodString>;
     hostRoofEdge: z.ZodOptional<z.ZodEnum<{
         "+X": "+X";
-        "-X": "-X";
         "+Z": "+Z";
+        "-X": "-X";
         "-Z": "-Z";
     }>>;
     hostRoofEdgeRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
@@ -187,8 +187,8 @@ export declare const LeanToExtensionNode: z.ZodObject<{
     rightOverhang: z.ZodDefault<z.ZodNumber>;
     coveringType: z.ZodDefault<z.ZodEnum<{
         generic: "generic";
-        shingle: "shingle";
         "metal-panel": "metal-panel";
+        shingle: "shingle";
     }>>;
     beamWidth: z.ZodDefault<z.ZodNumber>;
     beamHeight: z.ZodDefault<z.ZodNumber>;
@@ -199,10 +199,10 @@ export declare const LeanToExtensionNode: z.ZodObject<{
     rafterSpacing: z.ZodDefault<z.ZodNumber>;
     rafterEndInset: z.ZodDefault<z.ZodNumber>;
     framingStrategy: z.ZodDefault<z.ZodEnum<{
+        "covering-specific": "covering-specific";
         hidden: "hidden";
-        rafters: "rafters";
         purlins: "purlins";
-        "covering-specific": "covering-specific";
+        rafters: "rafters";
     }>>;
     purlinWidth: z.ZodDefault<z.ZodNumber>;
     purlinHeight: z.ZodDefault<z.ZodNumber>;
@@ -218,20 +218,20 @@ export declare const LeanToExtensionNode: z.ZodObject<{
     postInset: z.ZodDefault<z.ZodNumber>;
     omittedPostSlots: z.ZodDefault<z.ZodArray<z.ZodObject<{
         side: z.ZodEnum<{
-            low: "low";
             high: "high";
+            low: "low";
         }>;
         index: z.ZodNumber;
         layoutCount: z.ZodNumber;
     }, z.core.$strip>>>;
     postBracing: z.ZodDefault<z.ZodEnum<{
-        none: "none";
         knee: "knee";
+        none: "none";
     }>>;
     footingStyle: z.ZodDefault<z.ZodEnum<{
-        none: "none";
         "base-plate": "base-plate";
         "concrete-pad": "concrete-pad";
+        none: "none";
     }>>;
 }, z.core.$strip>;
 export type LeanToExtensionNode = z.infer<typeof LeanToExtensionNode>;

package/dist/schema/nodes/level.d.ts

@@ -10,8 +10,8 @@ export declare const LevelNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -22,30 +22,30 @@ export declare const LevelNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `separator_${string}` | `floor-opening_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`, string>>>>;
     level: z.ZodDefault<z.ZodNumber>;
     baseElevation: z.ZodDefault<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;

package/dist/schema/nodes/lineset.d.ts

@@ -23,8 +23,8 @@ export declare const LinesetNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -35,23 +35,23 @@ export declare const LinesetNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;

package/dist/schema/nodes/liquid-line.d.ts

@@ -17,8 +17,8 @@ export declare const LiquidLineNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -29,23 +29,23 @@ export declare const LiquidLineNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;

package/dist/schema/nodes/measurement.d.ts

@@ -200,8 +200,8 @@ export declare const MeasurementNode: z.ZodObject<{
         position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         mode: z.ZodDefault<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
@@ -212,23 +212,23 @@ export declare const MeasurementNode: z.ZodObject<{
             ns: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             role: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                piece: "piece";
                 absorbed: "absorbed";
                 alias: "alias";
                 derived: "derived";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;

package/dist/schema/nodes/opening-types.d.ts

@@ -2,21 +2,21 @@ import { z } from 'zod';
 /** Opening kinds, in a file with no other dependency: facade units and agent tool contracts
  * validate against them without loading the node schemas. */
 export declare const DoorType: z.ZodEnum<{
+    barn: "barn";
     double: "double";
-    hinged: "hinged";
-    french: "french";
     folding: "folding";
-    pocket: "pocket";
-    barn: "barn";
-    sliding: "sliding";
-    "garage-sectional": "garage-sectional";
+    french: "french";
     "garage-rollup": "garage-rollup";
+    "garage-sectional": "garage-sectional";
     "garage-tiltup": "garage-tiltup";
+    hinged: "hinged";
+    pocket: "pocket";
+    sliding: "sliding";
 }>;
 export type DoorType = z.infer<typeof DoorType>;
 /** A new door's leaf, two raised panels stacked: the Panel style, fresh on every call. */
 export declare const defaultDoorSegments: () => {
-    type: "panel";
+    type: 'panel';
     heightRatio: number;
     columnRatios: number[];
     dividerThickness: number;
@@ -26,16 +26,16 @@ export declare const defaultDoorSegments: () => {
 /** A new door's leaf margin [x, y] (m). */
 export declare const DEFAULT_DOOR_CONTENT_PADDING: [number, number];
 export declare const WindowType: z.ZodEnum<{
-    fixed: "fixed";
-    sliding: "sliding";
-    casement: "casement";
     awning: "awning";
-    hopper: "hopper";
-    "single-hung": "single-hung";
-    "double-hung": "double-hung";
     bay: "bay";
     bow: "bow";
+    casement: "casement";
+    "double-hung": "double-hung";
+    fixed: "fixed";
+    hopper: "hopper";
     louvered: "louvered";
+    "single-hung": "single-hung";
+    sliding: "sliding";
 }>;
 export type WindowType = z.infer<typeof WindowType>;
 //# sourceMappingURL=opening-types.d.ts.map