@elaraai/e3-ui 1.0.97 → 1.0.99

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

@@ -0,0 +1,2640 @@
+/**
+ * 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">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: 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">], import("@elaraai/e3").IndexesOf<{
+    schematic_floor_racks_by_model: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["model"], unknown>;
+}, 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;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, 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;
+}>>>>;
+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">], 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;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>>>, 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;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>>>>;
+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">], 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;
+    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;
+}>>>, 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;
+    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 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">], import("@elaraai/e3").IndexesOf<{
+    schematic_racks_by_name: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+    schematic_racks_by_hall: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["hall"], unknown>;
+    schematic_racks_by_owner: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["owner"], unknown>;
+    schematic_racks_by_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: 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 [], {
+        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_racks_by_owner_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: 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"], {
+        readonly 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;
+        }>;
+    }>;
+}, 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;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, 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;
+}>>>>;
+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">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, 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;
+                }>;
+            }>>;
+            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;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: 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">], 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;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>, 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;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>>;
+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">], 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;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>, 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;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>>;
+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">], 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;
+    readonly radius: FloatType;
+    readonly setpoint: FloatType;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, 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;
+}>>>>;
+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">], 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;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>>>, 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;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>>>>;
+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">], import("@elaraai/e3").IndexesOf<{
+    schematic_fibre_by_system: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["system"], unknown>;
+}, 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;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, 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;
+}>>>>;
+/** 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">], import("@elaraai/e3").IndexesOf<Record<never, never>, 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;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, 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;
+}>>>>;
+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">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: 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">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: 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">], import("@elaraai/e3").IndexesOf<{
+    schematic_rack_templates_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+}, 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;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, 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;
+    }>;
+}>>>>;
+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">], import("@elaraai/e3").IndexesOf<{
+    schematic_fibre_templates_by_system: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["system"], unknown>;
+}, 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;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, 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;
+    }>;
+}>>>>;
+export declare const schematicOwners: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_owners">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>>>;
+export declare const schematicDataCentre: import("@elaraai/east").ExampleDef<[], any>;
+/** The racks the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export declare const schematicConflictRacks: 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_conflict_racks">], 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;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+    elsewhere: import("@elaraai/e3").MutationDraft<[]>;
+}, 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;
+}>>>>;
+/**
+ * Your edits meeting someone else's save, in one window: edit, then press
+ * Someone else saves, which saves another person's change to the same racks —
+ * every rack half a metre to the right. A rack you moved sideways too is a
+ * conflict, waiting for you to choose; a rack you moved only up or down, or
+ * whose fields you changed in the panel, combines with theirs. Each press
+ * saves their change again.
+ */
+export declare const schematicConflicts: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=schematic.examples.d.ts.map