@elaraai/e3-ui 1.0.98 → 1.0.100

package/dist/test/schematic/schematic-records.examples.d.ts

@@ -83,9 +83,54 @@ export declare const schematicStressRacks: import("@elaraai/e3").RecordDef<DictT
     readonly y: FloatType;
     readonly w: FloatType;
     readonly h: FloatType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_stress_racks">]>;
-/** The racks' patch door: each Save of the floor writes through it, and the budget run fills the floor through it. */
-export declare const schematicStressRacksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_racks">], import("@elaraai/e3").IndexesOf<{
+    schematic_stress_racks_by_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly hall: StringType;
+        readonly model: StringType;
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly [], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+    schematic_stress_racks_by_hall_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            hall: StringType;
+        }>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly hall: StringType;
+        readonly model: StringType;
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly ["hall"], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly on: readonly ["hall"];
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+    schematic_stress_racks_by_model: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["model"], unknown>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly hall: StringType;
     readonly model: StringType;
@@ -93,186 +138,125 @@ export declare const schematicStressRacksPatch: import("@elaraai/e3").MutationDe
     readonly y: FloatType;
     readonly w: FloatType;
     readonly h: FloatType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly hall: StringType;
-            readonly model: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly hall: StringType;
-            readonly model: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly hall: StringType;
-            readonly model: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
         }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly hall: StringType;
-            readonly model: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly hall: StringType;
-                    readonly model: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly hall: StringType;
-                    readonly model: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
             }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly hall: StringType;
+                        readonly model: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
                     }>;
-                }>;
-                readonly hall: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly hall: StringType;
+                        readonly model: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
                     }>;
                 }>;
-                readonly model: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly x: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly hall: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly y: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly model: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly w: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly h: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The window, whatever the rail chooses: every rack filed once by its box, at a 1 cm cell. */
-export declare const schematicStressRacksByArea: import("@elaraai/e3").RecordIndexDef<"schematic_stress_racks_by_area", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly hall: StringType;
-    readonly model: StringType;
-    readonly x: FloatType;
-    readonly y: FloatType;
-    readonly w: FloatType;
-    readonly h: FloatType;
-}>>, StructType<Record<never, never> & {
-    __area: IntegerType;
-}>, StructType<{
-    readonly name: StringType;
-    readonly hall: StringType;
-    readonly model: StringType;
-    readonly x: FloatType;
-    readonly y: FloatType;
-    readonly w: FloatType;
-    readonly h: FloatType;
-}>, readonly ["__area"]> & {
-    area: import("@elaraai/e3").AreaIndexOf<{
-        readonly x: "x";
-        readonly y: "y";
-        readonly width: "w";
-        readonly height: "h";
-        readonly at: "centre";
-        readonly cell: 0.01;
-    }>;
-};
-/** Beside it, a choice of halls and the window in one read. */
-export declare const schematicStressRacksByHallArea: import("@elaraai/e3").RecordIndexDef<"schematic_stress_racks_by_hall_area", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly hall: StringType;
-    readonly model: StringType;
-    readonly x: FloatType;
-    readonly y: FloatType;
-    readonly w: FloatType;
-    readonly h: FloatType;
-}>>, StructType<{
-    hall: StringType;
-} & {
-    __area: IntegerType;
-}>, StructType<{
-    readonly name: StringType;
-    readonly hall: StringType;
-    readonly model: StringType;
-    readonly x: FloatType;
-    readonly y: FloatType;
-    readonly w: FloatType;
-    readonly h: FloatType;
-}>, readonly ["hall", "__area"]> & {
-    area: import("@elaraai/e3").AreaIndexOf<{
-        readonly on: readonly ["hall"];
-        readonly x: "x";
-        readonly y: "y";
-        readonly width: "w";
-        readonly height: "h";
-        readonly at: "centre";
-        readonly cell: 0.01;
-    }>;
-};
-/** A choice no area index leads: a window under it asks which of its racks the choice holds. */
-export declare const schematicStressRacksByModel: import("@elaraai/e3").RecordIndexDef<"schematic_stress_racks_by_model", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly hall: StringType;
     readonly model: StringType;
@@ -280,7 +264,7 @@ export declare const schematicStressRacksByModel: import("@elaraai/e3").RecordIn
     readonly y: FloatType;
     readonly w: FloatType;
     readonly h: FloatType;
-}>>, StringType, NullType, readonly ["model"]>;
+}>>>>;
 export declare const schematicStressRackLoads: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly kw: FloatType;
     readonly capacity: FloatType;
@@ -289,9 +273,7 @@ export declare const schematicStressRackLoads: import("@elaraai/e3").RecordDef<D
         readonly warm: NullType;
         readonly hot: NullType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "schematic_stress_rack_loads">]>;
-/** The loads' patch door: the budget run fills them through it, keyed as the racks it fills. */
-export declare const schematicStressRackLoadsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_rack_loads">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly kw: FloatType;
     readonly capacity: FloatType;
     readonly alarm: VariantType<{
@@ -299,126 +281,136 @@ export declare const schematicStressRackLoadsPatch: import("@elaraai/e3").Mutati
         readonly warm: NullType;
         readonly hot: NullType;
     }>;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>;
