@elaraai/e3-ui 1.0.94 → 1.0.96

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

@@ -0,0 +1,3499 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Schedule's records: what `Schedule.events`, `Schedule.resources` and
+ * `Schedule.periods` are built over in Schedule's specs, which e3-ui-components
+ * reads on e3 itself (#1379). Schedule draws nothing of its own — its kinds
+ * are the Calendar's, the Plan's, the Roster's and the Allocation's, whose
+ * examples show them — so this module declares records and no examples: a
+ * `.examples.ts` module, of which the showcase builds no page.
+ *
+ * - Calendar Spec §3.1's: shifts on people, maintenance jobs on machines with
+ *   a backlog, inspections on a site or a machine, tasks whose estimates run in
+ *   every unit, and visits with a field named with a dot.
+ * - Plan Builder Spec §3.1's print works: jobs as bars, stops as marks,
+ *   deliveries as tiles in their lanes and crew shifts as chips.
+ * - Builder Interfaces Spec §4's: a warehouse's duties and weeks, the
+ *   Roster's, and a kiln yard's bins and days, the Allocation's.
+ *
+ * Each is bound as an app binds it, through its patch door.
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, SetType, StringType, StructType, VariantType, variant } from "@elaraai/east";
+/** A shift's or a job's status. */
+export declare const ScheduleStatus: VariantType<{
+    readonly tentative: NullType;
+    readonly confirmed: NullType;
+    readonly in_progress: NullType;
+    readonly done: NullType;
+}>;
+/** A shift's handover checklist. */
+export declare const ScheduleChecklist: ArrayType<StructType<{
+    readonly item: StringType;
+    readonly done: BooleanType;
+}>>;
+/** A shift: plain times, a person or none, its crew, the skills it needs and its handover. */
+export declare const ScheduleShift: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly person: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly crew: IntegerType;
+    readonly skills: SetType<StringType>;
+    readonly handover: ArrayType<StructType<{
+        readonly item: StringType;
+        readonly done: BooleanType;
+    }>>;
+}>;
+/** A maintenance job: Option times, so it can wait in the backlog, and its work order. */
+export declare const ScheduleJob: StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly machine: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly work_order: StringType;
+    readonly estimate_h: FloatType;
+    readonly due: OptionType<DateTimeType>;
+}>;
+/** An inspection: on a site or a machine, by the variant's case, its contact a nested struct an edit reaches into. */
+export declare const ScheduleInspection: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly target: OptionType<VariantType<{
+        readonly site: StringType;
+        readonly machine: StringType;
+    }>>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly contact: StructType<{
+        readonly name: StringType;
+        readonly phone: StringType;
+    }>;
+}>;
+/** A task: on no resource, its estimate a duration in any unit. */
+export declare const ScheduleTask: StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly estimate: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+}>;
+/** A visit: a field named with a dot beside a struct of that name, so a path names a field by its steps. */
+export declare const ScheduleVisit: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly "contact.phone": StringType;
+    readonly contact: StructType<{
+        readonly phone: StringType;
+    }>;
+}>;
+/** The shifts about Thursday 1 October 2026: a day shift, a night running on past midnight, and one a week later. */
+export declare const scheduleShifts: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly person: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly crew: IntegerType;
+    readonly skills: SetType<StringType>;
+    readonly handover: ArrayType<StructType<{
+        readonly item: StringType;
+        readonly done: BooleanType;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_shifts">]>;
+export declare const scheduleShiftsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly person: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly crew: IntegerType;
+    readonly skills: SetType<StringType>;
+    readonly handover: ArrayType<StructType<{
+        readonly item: StringType;
+        readonly done: BooleanType;
+    }>>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly person: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly crew: IntegerType;
+            readonly skills: SetType<StringType>;
+            readonly handover: ArrayType<StructType<{
+                readonly item: StringType;
+                readonly done: BooleanType;
+            }>>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly person: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly crew: IntegerType;
+            readonly skills: SetType<StringType>;
+            readonly handover: ArrayType<StructType<{
+                readonly item: StringType;
+                readonly done: BooleanType;
+            }>>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly person: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly crew: IntegerType;
+            readonly skills: SetType<StringType>;
+            readonly handover: ArrayType<StructType<{
+                readonly item: StringType;
+                readonly done: BooleanType;
+            }>>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly person: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly crew: IntegerType;
+            readonly skills: SetType<StringType>;
+            readonly handover: ArrayType<StructType<{
+                readonly item: StringType;
+                readonly done: BooleanType;
+            }>>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly person: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly crew: IntegerType;
+                    readonly skills: SetType<StringType>;
+                    readonly handover: ArrayType<StructType<{
+                        readonly item: StringType;
+                        readonly done: BooleanType;
+                    }>>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly person: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly crew: IntegerType;
+                    readonly skills: SetType<StringType>;
+                    readonly handover: ArrayType<StructType<{
+                        readonly item: StringType;
+                        readonly done: BooleanType;
+                    }>>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly person: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly status: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly tentative: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly confirmed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly in_progress: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly done: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly crew: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+                readonly skills: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: SetType<StringType>;
+                        after: SetType<StringType>;
+                    }>;
+                    patch: DictType<StringType, VariantType<{
+                        delete: NullType;
+                        insert: NullType;
+                    }>>;
+                }>;
+                readonly handover: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly item: StringType;
+                            readonly done: BooleanType;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly item: StringType;
+                            readonly done: BooleanType;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: VariantType<{
+                            delete: StructType<{
+                                readonly item: StringType;
+                                readonly done: BooleanType;
+                            }>;
+                            insert: StructType<{
+                                readonly item: StringType;
+                                readonly done: BooleanType;
+                            }>;
+                            update: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly item: StringType;
+                                        readonly done: BooleanType;
+                                    }>;
+                                    after: StructType<{
+                                        readonly item: StringType;
+                                        readonly done: BooleanType;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly item: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly done: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: BooleanType;
+                                            after: BooleanType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The jobs: one scheduled, and two in the backlog, one of them due. */
+export declare const scheduleJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly machine: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly work_order: StringType;
+    readonly estimate_h: FloatType;
+    readonly due: OptionType<DateTimeType>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_jobs">]>;
+export declare const scheduleJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly machine: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly work_order: StringType;
+    readonly estimate_h: FloatType;
+    readonly due: OptionType<DateTimeType>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly machine: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly work_order: StringType;
+            readonly estimate_h: FloatType;
+            readonly due: OptionType<DateTimeType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly machine: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly work_order: StringType;
+            readonly estimate_h: FloatType;
+            readonly due: OptionType<DateTimeType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly machine: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly work_order: StringType;
+            readonly estimate_h: FloatType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly machine: OptionType<StringType>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly work_order: StringType;
+            readonly estimate_h: FloatType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly machine: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly work_order: StringType;
+                    readonly estimate_h: FloatType;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly machine: OptionType<StringType>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly work_order: StringType;
+                    readonly estimate_h: FloatType;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly machine: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly status: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly tentative: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly confirmed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly in_progress: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly done: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly work_order: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly estimate_h: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly due: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The inspections: a safety walk of the north site. */
+export declare const scheduleInspections: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly target: OptionType<VariantType<{
+        readonly site: StringType;
+        readonly machine: StringType;
+    }>>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly contact: StructType<{
+        readonly name: StringType;
+        readonly phone: StringType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_inspections">]>;
+export declare const scheduleInspectionsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly target: OptionType<VariantType<{
+        readonly site: StringType;
+        readonly machine: StringType;
+    }>>;
+    readonly status: VariantType<{
+        readonly tentative: NullType;
+        readonly confirmed: NullType;
+        readonly in_progress: NullType;
+        readonly done: NullType;
+    }>;
+    readonly contact: StructType<{
+        readonly name: StringType;
+        readonly phone: StringType;
+    }>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly target: OptionType<VariantType<{
+                readonly site: StringType;
+                readonly machine: StringType;
+            }>>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly contact: StructType<{
+                readonly name: StringType;
+                readonly phone: StringType;
+            }>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly target: OptionType<VariantType<{
+                readonly site: StringType;
+                readonly machine: StringType;
+            }>>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly contact: StructType<{
+                readonly name: StringType;
+                readonly phone: StringType;
+            }>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly target: OptionType<VariantType<{
+                readonly site: StringType;
+                readonly machine: StringType;
+            }>>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly contact: StructType<{
+                readonly name: StringType;
+                readonly phone: StringType;
+            }>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly target: OptionType<VariantType<{
+                readonly site: StringType;
+                readonly machine: StringType;
+            }>>;
+            readonly status: VariantType<{
+                readonly tentative: NullType;
+                readonly confirmed: NullType;
+                readonly in_progress: NullType;
+                readonly done: NullType;
+            }>;
+            readonly contact: StructType<{
+                readonly name: StringType;
+                readonly phone: StringType;
+            }>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly target: OptionType<VariantType<{
+                        readonly site: StringType;
+                        readonly machine: StringType;
+                    }>>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly contact: StructType<{
+                        readonly name: StringType;
+                        readonly phone: StringType;
+                    }>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly target: OptionType<VariantType<{
+                        readonly site: StringType;
+                        readonly machine: StringType;
+                    }>>;
+                    readonly status: VariantType<{
+                        readonly tentative: NullType;
+                        readonly confirmed: NullType;
+                        readonly in_progress: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly contact: StructType<{
+                        readonly name: StringType;
+                        readonly phone: StringType;
+                    }>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly target: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<VariantType<{
+                            readonly site: StringType;
+                            readonly machine: StringType;
+                        }>>;
+                        after: OptionType<VariantType<{
+                            readonly site: StringType;
+                            readonly machine: StringType;
+                        }>>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: VariantType<{
+                                    readonly site: StringType;
+                                    readonly machine: StringType;
+                                }>;
+                                after: VariantType<{
+                                    readonly site: StringType;
+                                    readonly machine: StringType;
+                                }>;
+                            }>;
+                            patch: VariantType<{
+                                readonly site: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
+                                }>;
+                                readonly machine: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly status: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly tentative: NullType;
+                            readonly confirmed: NullType;
+                            readonly in_progress: NullType;
+                            readonly done: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly tentative: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly confirmed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly in_progress: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly done: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly contact: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StructType<{
+                            readonly name: StringType;
+                            readonly phone: StringType;
+                        }>;
+                        after: StructType<{
+                            readonly name: StringType;
+                            readonly phone: StringType;
+                        }>;
+                    }>;
+                    patch: StructType<{
+                        readonly name: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly phone: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The tasks, each estimated in a unit of its own. */
+export declare const scheduleTasks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly estimate: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_tasks">]>;
+export declare const scheduleTasksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly estimate: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly estimate: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly estimate: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly estimate: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly estimate: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly estimate: VariantType<{
+                        readonly minutes: FloatType;
+                        readonly hours: FloatType;
+                        readonly days: FloatType;
+                        readonly weeks: FloatType;
+                        readonly months: FloatType;
+                    }>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly estimate: VariantType<{
+                        readonly minutes: FloatType;
+                        readonly hours: FloatType;
+                        readonly days: FloatType;
+                        readonly weeks: FloatType;
+                        readonly months: FloatType;
+                    }>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly estimate: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly minutes: FloatType;
+                            readonly hours: FloatType;
+                            readonly days: FloatType;
+                            readonly weeks: FloatType;
+                            readonly months: FloatType;
+                        }>;
+                        after: VariantType<{
+                            readonly minutes: FloatType;
+                            readonly hours: FloatType;
+                            readonly days: FloatType;
+                            readonly weeks: FloatType;
+                            readonly months: FloatType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly minutes: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly hours: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly days: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly weeks: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly months: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The visits: one, its dotted field and its contact's phone told apart. */
+export declare const scheduleVisits: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly "contact.phone": StringType;
+    readonly contact: StructType<{
+        readonly phone: StringType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_visits">]>;
+export declare const scheduleVisitsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly "contact.phone": StringType;
+    readonly contact: StructType<{
+        readonly phone: StringType;
+    }>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly "contact.phone": StringType;
+            readonly contact: StructType<{
+                readonly phone: StringType;
+            }>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly "contact.phone": StringType;
+            readonly contact: StructType<{
+                readonly phone: StringType;
+            }>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly "contact.phone": StringType;
+            readonly contact: StructType<{
+                readonly phone: StringType;
+            }>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly "contact.phone": StringType;
+            readonly contact: StructType<{
+                readonly phone: StringType;
+            }>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly "contact.phone": StringType;
+                    readonly contact: StructType<{
+                        readonly phone: StringType;
+                    }>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly "contact.phone": StringType;
+                    readonly contact: StructType<{
+                        readonly phone: StringType;
+                    }>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly "contact.phone": VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly contact: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StructType<{
+                            readonly phone: StringType;
+                        }>;
+                        after: StructType<{
+                            readonly phone: StringType;
+                        }>;
+                    }>;
+                    patch: StructType<{
+                        readonly phone: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** A print job: Option times and press, so it can wait in the backlog; the lifecycle it wears; its sheets. */
+export declare const SchedulePrintJob: StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly press: OptionType<StringType>;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+    readonly sheets: FloatType;
+    readonly customer: StringType;
+    readonly stock: VariantType<{
+        readonly coated: NullType;
+        readonly uncoated: NullType;
+        readonly board: NullType;
+    }>;
+    readonly due: OptionType<DateTimeType>;
+}>;
+/** A stop: one instant at a press. */
+export declare const SchedulePrintStop: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly kind: VariantType<{
+        readonly plate_change: NullType;
+        readonly service: NullType;
+    }>;
+}>;
+/** A crew's shift, and the lifecycle it wears. */
+export declare const SchedulePrintShift: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly crew: StringType;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+}>;
+/** A delivery: one instant at a press, in the morning's lane or the afternoon's. */
+export declare const SchedulePrintDelivery: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly slot: StringType;
+}>;
+/** The jobs about Monday 5 October 2026: a brochure run on press A, and a catalogue run waiting, due on the 9th. */
+export declare const schedulePrintJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly press: OptionType<StringType>;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+    readonly sheets: FloatType;
+    readonly customer: StringType;
+    readonly stock: VariantType<{
+        readonly coated: NullType;
+        readonly uncoated: NullType;
+        readonly board: NullType;
+    }>;
+    readonly due: OptionType<DateTimeType>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_print_jobs">]>;
+export declare const schedulePrintJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly press: OptionType<StringType>;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+    readonly sheets: FloatType;
+    readonly customer: StringType;
+    readonly stock: VariantType<{
+        readonly coated: NullType;
+        readonly uncoated: NullType;
+        readonly board: NullType;
+    }>;
+    readonly due: OptionType<DateTimeType>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly press: OptionType<StringType>;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            readonly sheets: FloatType;
+            readonly customer: StringType;
+            readonly stock: VariantType<{
+                readonly coated: NullType;
+                readonly uncoated: NullType;
+                readonly board: NullType;
+            }>;
+            readonly due: OptionType<DateTimeType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly press: OptionType<StringType>;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            readonly sheets: FloatType;
+            readonly customer: StringType;
+            readonly stock: VariantType<{
+                readonly coated: NullType;
+                readonly uncoated: NullType;
+                readonly board: NullType;
+            }>;
+            readonly due: OptionType<DateTimeType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly press: OptionType<StringType>;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            readonly sheets: FloatType;
+            readonly customer: StringType;
+            readonly stock: VariantType<{
+                readonly coated: NullType;
+                readonly uncoated: NullType;
+                readonly board: NullType;
+            }>;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly press: OptionType<StringType>;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            readonly sheets: FloatType;
+            readonly customer: StringType;
+            readonly stock: VariantType<{
+                readonly coated: NullType;
+                readonly uncoated: NullType;
+                readonly board: NullType;
+            }>;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly press: OptionType<StringType>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly sheets: FloatType;
+                    readonly customer: StringType;
+                    readonly stock: VariantType<{
+                        readonly coated: NullType;
+                        readonly uncoated: NullType;
+                        readonly board: NullType;
+                    }>;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                    readonly press: OptionType<StringType>;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: VariantType<{
+                            readonly added: NullType;
+                            readonly recommended: NullType;
+                            readonly removed: NullType;
+                        }>;
+                        readonly confirmed: NullType;
+                        readonly "in-progress": NullType;
+                        readonly actual: NullType;
+                        readonly rejected: NullType;
+                    }>;
+                    readonly sheets: FloatType;
+                    readonly customer: StringType;
+                    readonly stock: VariantType<{
+                        readonly coated: NullType;
+                        readonly uncoated: NullType;
+                        readonly board: NullType;
+                    }>;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly press: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly state: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly estimated: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly proposed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                                after: VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                            }>;
+                            patch: VariantType<{
+                                readonly added: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                                readonly recommended: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                                readonly removed: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                        readonly confirmed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly "in-progress": VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly actual: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly rejected: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly sheets: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly customer: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly stock: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly coated: NullType;
+                            readonly uncoated: NullType;
+                            readonly board: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly coated: NullType;
+                            readonly uncoated: NullType;
+                            readonly board: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly coated: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly uncoated: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly board: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly due: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The stops: a plate change on press A as the brochure run ends. */
+export declare const schedulePrintStops: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly kind: VariantType<{
+        readonly plate_change: NullType;
+        readonly service: NullType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_print_stops">]>;
+export declare const schedulePrintStopsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly kind: VariantType<{
+        readonly plate_change: NullType;
+        readonly service: NullType;
+    }>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly kind: VariantType<{
+                readonly plate_change: NullType;
+                readonly service: NullType;
+            }>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly kind: VariantType<{
+                readonly plate_change: NullType;
+                readonly service: NullType;
+            }>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly kind: VariantType<{
+                readonly plate_change: NullType;
+                readonly service: NullType;
+            }>;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly kind: VariantType<{
+                readonly plate_change: NullType;
+                readonly service: NullType;
+            }>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly press: StringType;
+                    readonly kind: VariantType<{
+                        readonly plate_change: NullType;
+                        readonly service: NullType;
+                    }>;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly press: StringType;
+                    readonly kind: VariantType<{
+                        readonly plate_change: NullType;
+                        readonly service: NullType;
+                    }>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly at: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly press: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly kind: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly plate_change: NullType;
+                            readonly service: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly plate_change: NullType;
+                            readonly service: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly plate_change: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly service: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The crews' shifts: crew 1's early shift. */
+export declare const schedulePrintShifts: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly crew: StringType;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_print_shifts">]>;
+export declare const schedulePrintShiftsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly crew: StringType;
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly crew: StringType;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: 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 title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly crew: StringType;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: 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, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly crew: StringType;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: 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 title: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly crew: StringType;
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly crew: StringType;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: 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 title: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly crew: StringType;
+                    readonly state: VariantType<{
+                        readonly estimated: NullType;
+                        readonly proposed: 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 title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly crew: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly state: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly estimated: NullType;
+                            readonly proposed: VariantType<{
+                                readonly added: NullType;
+                                readonly recommended: NullType;
+                                readonly removed: NullType;
+                            }>;
+                            readonly confirmed: NullType;
+                            readonly "in-progress": NullType;
+                            readonly actual: NullType;
+                            readonly rejected: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly estimated: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly proposed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                                after: VariantType<{
+                                    readonly added: NullType;
+                                    readonly recommended: NullType;
+                                    readonly removed: NullType;
+                                }>;
+                            }>;
+                            patch: VariantType<{
+                                readonly added: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                                readonly recommended: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                                readonly removed: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: NullType;
+                                        after: NullType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                        readonly confirmed: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly "in-progress": VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly actual: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly rejected: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The deliveries: a van to the depot from press B, in the morning's lane. */
+export declare const schedulePrintDeliveries: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly slot: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schedule_print_deliveries">]>;
+export declare const schedulePrintDeliveriesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly slot: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly slot: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly slot: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly slot: StringType;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly press: StringType;
+            readonly slot: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly press: StringType;
+                    readonly slot: StringType;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly press: StringType;
+                    readonly slot: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly title: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly at: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly press: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly slot: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** A duty: the Roster's roles beside fields of the app's own. */
+export declare const ScheduleDuty: StructType<{
+    readonly who: VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>;
+/** A duty with only the Roster's required roles, its person a plain key. */
+export declare const SchedulePlainDuty: StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>;
+/** A bin: the Allocation's roles beside the yard's own fields. */
+export declare const ScheduleBin: StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: OptionType<StringType>;
+    readonly m3: FloatType;
+    readonly kilns: DictType<StringType, FloatType>;
+    readonly dryFor: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly spec: OptionType<StringType>;
+    readonly specMeasured: StringType;
+    readonly instruction: OptionType<StringType>;
+}>;
+/** A week of the app's: its status, the proposals it dismissed, and a field of its own. */
+export declare const ScheduleWeek: StructType<{
+    readonly state: VariantType<{
+        readonly open: NullType;
+        readonly issued: StructType<{
+            readonly at: DateTimeType;
+        }>;
+        readonly cancelled: NullType;
+    }>;
+    readonly dismissed: SetType<StringType>;
+    readonly approver: OptionType<StringType>;
+}>;
+/** A day of the app's, its published case holding nothing. */
+export declare const ScheduleDay: StructType<{
+    readonly state: VariantType<{
+        readonly draft: NullType;
+        readonly issued: NullType;
+    }>;
+    readonly notes: StringType;
+}>;
+/** The duties: a lead's early shift and an agency's late in the week of 8 March 2027, and the lead's a fortnight on. */
+export declare const scheduleDuties: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly who: VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schedule_duties">]>;
+export declare const scheduleDutiesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly who: VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly who: VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly who: VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly who: VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>;
+        insert: StructType<{
+            readonly who: VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly who: VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+                after: StructType<{
+                    readonly who: VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly who: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly staff: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly agency: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly shift: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly role: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly task: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly unpaidBreak: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly costCentre: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly note: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The duties by the days each touches, as a large record's day index files them. */
+export declare const scheduleDutiesByDay: import("@elaraai/e3").RecordIndexDef<"schedule_duties_by_day", DictType<StringType, StructType<{
+    readonly who: VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, DateTimeType, NullType, undefined> & {
+    interval: undefined;
+};
+/** Duties with only the Roster's required roles. */
+export declare const schedulePlainDuties: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schedule_plain_duties">]>;
+export declare const schedulePlainDutiesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>;
+        insert: StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly person: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                }>;
+                after: StructType<{
+                    readonly person: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly person: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly shift: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The bins: one on Tuesday 11 May 2027, on its kiln. */
+export declare const scheduleBins: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: OptionType<StringType>;
+    readonly m3: FloatType;
+    readonly kilns: DictType<StringType, FloatType>;
+    readonly dryFor: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly spec: OptionType<StringType>;
+    readonly specMeasured: StringType;
+    readonly instruction: OptionType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_bins">]>;
+export declare const scheduleBinsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: OptionType<StringType>;
+    readonly m3: FloatType;
+    readonly kilns: DictType<StringType, FloatType>;
+    readonly dryFor: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly spec: OptionType<StringType>;
+    readonly specMeasured: StringType;
+    readonly instruction: OptionType<StringType>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly bay: StringType;
+            readonly at: DateTimeType;
+            readonly load: OptionType<StringType>;
+            readonly m3: FloatType;
+            readonly kilns: DictType<StringType, FloatType>;
+            readonly dryFor: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly spec: OptionType<StringType>;
+            readonly specMeasured: StringType;
+            readonly instruction: OptionType<StringType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly bay: StringType;
+            readonly at: DateTimeType;
+            readonly load: OptionType<StringType>;
+            readonly m3: FloatType;
+            readonly kilns: DictType<StringType, FloatType>;
+            readonly dryFor: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly spec: OptionType<StringType>;
+            readonly specMeasured: StringType;
+            readonly instruction: OptionType<StringType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly bay: StringType;
+            readonly at: DateTimeType;
+            readonly load: OptionType<StringType>;
+            readonly m3: FloatType;
+            readonly kilns: DictType<StringType, FloatType>;
+            readonly dryFor: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly spec: OptionType<StringType>;
+            readonly specMeasured: StringType;
+            readonly instruction: OptionType<StringType>;
+        }>;
+        insert: StructType<{
+            readonly bay: StringType;
+            readonly at: DateTimeType;
+            readonly load: OptionType<StringType>;
+            readonly m3: FloatType;
+            readonly kilns: DictType<StringType, FloatType>;
+            readonly dryFor: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly spec: OptionType<StringType>;
+            readonly specMeasured: StringType;
+            readonly instruction: OptionType<StringType>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly bay: StringType;
+                    readonly at: DateTimeType;
+                    readonly load: OptionType<StringType>;
+                    readonly m3: FloatType;
+                    readonly kilns: DictType<StringType, FloatType>;
+                    readonly dryFor: VariantType<{
+                        readonly minutes: FloatType;
+                        readonly hours: FloatType;
+                        readonly days: FloatType;
+                        readonly weeks: FloatType;
+                        readonly months: FloatType;
+                    }>;
+                    readonly spec: OptionType<StringType>;
+                    readonly specMeasured: StringType;
+                    readonly instruction: OptionType<StringType>;
+                }>;
+                after: StructType<{
+                    readonly bay: StringType;
+                    readonly at: DateTimeType;
+                    readonly load: OptionType<StringType>;
+                    readonly m3: FloatType;
+                    readonly kilns: DictType<StringType, FloatType>;
+                    readonly dryFor: VariantType<{
+                        readonly minutes: FloatType;
+                        readonly hours: FloatType;
+                        readonly days: FloatType;
+                        readonly weeks: FloatType;
+                        readonly months: FloatType;
+                    }>;
+                    readonly spec: OptionType<StringType>;
+                    readonly specMeasured: StringType;
+                    readonly instruction: OptionType<StringType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly bay: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly at: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly load: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly m3: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly kilns: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DictType<StringType, FloatType>;
+                        after: DictType<StringType, FloatType>;
+                    }>;
+                    patch: DictType<StringType, VariantType<{
+                        delete: FloatType;
+                        insert: FloatType;
+                        update: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly dryFor: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly minutes: FloatType;
+                            readonly hours: FloatType;
+                            readonly days: FloatType;
+                            readonly weeks: FloatType;
+                            readonly months: FloatType;
+                        }>;
+                        after: VariantType<{
+                            readonly minutes: FloatType;
+                            readonly hours: FloatType;
+                            readonly days: FloatType;
+                            readonly weeks: FloatType;
+                            readonly months: FloatType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly minutes: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly hours: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly days: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly weeks: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                        readonly months: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly spec: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly specMeasured: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly instruction: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The weeks: one issued, the next open, the one after cancelled. */
+export declare const scheduleWeeks: import("@elaraai/e3").RecordDef<DictType<DateTimeType, StructType<{
+    readonly state: VariantType<{
+        readonly open: NullType;
+        readonly issued: StructType<{
+            readonly at: DateTimeType;
+        }>;
+        readonly cancelled: NullType;
+    }>;
+    readonly dismissed: SetType<StringType>;
+    readonly approver: OptionType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "schedule_weeks">]>;
+export declare const scheduleWeeksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, StructType<{
+    readonly state: VariantType<{
+        readonly open: NullType;
+        readonly issued: StructType<{
+            readonly at: DateTimeType;
+        }>;
+        readonly cancelled: NullType;
+    }>;
+    readonly dismissed: SetType<StringType>;
+    readonly approver: OptionType<StringType>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<DateTimeType, StructType<{
+            readonly state: VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+                readonly cancelled: NullType;
+            }>;
+            readonly dismissed: SetType<StringType>;
+            readonly approver: OptionType<StringType>;
+        }>>;
+        after: DictType<DateTimeType, StructType<{
+            readonly state: VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+                readonly cancelled: NullType;
+            }>;
+            readonly dismissed: SetType<StringType>;
+            readonly approver: OptionType<StringType>;
+        }>>;
+    }>;
+    patch: DictType<DateTimeType, VariantType<{
+        delete: StructType<{
+            readonly state: VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+                readonly cancelled: NullType;
+            }>;
+            readonly dismissed: SetType<StringType>;
+            readonly approver: OptionType<StringType>;
+        }>;
+        insert: StructType<{
+            readonly state: VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+                readonly cancelled: NullType;
+            }>;
+            readonly dismissed: SetType<StringType>;
+            readonly approver: OptionType<StringType>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly state: VariantType<{
+                        readonly open: NullType;
+                        readonly issued: StructType<{
+                            readonly at: DateTimeType;
+                        }>;
+                        readonly cancelled: NullType;
+                    }>;
+                    readonly dismissed: SetType<StringType>;
+                    readonly approver: OptionType<StringType>;
+                }>;
+                after: StructType<{
+                    readonly state: VariantType<{
+                        readonly open: NullType;
+                        readonly issued: StructType<{
+                            readonly at: DateTimeType;
+                        }>;
+                        readonly cancelled: NullType;
+                    }>;
+                    readonly dismissed: SetType<StringType>;
+                    readonly approver: OptionType<StringType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly state: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly open: NullType;
+                            readonly issued: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                            readonly cancelled: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly open: NullType;
+                            readonly issued: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                            readonly cancelled: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly open: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly issued: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StructType<{
+                                    readonly at: DateTimeType;
+                                }>;
+                                after: StructType<{
+                                    readonly at: DateTimeType;
+                                }>;
+                            }>;
+                            patch: StructType<{
+                                readonly at: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: DateTimeType;
+                                        after: DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                        readonly cancelled: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly dismissed: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: SetType<StringType>;
+                        after: SetType<StringType>;
+                    }>;
+                    patch: DictType<StringType, VariantType<{
+                        delete: NullType;
+                        insert: NullType;
+                    }>>;
+                }>;
+                readonly approver: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The days: Tuesday 11 May 2027, a draft. */
+export declare const scheduleDays: import("@elaraai/e3").RecordDef<DictType<DateTimeType, StructType<{
+    readonly state: VariantType<{
+        readonly draft: NullType;
+        readonly issued: NullType;
+    }>;
+    readonly notes: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schedule_days">]>;
+export declare const scheduleDaysPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, StructType<{
+    readonly state: VariantType<{
+        readonly draft: NullType;
+        readonly issued: NullType;
+    }>;
+    readonly notes: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<DateTimeType, StructType<{
+            readonly state: VariantType<{
+                readonly draft: NullType;
+                readonly issued: NullType;
+            }>;
+            readonly notes: StringType;
+        }>>;
+        after: DictType<DateTimeType, StructType<{
+            readonly state: VariantType<{
+                readonly draft: NullType;
+                readonly issued: NullType;
+            }>;
+            readonly notes: StringType;
+        }>>;
+    }>;
+    patch: DictType<DateTimeType, VariantType<{
+        delete: StructType<{
+            readonly state: VariantType<{
+                readonly draft: NullType;
+                readonly issued: NullType;
+            }>;
+            readonly notes: StringType;
+        }>;
+        insert: StructType<{
+            readonly state: VariantType<{
+                readonly draft: NullType;
+                readonly issued: NullType;
+            }>;
+            readonly notes: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly state: VariantType<{
+                        readonly draft: NullType;
+                        readonly issued: NullType;
+                    }>;
+                    readonly notes: StringType;
+                }>;
+                after: StructType<{
+                    readonly state: VariantType<{
+                        readonly draft: NullType;
+                        readonly issued: NullType;
+                    }>;
+                    readonly notes: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly state: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly draft: NullType;
+                            readonly issued: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly draft: NullType;
+                            readonly issued: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly draft: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly issued: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly notes: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+//# sourceMappingURL=schedule.examples.d.ts.map