@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/plan/plan-nested.examples.d.ts

@@ -0,0 +1,1829 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+/**
+ * The works, whose rows nest every collection a Plan reads a cell at a time
+ * (#1438), with their nested series index (#1434): each works' jobs and
+ * alarms, its load, its crews' hours and a tree of parts, over ten years,
+ * sparse and spread evenly over them; and the task that generates them from
+ * their sizes. And the Plan over them (#1439):
+ *
+ * - `planNestedAll`, every series kind over the works — span, heat, table,
+ *   group, and, switched off to start, chart, events, cards and buckets —
+ *   paged by rows and by time, each series switched on and off from the
+ *   library's Series tab, a crew's hours typed into;
+ * - `planConflictsTable`, three works' crews' hours typed into, meeting
+ *   someone else's save in one window.
+ *
+ * The records the Plan's tests read besides are `plan-nested.fixtures.ts`'s,
+ * on no page of the showcase.
+ *
+ * @packageDocumentation
+ */
+import { DateTimeType, DictType, FloatType, IntegerType, NullType, RecursiveType, StringType, StructType, variant } from "@elaraai/east";
+import * as e3 from "@elaraai/e3";
+/** A works' job: what it makes, when it runs, and its state. */
+export declare const WorksJob: StructType<{
+    readonly product: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: import("@elaraai/east").VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+}>;
+/** A works' alarm, raised at an instant. */
+export declare const WorksAlarm: StructType<{
+    readonly code: StringType;
+    readonly at: DateTimeType;
+}>;
+/** A crew of a works: its name, and its hours each quarter, by the instant they were booked. */
+export declare const WorksCrew: StructType<{
+    readonly name: StringType;
+    readonly hours: DictType<DateTimeType, FloatType>;
+}>;
+/** A part of a works: its jobs, and the parts beneath it. */
+export declare const WorksPart: RecursiveType<StructType<{
+    readonly name: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+}>>;
+/**
+ * A works: where it stands and how it is; its jobs and its alarms, things
+ * people drag; its load every four weeks; its crews, each one's hours each
+ * quarter; and its parts, a tree, each part's jobs filed under every part
+ * above it too.
+ */
+export declare const Works: StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>;
+/** The works, by key. */
+export declare const WorksByKey: DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>;
+/**
+ * A part's jobs over the weeks: one every seventeen weeks from its first, a
+ * day or two long, each keyed by the part and its number.
+ */
+export declare const generateWorksPartJobs: import("@elaraai/east").CallableFunctionExpr<[StringType, IntegerType, IntegerType], DictType<StringType, StructType<{
+    readonly product: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: import("@elaraai/east").VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+}>>>;
+/** A part at the foot of a works' tree: its jobs over the weeks, from its first, and no parts beneath it. */
+export declare const generateWorksLeafPart: import("@elaraai/east").CallableFunctionExpr<[StringType, IntegerType, IntegerType], RecursiveType<StructType<{
+    readonly name: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+}>>>;
+/** A works' top part: its jobs over the weeks, from its first, and two parts beneath it, each six weeks on from the one before. */
+export declare const generateWorksTopPart: import("@elaraai/east").CallableFunctionExpr<[StringType, IntegerType, IntegerType], RecursiveType<StructType<{
+    readonly name: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+}>>>;
+/**
+ * Works `n` over a number of weeks from Monday 3 January 2022: sparse, and
+ * spread evenly over them, each works at its own offset into every cycle so
+ * that no two works' items line up and any few weeks hold some — a job every
+ * five weeks, one to four days long and every ninth three weeks; an alarm
+ * every thirteen weeks; its load every four weeks; two crews' hours each
+ * quarter; and three parts, a top part over two, each a job every seventeen
+ * weeks. A function of `n` and the weeks alone.
+ */
+export declare const generateWorks: import("@elaraai/east").CallableFunctionExpr<[IntegerType, IntegerType], StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>;
+/** The first `rows` works over a number of weeks, by key: `W-` and each one's number plus 10,001. */
+export declare const generateWorksAll: import("@elaraai/east").CallableFunctionExpr<[IntegerType, IntegerType], DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>>;
+/**
+ * How many works the task generates: the two hundred the record starts with.
+ * A page runs every task of its area as the area starts, so the showcase
+ * generates no more than it shows; a stress run writes two thousand.
+ */
+export declare const planWorksRows: e3.DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "plan_works_rows">]>;
+/** How many weeks of each works' collections the task generates: ten years'. */
+export declare const planWorksWeeks: e3.DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "plan_works_weeks">]>;
+/** The task that generates the works from their sizes. */
+export declare const planWorksGenerated: e3.TaskDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>, [variant<"field", "tasks">, variant<"field", "plan_works_generated">, variant<"field", "output">]>;
+/**
+ * The works, two hundred of them over ten years, some 90,000 items: read lean
+ * a page at a time and their collections a cell at a time through their nested
+ * series index, never whole. Made as the package is exported, never as a page
+ * loads the example. A stress run writes two thousand through the patch door.
+ */
+export declare const planWorks: e3.RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>, [variant<"field", "records">, variant<"field", "plan_works">], e3.IndexesOf<{
+    plan_works_by_name: e3.IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+    plan_works_by_site_status: e3.IndexDraft<StructType<{
+        status: StringType;
+        site: StringType;
+    }>, NullType, readonly ["site", "status"], unknown>;
+    plan_works_in_time: e3.IndexDraft<e3.NestedKeyOf<DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly site: StringType;
+        readonly status: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly alarms: DictType<StringType, StructType<{
+            readonly code: StringType;
+            readonly at: DateTimeType;
+        }>>;
+        readonly load: DictType<DateTimeType, FloatType>;
+        readonly crews: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly hours: DictType<DateTimeType, FloatType>;
+        }>>;
+        readonly parts: DictType<StringType, RecursiveType<StructType<{
+            readonly name: StringType;
+            readonly jobs: DictType<StringType, StructType<{
+                readonly product: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: NullType;
+                        readonly recommended: NullType;
+                        readonly removed: NullType;
+                    }>;
+                    readonly confirmed: NullType;
+                    readonly "in-progress": NullType;
+                    readonly actual: NullType;
+                    readonly rejected: NullType;
+                }>;
+            }>>;
+            readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+        }>>>;
+    }>>>, e3.NestedValueOf<DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly site: StringType;
+        readonly status: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly alarms: DictType<StringType, StructType<{
+            readonly code: StringType;
+            readonly at: DateTimeType;
+        }>>;
+        readonly load: DictType<DateTimeType, FloatType>;
+        readonly crews: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly hours: DictType<DateTimeType, FloatType>;
+        }>>;
+        readonly parts: DictType<StringType, RecursiveType<StructType<{
+            readonly name: StringType;
+            readonly jobs: DictType<StringType, StructType<{
+                readonly product: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: NullType;
+                        readonly recommended: NullType;
+                        readonly removed: NullType;
+                    }>;
+                    readonly confirmed: NullType;
+                    readonly "in-progress": NullType;
+                    readonly actual: NullType;
+                    readonly rejected: NullType;
+                }>;
+            }>>;
+            readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+        }>>>;
+    }>>, {
+        readonly collections: {
+            readonly jobs: e3.SeriesItems<{
+                readonly from: "start";
+                readonly to: "end";
+            }, e3.SeriesItemsOptions>;
+            readonly alarms: e3.SeriesItems<{
+                readonly at: "at";
+            }, e3.SeriesItemsOptions>;
+            readonly load: e3.SeriesValues<e3.SeriesValuesOptions>;
+            readonly crews: e3.SeriesRows<{
+                readonly hours: e3.SeriesValues<{
+                    readonly rollup: "sum";
+                }>;
+            }>;
+            readonly parts: e3.SeriesRows<{
+                readonly jobs: e3.SeriesItems<{
+                    readonly from: "start";
+                    readonly to: "end";
+                }, {
+                    readonly rollup: true;
+                }>;
+                readonly parts: e3.SeriesRecursive;
+            }>;
+        };
+        readonly tile: "week";
+        readonly summary: "month";
+    }>, readonly [], {
+        readonly nested: e3.NestedOf<{
+            readonly collections: {
+                readonly jobs: e3.SeriesItems<{
+                    readonly from: "start";
+                    readonly to: "end";
+                }, e3.SeriesItemsOptions>;
+                readonly alarms: e3.SeriesItems<{
+                    readonly at: "at";
+                }, e3.SeriesItemsOptions>;
+                readonly load: e3.SeriesValues<e3.SeriesValuesOptions>;
+                readonly crews: e3.SeriesRows<{
+                    readonly hours: e3.SeriesValues<{
+                        readonly rollup: "sum";
+                    }>;
+                }>;
+                readonly parts: e3.SeriesRows<{
+                    readonly jobs: e3.SeriesItems<{
+                        readonly from: "start";
+                        readonly to: "end";
+                    }, {
+                        readonly rollup: true;
+                    }>;
+                    readonly parts: e3.SeriesRecursive;
+                }>;
+            };
+            readonly tile: "week";
+            readonly summary: "month";
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly site: StringType;
+                readonly status: StringType;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly product: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                }>>;
+                readonly alarms: DictType<StringType, StructType<{
+                    readonly code: StringType;
+                    readonly at: DateTimeType;
+                }>>;
+                readonly load: DictType<DateTimeType, FloatType>;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+                readonly parts: DictType<StringType, RecursiveType<StructType<{
+                    readonly name: StringType;
+                    readonly jobs: DictType<StringType, StructType<{
+                        readonly product: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>>;
+                    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                }>>>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly site: StringType;
+                readonly status: StringType;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly product: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                }>>;
+                readonly alarms: DictType<StringType, StructType<{
+                    readonly code: StringType;
+                    readonly at: DateTimeType;
+                }>>;
+                readonly load: DictType<DateTimeType, FloatType>;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+                readonly parts: DictType<StringType, RecursiveType<StructType<{
+                    readonly name: StringType;
+                    readonly jobs: DictType<StringType, StructType<{
+                        readonly product: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>>;
+                    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                }>>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly site: StringType;
+                readonly status: StringType;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly product: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                }>>;
+                readonly alarms: DictType<StringType, StructType<{
+                    readonly code: StringType;
+                    readonly at: DateTimeType;
+                }>>;
+                readonly load: DictType<DateTimeType, FloatType>;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+                readonly parts: DictType<StringType, RecursiveType<StructType<{
+                    readonly name: StringType;
+                    readonly jobs: DictType<StringType, StructType<{
+                        readonly product: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>>;
+                    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                }>>>;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly site: StringType;
+                readonly status: StringType;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly product: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: import("@elaraai/east").VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                }>>;
+                readonly alarms: DictType<StringType, StructType<{
+                    readonly code: StringType;
+                    readonly at: DateTimeType;
+                }>>;
+                readonly load: DictType<DateTimeType, FloatType>;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+                readonly parts: DictType<StringType, RecursiveType<StructType<{
+                    readonly name: StringType;
+                    readonly jobs: DictType<StringType, StructType<{
+                        readonly product: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>>;
+                    readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                }>>>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly site: StringType;
+                        readonly status: StringType;
+                        readonly jobs: DictType<StringType, StructType<{
+                            readonly product: StringType;
+                            readonly start: DateTimeType;
+                            readonly end: DateTimeType;
+                            readonly state: import("@elaraai/east").VariantType<{
+                                readonly estimated: NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                                readonly confirmed: NullType;
+                                readonly "in-progress": NullType;
+                                readonly actual: NullType;
+                                readonly rejected: NullType;
+                            }>;
+                        }>>;
+                        readonly alarms: DictType<StringType, StructType<{
+                            readonly code: StringType;
+                            readonly at: DateTimeType;
+                        }>>;
+                        readonly load: DictType<DateTimeType, FloatType>;
+                        readonly crews: DictType<StringType, StructType<{
+                            readonly name: StringType;
+                            readonly hours: DictType<DateTimeType, FloatType>;
+                        }>>;
+                        readonly parts: DictType<StringType, RecursiveType<StructType<{
+                            readonly name: StringType;
+                            readonly jobs: DictType<StringType, StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>>;
+                            readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>>;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly site: StringType;
+                        readonly status: StringType;
+                        readonly jobs: DictType<StringType, StructType<{
+                            readonly product: StringType;
+                            readonly start: DateTimeType;
+                            readonly end: DateTimeType;
+                            readonly state: import("@elaraai/east").VariantType<{
+                                readonly estimated: NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                                readonly confirmed: NullType;
+                                readonly "in-progress": NullType;
+                                readonly actual: NullType;
+                                readonly rejected: NullType;
+                            }>;
+                        }>>;
+                        readonly alarms: DictType<StringType, StructType<{
+                            readonly code: StringType;
+                            readonly at: DateTimeType;
+                        }>>;
+                        readonly load: DictType<DateTimeType, FloatType>;
+                        readonly crews: DictType<StringType, StructType<{
+                            readonly name: StringType;
+                            readonly hours: DictType<DateTimeType, FloatType>;
+                        }>>;
+                        readonly parts: DictType<StringType, RecursiveType<StructType<{
+                            readonly name: StringType;
+                            readonly jobs: DictType<StringType, StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>>;
+                            readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                        }>>>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly site: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly status: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly jobs: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>>;
+                            after: DictType<StringType, StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>;
+                            insert: StructType<{
+                                readonly product: StringType;
+                                readonly start: DateTimeType;
+                                readonly end: DateTimeType;
+                                readonly state: import("@elaraai/east").VariantType<{
+                                    readonly estimated: NullType;
+                                    readonly proposed: import("@elaraai/east").VariantType<{
+                                        readonly added: NullType;
+                                        readonly recommended: NullType;
+                                        readonly removed: NullType;
+                                    }>;
+                                    readonly confirmed: NullType;
+                                    readonly "in-progress": NullType;
+                                    readonly actual: NullType;
+                                    readonly rejected: NullType;
+                                }>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly product: StringType;
+                                        readonly start: DateTimeType;
+                                        readonly end: DateTimeType;
+                                        readonly state: import("@elaraai/east").VariantType<{
+                                            readonly estimated: NullType;
+                                            readonly proposed: import("@elaraai/east").VariantType<{
+                                                readonly added: NullType;
+                                                readonly recommended: NullType;
+                                                readonly removed: NullType;
+                                            }>;
+                                            readonly confirmed: NullType;
+                                            readonly "in-progress": NullType;
+                                            readonly actual: NullType;
+                                            readonly rejected: NullType;
+                                        }>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly product: StringType;
+                                        readonly start: DateTimeType;
+                                        readonly end: DateTimeType;
+                                        readonly state: import("@elaraai/east").VariantType<{
+                                            readonly estimated: NullType;
+                                            readonly proposed: import("@elaraai/east").VariantType<{
+                                                readonly added: NullType;
+                                                readonly recommended: NullType;
+                                                readonly removed: NullType;
+                                            }>;
+                                            readonly confirmed: NullType;
+                                            readonly "in-progress": NullType;
+                                            readonly actual: NullType;
+                                            readonly rejected: NullType;
+                                        }>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly product: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly start: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
+                                    }>;
+                                    readonly end: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
+                                    }>;
+                                    readonly state: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: import("@elaraai/east").VariantType<{
+                                                readonly estimated: NullType;
+                                                readonly proposed: import("@elaraai/east").VariantType<{
+                                                    readonly added: NullType;
+                                                    readonly recommended: NullType;
+                                                    readonly removed: NullType;
+                                                }>;
+                                                readonly confirmed: NullType;
+                                                readonly "in-progress": NullType;
+                                                readonly actual: NullType;
+                                                readonly rejected: NullType;
+                                            }>;
+                                            after: import("@elaraai/east").VariantType<{
+                                                readonly estimated: NullType;
+                                                readonly proposed: import("@elaraai/east").VariantType<{
+                                                    readonly added: NullType;
+                                                    readonly recommended: NullType;
+                                                    readonly removed: NullType;
+                                                }>;
+                                                readonly confirmed: NullType;
+                                                readonly "in-progress": NullType;
+                                                readonly actual: NullType;
+                                                readonly rejected: NullType;
+                                            }>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            readonly estimated: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            readonly proposed: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").VariantType<{
+                                                        readonly added: NullType;
+                                                        readonly recommended: NullType;
+                                                        readonly removed: NullType;
+                                                    }>;
+                                                    after: import("@elaraai/east").VariantType<{
+                                                        readonly added: NullType;
+                                                        readonly recommended: NullType;
+                                                        readonly removed: NullType;
+                                                    }>;
+                                                }>;
+                                                patch: import("@elaraai/east").VariantType<{
+                                                    readonly added: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly recommended: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly removed: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly confirmed: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            readonly "in-progress": import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            readonly actual: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            readonly rejected: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly alarms: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, StructType<{
+                                readonly code: StringType;
+                                readonly at: DateTimeType;
+                            }>>;
+                            after: DictType<StringType, StructType<{
+                                readonly code: StringType;
+                                readonly at: DateTimeType;
+                            }>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly code: StringType;
+                                readonly at: DateTimeType;
+                            }>;
+                            insert: StructType<{
+                                readonly code: StringType;
+                                readonly at: DateTimeType;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly code: StringType;
+                                        readonly at: DateTimeType;
+                                    }>;
+                                    after: StructType<{
+                                        readonly code: StringType;
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly code: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly at: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<DateTimeType, FloatType>;
+                            after: DictType<DateTimeType, FloatType>;
+                        }>;
+                        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+                            delete: FloatType;
+                            insert: FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: FloatType;
+                                    after: FloatType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly crews: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>>;
+                            after: DictType<StringType, StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>;
+                            insert: StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly name: StringType;
+                                        readonly hours: DictType<DateTimeType, FloatType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly name: StringType;
+                                        readonly hours: DictType<DateTimeType, FloatType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly name: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly hours: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DictType<DateTimeType, FloatType>;
+                                            after: DictType<DateTimeType, FloatType>;
+                                        }>;
+                                        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+                                            delete: FloatType;
+                                            insert: FloatType;
+                                            update: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                        }>>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly parts: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, RecursiveType<StructType<{
+                                readonly name: StringType;
+                                readonly jobs: DictType<StringType, StructType<{
+                                    readonly product: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
+                                    readonly state: import("@elaraai/east").VariantType<{
+                                        readonly estimated: NullType;
+                                        readonly proposed: import("@elaraai/east").VariantType<{
+                                            readonly added: NullType;
+                                            readonly recommended: NullType;
+                                            readonly removed: NullType;
+                                        }>;
+                                        readonly confirmed: NullType;
+                                        readonly "in-progress": NullType;
+                                        readonly actual: NullType;
+                                        readonly rejected: NullType;
+                                    }>;
+                                }>>;
+                                readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>>;
+                            after: DictType<StringType, RecursiveType<StructType<{
+                                readonly name: StringType;
+                                readonly jobs: DictType<StringType, StructType<{
+                                    readonly product: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
+                                    readonly state: import("@elaraai/east").VariantType<{
+                                        readonly estimated: NullType;
+                                        readonly proposed: import("@elaraai/east").VariantType<{
+                                            readonly added: NullType;
+                                            readonly recommended: NullType;
+                                            readonly removed: NullType;
+                                        }>;
+                                        readonly confirmed: NullType;
+                                        readonly "in-progress": NullType;
+                                        readonly actual: NullType;
+                                        readonly rejected: NullType;
+                                    }>;
+                                }>>;
+                                readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: RecursiveType<StructType<{
+                                readonly name: StringType;
+                                readonly jobs: DictType<StringType, StructType<{
+                                    readonly product: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
+                                    readonly state: import("@elaraai/east").VariantType<{
+                                        readonly estimated: NullType;
+                                        readonly proposed: import("@elaraai/east").VariantType<{
+                                            readonly added: NullType;
+                                            readonly recommended: NullType;
+                                            readonly removed: NullType;
+                                        }>;
+                                        readonly confirmed: NullType;
+                                        readonly "in-progress": NullType;
+                                        readonly actual: NullType;
+                                        readonly rejected: NullType;
+                                    }>;
+                                }>>;
+                                readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            insert: RecursiveType<StructType<{
+                                readonly name: StringType;
+                                readonly jobs: DictType<StringType, StructType<{
+                                    readonly product: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
+                                    readonly state: import("@elaraai/east").VariantType<{
+                                        readonly estimated: NullType;
+                                        readonly proposed: import("@elaraai/east").VariantType<{
+                                            readonly added: NullType;
+                                            readonly recommended: NullType;
+                                            readonly removed: NullType;
+                                        }>;
+                                        readonly confirmed: NullType;
+                                        readonly "in-progress": NullType;
+                                        readonly actual: NullType;
+                                        readonly rejected: NullType;
+                                    }>;
+                                }>>;
+                                readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                            }>>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: RecursiveType<StructType<{
+                                        readonly name: StringType;
+                                        readonly jobs: DictType<StringType, StructType<{
+                                            readonly product: StringType;
+                                            readonly start: DateTimeType;
+                                            readonly end: DateTimeType;
+                                            readonly state: import("@elaraai/east").VariantType<{
+                                                readonly estimated: NullType;
+                                                readonly proposed: import("@elaraai/east").VariantType<{
+                                                    readonly added: NullType;
+                                                    readonly recommended: NullType;
+                                                    readonly removed: NullType;
+                                                }>;
+                                                readonly confirmed: NullType;
+                                                readonly "in-progress": NullType;
+                                                readonly actual: NullType;
+                                                readonly rejected: NullType;
+                                            }>;
+                                        }>>;
+                                        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                    after: RecursiveType<StructType<{
+                                        readonly name: StringType;
+                                        readonly jobs: DictType<StringType, StructType<{
+                                            readonly product: StringType;
+                                            readonly start: DateTimeType;
+                                            readonly end: DateTimeType;
+                                            readonly state: import("@elaraai/east").VariantType<{
+                                                readonly estimated: NullType;
+                                                readonly proposed: import("@elaraai/east").VariantType<{
+                                                    readonly added: NullType;
+                                                    readonly recommended: NullType;
+                                                    readonly removed: NullType;
+                                                }>;
+                                                readonly confirmed: NullType;
+                                                readonly "in-progress": NullType;
+                                                readonly actual: NullType;
+                                                readonly rejected: NullType;
+                                            }>;
+                                        }>>;
+                                        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                                    }>>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly site: StringType;
+    readonly status: StringType;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly product: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+    }>>;
+    readonly alarms: DictType<StringType, StructType<{
+        readonly code: StringType;
+        readonly at: DateTimeType;
+    }>>;
+    readonly load: DictType<DateTimeType, FloatType>;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+    readonly parts: DictType<StringType, RecursiveType<StructType<{
+        readonly name: StringType;
+        readonly jobs: DictType<StringType, StructType<{
+            readonly product: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: import("@elaraai/east").VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>>;
+        readonly parts: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>>;
+}>>>>;
+/**
+ * Every series kind a Plan reads a cell at a time, over the works and their
+ * ten years (#1438): each works' jobs as runs and its alarms as decisions,
+ * its load as a heat strip, its crews' hours as a table whose works row draws
+ * their sums as e3 keeps them, and its parts as a tree whose folded parents
+ * draw their bands from the jobs e3 files under them; and, switched off to
+ * start, its load as a line, its alarms as exception marks and as tiles, and
+ * its jobs as chips. The rail pages the works and narrows them by site and
+ * state; the canvas pages them by rows and by time, reading the cells around
+ * the rows in view, and shades a collection from its totals past 10,000
+ * items. The series are picked: the library's Series tab switches each on and
+ * off. A moved job is a draft of its works read whole, saved by key through
+ * the patch door.
+ */
+export declare const planNestedAll: import("@elaraai/east").ExampleDef<[], any>;
+/** A works of the conflicts example: its name and its crews' hours. */
+export declare const ConflictWorks: StructType<{
+    readonly name: StringType;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+}>;
+/** The works the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export declare const planConflictWorks: e3.RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "plan_conflict_works">], e3.IndexesOf<{
+    plan_conflict_works_by_name: e3.IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+    plan_conflict_works_in_time: e3.IndexDraft<e3.NestedKeyOf<DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly crews: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly hours: DictType<DateTimeType, FloatType>;
+        }>>;
+    }>>>, e3.NestedValueOf<DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly crews: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly hours: DictType<DateTimeType, FloatType>;
+        }>>;
+    }>>, {
+        readonly collections: {
+            readonly crews: e3.SeriesRows<{
+                readonly hours: e3.SeriesValues<{
+                    readonly rollup: "sum";
+                }>;
+            }>;
+        };
+        readonly tile: "week";
+        readonly summary: "month";
+    }>, readonly [], {
+        readonly nested: e3.NestedOf<{
+            readonly collections: {
+                readonly crews: e3.SeriesRows<{
+                    readonly hours: e3.SeriesValues<{
+                        readonly rollup: "sum";
+                    }>;
+                }>;
+            };
+            readonly tile: "week";
+            readonly summary: "month";
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly crews: DictType<StringType, StructType<{
+                    readonly name: StringType;
+                    readonly hours: DictType<DateTimeType, FloatType>;
+                }>>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly crews: DictType<StringType, StructType<{
+                            readonly name: StringType;
+                            readonly hours: DictType<DateTimeType, FloatType>;
+                        }>>;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly crews: DictType<StringType, StructType<{
+                            readonly name: StringType;
+                            readonly hours: DictType<DateTimeType, FloatType>;
+                        }>>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly crews: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>>;
+                            after: DictType<StringType, StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>;
+                            insert: StructType<{
+                                readonly name: StringType;
+                                readonly hours: DictType<DateTimeType, FloatType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly name: StringType;
+                                        readonly hours: DictType<DateTimeType, FloatType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly name: StringType;
+                                        readonly hours: DictType<DateTimeType, FloatType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly name: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly hours: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DictType<DateTimeType, FloatType>;
+                                            after: DictType<DateTimeType, FloatType>;
+                                        }>;
+                                        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+                                            delete: FloatType;
+                                            insert: FloatType;
+                                            update: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                        }>>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+    elsewhere: e3.MutationDraft<[]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly crews: DictType<StringType, StructType<{
+        readonly name: StringType;
+        readonly hours: DictType<DateTimeType, FloatType>;
+    }>>;
+}>>>>;
+/**
+ * Your edits meeting someone else's save, in one window: type a crew's hours
+ * for a week, then press Someone else saves, which saves another person's
+ * change to the same works — every crew's hours 10 more in every week. The
+ * week you typed is a conflict, named by its works and its crew, waiting for
+ * you to choose. Each press saves their change again.
+ */
+export declare const planConflictsTable: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=plan-nested.examples.d.ts.map