-        insert: StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                    readonly alarm: VariantType<{
-                        readonly ok: NullType;
-                        readonly warm: NullType;
-                        readonly hot: NullType;
-                    }>;
-                }>;
-                after: StructType<{
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                    readonly alarm: VariantType<{
-                        readonly ok: NullType;
-                        readonly warm: NullType;
-                        readonly hot: NullType;
-                    }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
-            }>;
-            patch: StructType<{
-                readonly kw: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
-                    }>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
-                readonly capacity: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
-                    }>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
+            }>;
+            insert: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
                 readonly alarm: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
                             readonly ok: NullType;
                             readonly warm: NullType;
                             readonly hot: NullType;
                         }>;
-                        after: VariantType<{
+                    }>;
+                    after: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
                             readonly ok: NullType;
                             readonly warm: NullType;
                             readonly hot: NullType;
                         }>;
                     }>;
-                    patch: VariantType<{
-                        readonly ok: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                }>;
+                patch: StructType<{
+                    readonly kw: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly capacity: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
                         }>;
-                        readonly warm: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                    }>;
+                    readonly alarm: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
                             }>;
                         }>;
-                        readonly hot: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            readonly ok: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly warm: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly hot: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>>>;
 /** A rack joined to another across the floor. */
 export declare const StressUplink: StructType<{
     readonly from: StringType;
@@ -431,14 +423,32 @@ export declare const StressUplink: StructType<{
 export declare const schematicStressUplinks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly from: StringType;
     readonly to: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_stress_uplinks">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_uplinks">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>>>>;
 export declare const schematicStressHalls: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
     readonly y: FloatType;
     readonly w: FloatType;
     readonly h: FloatType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_stress_halls">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_halls">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>>;
 export declare const schematicRecordIndexes: import("@elaraai/east").ExampleDef<[], any>;
 export declare const schematicRecordIndexesMobile: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=schematic-records.examples.d.ts.map

package/dist/test/schematic/schematic-records.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schematic-records.examples.d.ts","sourceRoot":"","sources":["../../../test/schematic/schematic-records.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EAAa,QAAQ,EAAQ,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAiB,OAAO,EAAE,MAAM,eAAe,CAAC;AAmBzJ,6FAA6F;AAC7F,eAAO,MAAM,UAAU;;;;;;;;EAAgI,CAAC;AACxJ,2BAA2B;AAC3B,eAAO,MAAM,WAAW;;;;EAA+D,CAAC;AACxF,+DAA+D;AAC/D,eAAO,MAAM,UAAU;;;;;;;;EAAyE,CAAC;AACjG,iDAAiD;AACjD,eAAO,MAAM,UAAU;;;;;;EAA2F,CAAC;AAKnH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;IAoBxB,CAAC;AAEH,wJAAwJ;AACxJ,eAAO,MAAM,aAAa;;;;;;;;IAYxB,CAAC;AAEH,eAAO,MAAM,wBAAwB,8HAAiF,CAAC;AACvH,eAAO,MAAM,6BAA6B;;;;;;;;mHAAyF,CAAC;AACpI,eAAO,MAAM,oBAAoB;;;;;;;;+EAA4F,CAAC;AAC9H,sHAAsH;AACtH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA0C,CAAC;AACjF,+FAA+F;AAC/F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAErC,CAAC;AACH,+DAA+D;AAC/D,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEzC,CAAC;AACH,gGAAgG;AAChG,eAAO,MAAM,2BAA2B;;;;;;;;8CAA6F,CAAC;AACtI,eAAO,MAAM,wBAAwB;;;;;;;;oFAAiG,CAAC;AACvI,gGAAgG;AAChG,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA8C,CAAC;AACzF,iDAAiD;AACjD,eAAO,MAAM,YAAY;;;EAAmD,CAAC;AAC7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;iFAKhC,CAAC;AACJ,eAAO,MAAM,oBAAoB;;;;;;+EAW9B,CAAC;AAEJ,eAAO,MAAM,sBAAsB,6CAuDjC,CAAC;AAEH,eAAO,MAAM,4BAA4B,6CAwDvC,CAAC"}
+{"version":3,"file":"schematic-records.examples.d.ts","sourceRoot":"","sources":["../../../test/schematic/schematic-records.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EAAa,QAAQ,EAAQ,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAiB,OAAO,EAAE,MAAM,eAAe,CAAC;AAmBzJ,6FAA6F;AAC7F,eAAO,MAAM,UAAU;;;;;;;;EAAgI,CAAC;AACxJ,2BAA2B;AAC3B,eAAO,MAAM,WAAW;;;;EAA+D,CAAC;AACxF,+DAA+D;AAC/D,eAAO,MAAM,UAAU;;;;;;;;EAAyE,CAAC;AACjG,iDAAiD;AACjD,eAAO,MAAM,UAAU;;;;;;EAA2F,CAAC;AAKnH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;IAoBxB,CAAC;AAEH,wJAAwJ;AACxJ,eAAO,MAAM,aAAa;;;;;;;;IAYxB,CAAC;AAEH,eAAO,MAAM,wBAAwB,8HAAiF,CAAC;AACvH,eAAO,MAAM,6BAA6B;;;;;;;;mHAAyF,CAAC;AACpI,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkB/B,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMnC,CAAC;AACH,iDAAiD;AACjD,eAAO,MAAM,YAAY;;;EAAmD,CAAC;AAC7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;KAOjC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;KAa/B,CAAC;AAEH,eAAO,MAAM,sBAAsB,6CAuDjC,CAAC;AAEH,eAAO,MAAM,4BAA4B,6CAwDvC,CAAC"}