@elaraai/e3-ui 1.0.97 → 1.0.98

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

@@ -0,0 +1,2289 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+import { ArrayType, BooleanType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, variant } from "@elaraai/east";
+/** A system the floor's equipment and areas belong to: a layer of the drawing, its colour a theme token. */
+export declare const DcSystem: StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: FloatType;
+}>;
+export declare const schematicSystems: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_systems">]>;
+/** The systems' patch door: another session's change of a layer — its colour, say — which the floor redraws. */
+export declare const schematicSystemsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: FloatType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly colour: StringType;
+            readonly order: IntegerType;
+            readonly fixed: BooleanType;
+            readonly dim: FloatType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly colour: StringType;
+            readonly order: IntegerType;
+            readonly fixed: BooleanType;
+            readonly dim: FloatType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly label: StringType;
+            readonly colour: StringType;
+            readonly order: IntegerType;
+            readonly fixed: BooleanType;
+            readonly dim: FloatType;
+        }>;
+        insert: StructType<{
+            readonly label: StringType;
+            readonly colour: StringType;
+            readonly order: IntegerType;
+            readonly fixed: BooleanType;
+            readonly dim: FloatType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly label: StringType;
+                    readonly colour: StringType;
+                    readonly order: IntegerType;
+                    readonly fixed: BooleanType;
+                    readonly dim: FloatType;
+                }>;
+                after: StructType<{
+                    readonly label: StringType;
+                    readonly colour: StringType;
+                    readonly order: IntegerType;
+                    readonly fixed: BooleanType;
+                    readonly dim: FloatType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly label: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly colour: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly order: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+                readonly fixed: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: BooleanType;
+                        after: BooleanType;
+                    }>;
+                }>;
+                readonly dim: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const FloorRack: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>;
+export declare const schematicFloorRacks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_floor_racks">]>;
+/** The floor's racks' patch door: the handover's Save, and another session's moves of a rack, which the floor redraws. */
+export declare const schematicFloorRacksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly kw: FloatType;
+            readonly capacity: FloatType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly kw: FloatType;
+            readonly capacity: FloatType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly kw: FloatType;
+            readonly capacity: FloatType;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly kw: FloatType;
+            readonly capacity: FloatType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly model: StringType;
+                    readonly kw: FloatType;
+                    readonly capacity: FloatType;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly model: StringType;
+                    readonly kw: FloatType;
+                    readonly capacity: FloatType;
+                }>;
+            }>;
+            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 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;
+                    }>;
+                }>;
+                readonly model: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly kw: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly capacity: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicFloor: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * The same hall handed over to its install crew, who move its racks into
+ * place: the racks bound with their patch door, so Move moves them and Del
+ * deletes them, each a step of the history Save writes through it. It is
+ * given no pane — no library and no inspector — so its frame is its toolbar,
+ * its canvas and its footer.
+ */
+export declare const schematicHandover: import("@elaraai/east").ExampleDef<[], any>;
+/** A corner of a unit's outline, about its centre, in metres. */
+export declare const ShapePoint: StructType<{
+    readonly x: FloatType;
+    readonly y: FloatType;
+}>;
+/** A unit, measured as the site measures it: a cooling tower by its radius, a cooling unit by its outline's corners, or by neither. */
+export declare const ShapeUnit: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>;
+/** A corner of an area's edge, about its box's centre; its bulge curves the edge to the next corner (0 is straight). */
+export declare const ShapeCorner: StructType<{
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly bulge: FloatType;
+}>;
+/** What an area is: a hall, outlined, or a duct bank, a hatched band of its width. */
+export declare const ShapeAreaKind: VariantType<{
+    readonly hall: NullType;
+    readonly duct: StructType<{
+        readonly width: FloatType;
+    }>;
+}>;
+/** An area: its box, what it is, and its edge's corners. */
+export declare const ShapeArea: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly hall: NullType;
+        readonly duct: StructType<{
+            readonly width: FloatType;
+        }>;
+    }>;
+    readonly corners: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly bulge: FloatType;
+    }>>;
+    readonly system: StringType;
+}>;
+export declare const schematicShapeUnits: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_shape_units">]>;
+export declare const schematicShapeAreas: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly hall: NullType;
+        readonly duct: StructType<{
+            readonly width: FloatType;
+        }>;
+    }>;
+    readonly corners: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly bulge: FloatType;
+    }>>;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_shape_areas">]>;
+export declare const schematicShapes: import("@elaraai/east").ExampleDef<[], any>;
+/** A rack: placed by its centre, or unplaced until a drop places it. */
+export declare const DcRack: StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>;
+/** A rack's load: what its card's bar, figure and dot draw. */
+export declare const DcLoad: StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>;
+/** A network frame or a power distribution unit. */
+export declare const DcUnit: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>;
+/** A cooling unit: round, drawn by its radius. */
+export declare const DcCooling: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly radius: FloatType;
+    readonly setpoint: FloatType;
+    readonly system: StringType;
+}>;
+/** What an area is: a room or a cage, outlined, or a cold or a hot aisle, hatched. */
+export declare const DcAreaKind: VariantType<{
+    readonly room: NullType;
+    readonly cold: NullType;
+    readonly hot: NullType;
+}>;
+/** A hall, a cage or an aisle. */
+export declare const DcArea: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>;
+/** A fibre run's end: a rack, or a network frame. */
+export declare const DcEnd: VariantType<{
+    readonly rack: StringType;
+    readonly frame: StringType;
+}>;
+/** A bend of a fibre run's path, in metres. */
+export declare const DcPoint: StructType<{
+    readonly x: FloatType;
+    readonly y: FloatType;
+}>;
+/** What a run carries: fibre, drawn solid, or a logical link — management, a cross-connect — drawn dashed. */
+export declare const DcCable: VariantType<{
+    readonly fibre: NullType;
+    readonly logical: NullType;
+}>;
+/** A fibre run between two ends. */
+export declare const DcFibre: StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>;
+/** A power feed: power distribution units feeding racks. */
+export declare const DcFeed: StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: StringType;
+}>;
+/** A fibre trunk: one cable gathering several racks' runs into a frame. */
+export declare const DcTrunk: StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: StringType;
+}>;
+/** What a rack template gives a new rack: every field of a rack but its centre, which the drop places. */
+export declare const DcRackValues: StructType<{
+    readonly name: StringType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>;
+/** A rack template: its card's name and group, and the rack it creates. */
+export declare const DcRackTemplate: StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly values: StructType<{
+        readonly name: StringType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>;
+}>;
+/** What a fibre template gives a run: every field of a run but its ends. */
+export declare const DcFibreValues: StructType<{
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>;
+/** A fibre template: its card's name and system, and what it gives a run. */
+export declare const DcFibreTemplate: StructType<{
+    readonly name: StringType;
+    readonly system: StringType;
+    readonly values: StructType<{
+        readonly path: ArrayType<StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+        }>>;
+        readonly label: OptionType<StringType>;
+        readonly speed: OptionType<StringType>;
+        readonly cable: VariantType<{
+            readonly fibre: NullType;
+            readonly logical: NullType;
+        }>;
+        readonly system: StringType;
+    }>;
+}>;
+/** A tenant of the floor: the owner a rack is let to, and who looks after its racks. */
+export declare const DcOwner: StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>;
+export declare const schematicRacks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_racks">]>;
+export declare const schematicRacksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: OptionType<FloatType>;
+            readonly y: OptionType<FloatType>;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly hall: StringType;
+            readonly system: StringType;
+            readonly owner: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: OptionType<FloatType>;
+            readonly y: OptionType<FloatType>;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly hall: StringType;
+            readonly system: StringType;
+            readonly owner: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly x: OptionType<FloatType>;
+            readonly y: OptionType<FloatType>;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly hall: StringType;
+            readonly system: StringType;
+            readonly owner: StringType;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly x: OptionType<FloatType>;
+            readonly y: OptionType<FloatType>;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly model: StringType;
+            readonly hall: StringType;
+            readonly system: StringType;
+            readonly owner: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly x: OptionType<FloatType>;
+                    readonly y: OptionType<FloatType>;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly model: StringType;
+                    readonly hall: StringType;
+                    readonly system: StringType;
+                    readonly owner: StringType;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly x: OptionType<FloatType>;
+                    readonly y: OptionType<FloatType>;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly model: StringType;
+                    readonly hall: StringType;
+                    readonly system: StringType;
+                    readonly owner: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly name: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly x: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<FloatType>;
+                        after: OptionType<FloatType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly y: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<FloatType>;
+                        after: OptionType<FloatType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: 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;
+                    }>;
+                }>;
+                readonly model: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly hall: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly owner: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicRacksByName: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_name", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, StringType, NullType, readonly ["name"]>;
+export declare const schematicRacksByHall: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_hall", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, StringType, NullType, readonly ["hall"]>;
+export declare const schematicRacksByOwner: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_owner", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, StringType, NullType, readonly ["owner"]>;
+/**
+ * The racks filed by their boxes at a 1 cm cell, for a floor read a window at a time (#1393): what a window reads whatever
+ * the rail chooses, and the racks with no position, under its unplaced clause, which the Backlog pages.
+ */
+export declare const schematicRacksByArea: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_area", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, StructType<Record<never, never> & {
+    __area: IntegerType;
+}>, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>, 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 owners and the window — or the racks with no position — in one read. */
+export declare const schematicRacksByOwnerArea: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_owner_area", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>>, StructType<{
+    owner: StringType;
+} & {
+    __area: IntegerType;
+}>, StructType<{
+    readonly name: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly hall: StringType;
+    readonly system: StringType;
+    readonly owner: StringType;
+}>, readonly ["owner", "__area"]> & {
+    area: import("@elaraai/e3").AreaIndexOf<{
+        readonly on: readonly ["owner"];
+        readonly x: "x";
+        readonly y: "y";
+        readonly width: "w";
+        readonly height: "h";
+        readonly at: "centre";
+        readonly cell: 0.01;
+    }>;
+};
+export declare const schematicRackLoads: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_rack_loads">]>;
+/** The racks' loads' patch door: a rack's capacity edited in the inspector's details. */
+export declare const schematicRackLoadsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        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;
+                    }>;
+                }>;
+            }>;
+            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 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;
+                        }>;
+                    }>;
+                    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;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicFrames: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_frames">]>;
+export declare const schematicPdus: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_pdus">]>;
+export declare const schematicCooling: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly radius: FloatType;
+    readonly setpoint: FloatType;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_cooling">]>;
+export declare const schematicCoolingPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly radius: FloatType;
+    readonly setpoint: FloatType;
+    readonly system: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly radius: FloatType;
+            readonly setpoint: FloatType;
+            readonly system: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly radius: FloatType;
+            readonly setpoint: FloatType;
+            readonly system: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly radius: FloatType;
+            readonly setpoint: FloatType;
+            readonly system: StringType;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly w: FloatType;
+            readonly h: FloatType;
+            readonly radius: FloatType;
+            readonly setpoint: FloatType;
+            readonly system: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly radius: FloatType;
+                    readonly setpoint: FloatType;
+                    readonly system: StringType;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                    readonly w: FloatType;
+                    readonly h: FloatType;
+                    readonly radius: FloatType;
+                    readonly setpoint: FloatType;
+                    readonly system: 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 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;
+                    }>;
+                }>;
+                readonly radius: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly setpoint: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicAreas: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_areas">]>;
+export declare const schematicFibre: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_fibre">]>;
+export declare const schematicFibrePatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>;
+        insert: StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly from: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly path: ArrayType<StructType<{
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                    readonly speed: OptionType<StringType>;
+                    readonly cable: VariantType<{
+                        readonly fibre: NullType;
+                        readonly logical: NullType;
+                    }>;
+                    readonly system: StringType;
+                }>;
+                after: StructType<{
+                    readonly from: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly path: ArrayType<StructType<{
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                    readonly speed: OptionType<StringType>;
+                    readonly cable: VariantType<{
+                        readonly fibre: NullType;
+                        readonly logical: NullType;
+                    }>;
+                    readonly system: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly from: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly rack: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly frame: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly to: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly rack: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly frame: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly path: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StructType<{
+                                readonly x: FloatType;
+                                readonly y: FloatType;
+                            }>;
+                            insert: StructType<{
+                                readonly x: FloatType;
+                                readonly y: FloatType;
+                            }>;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly x: FloatType;
+                                        readonly y: FloatType;
+                                    }>;
+                                    after: StructType<{
+                                        readonly x: FloatType;
+                                        readonly y: FloatType;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly x: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: FloatType;
+                                            after: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly y: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: FloatType;
+                                            after: FloatType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly label: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly speed: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly cable: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly fibre: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly logical: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/**
+ * The fibre runs by system, for a floor whose rail narrows its runs through a source of their own: a run read complete
+ * through its narrowing, a run a draft changed that a choice leaves out waiting in its session (#1391).
+ */
+export declare const schematicFibreBySystem: import("@elaraai/e3").RecordIndexDef<"schematic_fibre_by_system", DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>, StringType, NullType, readonly ["system"]>;
+/** The fibre runs of a floor whose cabling is frozen: the same runs, which no Save changes. */
+export declare const schematicFrozenFibre: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_frozen_fibre">]>;
+/** The frozen floor's door, a checked one: it refuses every change, naming why — what a Save over it is answered. */
+export declare const schematicFrozenFibrePatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>;
+        insert: StructType<{
+            readonly from: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly rack: StringType;
+                readonly frame: StringType;
+            }>;
+            readonly path: ArrayType<StructType<{
+                readonly x: FloatType;
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly speed: OptionType<StringType>;
+            readonly cable: VariantType<{
+                readonly fibre: NullType;
+                readonly logical: NullType;
+            }>;
+            readonly system: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly from: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly path: ArrayType<StructType<{
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                    readonly speed: OptionType<StringType>;
+                    readonly cable: VariantType<{
+                        readonly fibre: NullType;
+                        readonly logical: NullType;
+                    }>;
+                    readonly system: StringType;
+                }>;
+                after: StructType<{
+                    readonly from: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly to: VariantType<{
+                        readonly rack: StringType;
+                        readonly frame: StringType;
+                    }>;
+                    readonly path: ArrayType<StructType<{
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                    }>>;
+                    readonly label: OptionType<StringType>;
+                    readonly speed: OptionType<StringType>;
+                    readonly cable: VariantType<{
+                        readonly fibre: NullType;
+                        readonly logical: NullType;
+                    }>;
+                    readonly system: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly from: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly rack: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly frame: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly to: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly rack: StringType;
+                            readonly frame: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly rack: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly frame: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly path: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StructType<{
+                                readonly x: FloatType;
+                                readonly y: FloatType;
+                            }>;
+                            insert: StructType<{
+                                readonly x: FloatType;
+                                readonly y: FloatType;
+                            }>;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly x: FloatType;
+                                        readonly y: FloatType;
+                                    }>;
+                                    after: StructType<{
+                                        readonly x: FloatType;
+                                        readonly y: FloatType;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly x: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: FloatType;
+                                            after: FloatType;
+                                        }>;
+                                    }>;
+                                    readonly y: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: FloatType;
+                                            after: FloatType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly label: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly speed: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly cable: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly fibre: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly logical: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicFeeds: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_feeds">]>;
+export declare const schematicFeedsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly supply: ArrayType<StringType>;
+            readonly racks: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly load: StringType;
+            readonly system: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly supply: ArrayType<StringType>;
+            readonly racks: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly load: StringType;
+            readonly system: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly supply: ArrayType<StringType>;
+            readonly racks: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly load: StringType;
+            readonly system: StringType;
+        }>;
+        insert: StructType<{
+            readonly supply: ArrayType<StringType>;
+            readonly racks: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly load: StringType;
+            readonly system: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly supply: ArrayType<StringType>;
+                    readonly racks: ArrayType<StringType>;
+                    readonly label: StringType;
+                    readonly load: StringType;
+                    readonly system: StringType;
+                }>;
+                after: StructType<{
+                    readonly supply: ArrayType<StringType>;
+                    readonly racks: ArrayType<StringType>;
+                    readonly label: StringType;
+                    readonly load: StringType;
+                    readonly system: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly supply: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StringType>;
+                        after: ArrayType<StringType>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StringType;
+                            insert: StringType;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly racks: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StringType>;
+                        after: ArrayType<StringType>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StringType;
+                            insert: StringType;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly label: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly load: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The floor's fibre trunks: none yet — a Shift-connect from racks to a frame gathers their runs into one. */
+export declare const schematicTrunks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_trunks">]>;
+export declare const schematicTrunksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly racks: ArrayType<StringType>;
+            readonly frames: ArrayType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly system: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly racks: ArrayType<StringType>;
+            readonly frames: ArrayType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly system: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly racks: ArrayType<StringType>;
+            readonly frames: ArrayType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly system: StringType;
+        }>;
+        insert: StructType<{
+            readonly racks: ArrayType<StringType>;
+            readonly frames: ArrayType<StringType>;
+            readonly label: OptionType<StringType>;
+            readonly system: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly racks: ArrayType<StringType>;
+                    readonly frames: ArrayType<StringType>;
+                    readonly label: OptionType<StringType>;
+                    readonly system: StringType;
+                }>;
+                after: StructType<{
+                    readonly racks: ArrayType<StringType>;
+                    readonly frames: ArrayType<StringType>;
+                    readonly label: OptionType<StringType>;
+                    readonly system: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly racks: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StringType>;
+                        after: ArrayType<StringType>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StringType;
+                            insert: StringType;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly frames: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StringType>;
+                        after: ArrayType<StringType>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StringType;
+                            insert: StringType;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly label: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly system: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const schematicRackTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly values: StructType<{
+        readonly name: StringType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_rack_templates">]>;
+export declare const schematicRackTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"schematic_rack_templates_by_group", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly values: StructType<{
+        readonly name: StringType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>;
+}>>, StringType, NullType, readonly ["group"]>;
+export declare const schematicFibreTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly system: StringType;
+    readonly values: StructType<{
+        readonly path: ArrayType<StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+        }>>;
+        readonly label: OptionType<StringType>;
+        readonly speed: OptionType<StringType>;
+        readonly cable: VariantType<{
+            readonly fibre: NullType;
+            readonly logical: NullType;
+        }>;
+        readonly system: StringType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_fibre_templates">]>;
+export declare const schematicFibreTemplatesBySystem: import("@elaraai/e3").RecordIndexDef<"schematic_fibre_templates_by_system", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly system: StringType;
+    readonly values: StructType<{
+        readonly path: ArrayType<StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+        }>>;
+        readonly label: OptionType<StringType>;
+        readonly speed: OptionType<StringType>;
+        readonly cable: VariantType<{
+            readonly fibre: NullType;
+            readonly logical: NullType;
+        }>;
+        readonly system: StringType;
+    }>;
+}>>, StringType, NullType, readonly ["system"]>;
+export declare const schematicOwners: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_owners">]>;
+export declare const schematicDataCentre: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=schematic.examples.d.ts.map