@elaraai/e3-ui 1.0.85 → 1.0.87

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

@@ -0,0 +1,3666 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+import { ArrayType, DateTimeType, DictType, FloatType, NullType, OptionType, StringType, StructType, VariantType, variant } from "@elaraai/east";
+/** A press: its name, its hall and the sheets it prints an hour. */
+export declare const PrintPress: StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly sheets_per_hour: FloatType;
+}>;
+/** A crew: its name and its hall. */
+export declare const PrintCrew: StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+}>;
+/**
+ * A print job: when it runs and on which press — none of the three while it
+ * waits in the backlog — the lifecycle it wears, its sheets, and the
+ * customer's details.
+ */
+export declare const PrintJob: 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 on a press, at one instant: a plate change or a service. */
+export declare const PrintStop: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly press: StringType;
+    readonly kind: VariantType<{
+        readonly plate_change: NullType;
+        readonly service: NullType;
+    }>;
+}>;
+/** A crew's shift. */
+export declare const PrintShift: 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 customer: its name, the district it is in and its trade. */
+export declare const PrintCustomer: StructType<{
+    readonly name: StringType;
+    readonly district: StringType;
+    readonly trade: StringType;
+}>;
+/** The presses: three in each hall. A Plan never writes its resources. */
+export declare const planPrintPresses: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly sheets_per_hour: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_presses">]>;
+/** The crews: two in each hall. */
+export declare const planPrintCrews: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_crews">]>;
+/**
+ * The print jobs: actual before 14 October, in progress on it, confirmed,
+ * proposed and estimated after it; two overlapping on Press B2 on the 20th;
+ * and eight with no start waiting in the backlog, two due this week, two next
+ * week, two later and two with no due date.
+ */
+export declare const planPrintJobs: 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", "plan_print_jobs">]>;
+/** The jobs' patch door: every Save commits through it. */
+export declare const planPrintJobsPatch: 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: plate changes and services across the presses. */
+export declare const planPrintStops: 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", "plan_print_stops">]>;
+/** The stops' patch door. */
+export declare const planPrintStopsPatch: 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 shifts: each crew's early and late shifts, confirmed for the first two weeks and proposed for the last two. */
+export declare const planPrintShifts: 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", "plan_print_shifts">]>;
+/** The shifts' patch door. */
+export declare const planPrintShiftsPatch: 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 customers the jobs are printed for, by account, in three districts: what the print works' library lists. A Plan never writes them. */
+export declare const planPrintCustomers: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly district: StringType;
+    readonly trade: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_customers">]>;
+/**
+ * Each press's utilisation (%): a reading a day from 5 October, as the
+ * dataflow measures it, idle at the weekends. Press B2's 97 on the 20th is
+ * the day its two jobs overlap.
+ */
+export declare const planPrintUtilisation: import("@elaraai/e3").DatasetDef<DictType<StringType, ArrayType<FloatType>>, [variant<"field", "inputs">, variant<"field", "plan_print_utilisation">]>;
+/** The sheets printed each day from 5 October, across every press. */
+export declare const planPrintOutput: import("@elaraai/e3").DatasetDef<ArrayType<FloatType>, [variant<"field", "inputs">, variant<"field", "plan_print_output">]>;
+/**
+ * The smallest builder's jobs, a record of its own: eight on the presses, two
+ * of them overlapping on Press B2 on the 20th; one timed and given no press
+ * yet; and three with no start waiting in the backlog, due this week, next
+ * week and never.
+ */
+export declare const planEventJobs: 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", "plan_event_jobs">]>;
+/** The smallest builder's jobs' patch door: its Save commits through it. */
+export declare const planEventJobsPatch: 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 smallest builder (`Plan Builder Spec.md` §3.2): a row per press, each
+ * job a bar on its press, the jobs a record of the example's own. Jobs move
+ * and resize along a press and between presses, and Save commits the drafts
+ * as one patch through the jobs' patch door. Its library lists the backlog,
+ * the jobs with no start by when each is due, and the customers, a card
+ * apiece that sets the customer of the job it is dropped on
+ * (`Schedule.patch`). Its inspector shows what is selected: a job through the
+ * form its customer and stock are hinted for. Press B2's two jobs on the 20th
+ * overlap, and the toolbar's chip counts them; a job timed on no press draws
+ * on the jobs' Unassigned row. Its `id` keeps its panes and its library's
+ * cards apart from the print works' on the same surface. The two `Schedule`
+ * values are exactly what a Calendar takes.
+ */
+export declare const planEvents: import("@elaraai/east").ExampleDef<[], any>;
+/** A paper stock: its name, and its level in thousands of sheets, a reading a week from 5 October. */
+export declare const PrintStock: StructType<{
+    readonly name: StringType;
+    readonly weekly: ArrayType<FloatType>;
+}>;
+/** Four jobs on the print works' presses — the covers and the sleeves on Press B3, and the handbooks and the boxes they go into on Press A1 — which the Plan's specs read as a second kind of job. */
+export declare const planLinkJobs: 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", "plan_link_jobs">]>;
+/** The linked jobs' patch door. */
+export declare const planLinkJobsPatch: 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 paper in stock. */
+export declare const planLinkStock: import("@elaraai/e3").DatasetDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly weekly: ArrayType<FloatType>;
+}>>, [variant<"field", "inputs">, variant<"field", "plan_link_stock">]>;
+/** A work centre a job passes through on its way out: the platesetter, the bindery's folder and binder, the dispatch bay. */
+export declare const PrintCentre: StructType<{
+    readonly name: StringType;
+}>;
+/** A set of plates the platesetter makes for a job, at the moment it makes them. */
+export declare const PrintPlates: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly setter: StringType;
+}>;
+/** A bindery job — folding a press job's sections, or binding them — on the folder or the binder. */
+export declare const PrintBinding: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly line: 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 leaving the dispatch bay. */
+export declare const PrintDelivery: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly bay: StringType;
+}>;
+/** The platesetter. A Plan never writes its resources. */
+export declare const planLinkSetters: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_link_setters">]>;
+/** The bindery's two lines. */
+export declare const planLinkLines: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_link_lines">]>;
+/** The dispatch bay. */
+export declare const planLinkBays: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_link_bays">]>;
+/** The plates for the catalogue covers, made on the window's first day. */
+export declare const planLinkPlates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly setter: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_link_plates">]>;
+/** The plates' patch door. */
+export declare const planLinkPlatesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly setter: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly setter: StringType;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly setter: 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 setter: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/**
+ * The jobs the links join, on the six presses. Each link's jobs sit where its
+ * figure needs them: a job of two hours, which draws the narrowest bar; a job
+ * running in from before the window; one that ends before it starts, and one
+ * that starts after it ends; two jobs back to back on one press.
+ */
+export declare const planLinkCaseJobs: 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", "plan_link_case_jobs">]>;
+/** The jobs' patch door. */
+export declare const planLinkCaseJobsPatch: 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 bindery's jobs: two foldings of the book's sections, and two bindings. */
+export declare const planLinkBindings: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly line: 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", "plan_link_bindings">]>;
+/** The bindery's patch door. */
+export declare const planLinkBindingsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly line: 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 line: 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 line: 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 line: 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 line: 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 line: 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 line: 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 line: 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: the shop posters in the third week, the bound books in the fourth. */
+export declare const planLinkDeliveries: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly bay: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_link_deliveries">]>;
+/** The deliveries' patch door. */
+export declare const planLinkDeliveriesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly bay: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly bay: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly bay: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly bay: StringType;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly bay: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly bay: StringType;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly bay: 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 bay: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The parent of the shared folder and binder, held in a record like every other resource. */
+export declare const planPrintBindery: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_bindery">]>;
+/** The vans a delivery can move onto from the dispatch bay. */
+export declare const planPrintVans: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_vans">]>;
+/** A delivery's own status, separate from the schedule's lifecycle. */
+export declare const PrintDispatchStatus: VariantType<{
+    readonly queued: NullType;
+    readonly ready: NullType;
+    readonly dispatched: NullType;
+}>;
+/** A delivery on a bay or a van: the variant preserves the resource kind when it moves. */
+export declare const PrintDispatch: StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly location: VariantType<{
+        readonly bay: StringType;
+        readonly van: StringType;
+    }>;
+    readonly lane: StringType;
+    readonly status: VariantType<{
+        readonly queued: NullType;
+        readonly ready: NullType;
+        readonly dispatched: NullType;
+    }>;
+    readonly pallets: FloatType;
+}>;
+/** The print works' own plate orders, timed before its existing jobs. */
+export declare const planPrintPlates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly setter: StringType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_plates">]>;
+/** The print works' plates commit through their own patch door. */
+export declare const planPrintPlatesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly setter: StringType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly setter: StringType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly setter: StringType;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly setter: 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 setter: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** Two foldings run in parallel, followed by binding, after the handbook leaves Press A1. */
+export declare const planPrintBindings: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly line: 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", "plan_print_bindings">]>;
+/** The print works' bindery jobs commit through their own patch door. */
+export declare const planPrintBindingsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly line: 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 line: 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 line: 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 line: 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 line: 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 line: 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 line: 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 line: 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;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** Deliveries occupy AM/PM lanes and carry each of the dispatch statuses. */
+export declare const planPrintDeliveries: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly location: VariantType<{
+        readonly bay: StringType;
+        readonly van: StringType;
+    }>;
+    readonly lane: StringType;
+    readonly status: VariantType<{
+        readonly queued: NullType;
+        readonly ready: NullType;
+        readonly dispatched: NullType;
+    }>;
+    readonly pallets: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "plan_print_deliveries">]>;
+/** The print works' deliveries commit through their own patch door. */
+export declare const planPrintDeliveriesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly at: DateTimeType;
+    readonly location: VariantType<{
+        readonly bay: StringType;
+        readonly van: StringType;
+    }>;
+    readonly lane: StringType;
+    readonly status: VariantType<{
+        readonly queued: NullType;
+        readonly ready: NullType;
+        readonly dispatched: NullType;
+    }>;
+    readonly pallets: FloatType;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly location: VariantType<{
+                readonly bay: StringType;
+                readonly van: StringType;
+            }>;
+            readonly lane: StringType;
+            readonly status: VariantType<{
+                readonly queued: NullType;
+                readonly ready: NullType;
+                readonly dispatched: NullType;
+            }>;
+            readonly pallets: FloatType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly location: VariantType<{
+                readonly bay: StringType;
+                readonly van: StringType;
+            }>;
+            readonly lane: StringType;
+            readonly status: VariantType<{
+                readonly queued: NullType;
+                readonly ready: NullType;
+                readonly dispatched: NullType;
+            }>;
+            readonly pallets: FloatType;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly location: VariantType<{
+                readonly bay: StringType;
+                readonly van: StringType;
+            }>;
+            readonly lane: StringType;
+            readonly status: VariantType<{
+                readonly queued: NullType;
+                readonly ready: NullType;
+                readonly dispatched: NullType;
+            }>;
+            readonly pallets: FloatType;
+        }>;
+        insert: StructType<{
+            readonly title: StringType;
+            readonly at: DateTimeType;
+            readonly location: VariantType<{
+                readonly bay: StringType;
+                readonly van: StringType;
+            }>;
+            readonly lane: StringType;
+            readonly status: VariantType<{
+                readonly queued: NullType;
+                readonly ready: NullType;
+                readonly dispatched: NullType;
+            }>;
+            readonly pallets: FloatType;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly location: VariantType<{
+                        readonly bay: StringType;
+                        readonly van: StringType;
+                    }>;
+                    readonly lane: StringType;
+                    readonly status: VariantType<{
+                        readonly queued: NullType;
+                        readonly ready: NullType;
+                        readonly dispatched: NullType;
+                    }>;
+                    readonly pallets: FloatType;
+                }>;
+                after: StructType<{
+                    readonly title: StringType;
+                    readonly at: DateTimeType;
+                    readonly location: VariantType<{
+                        readonly bay: StringType;
+                        readonly van: StringType;
+                    }>;
+                    readonly lane: StringType;
+                    readonly status: VariantType<{
+                        readonly queued: NullType;
+                        readonly ready: NullType;
+                        readonly dispatched: NullType;
+                    }>;
+                    readonly pallets: FloatType;
+                }>;
+            }>;
+            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 location: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly bay: StringType;
+                            readonly van: StringType;
+                        }>;
+                        after: VariantType<{
+                            readonly bay: StringType;
+                            readonly van: StringType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly bay: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly van: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly lane: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly status: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: VariantType<{
+                            readonly queued: NullType;
+                            readonly ready: NullType;
+                            readonly dispatched: NullType;
+                        }>;
+                        after: VariantType<{
+                            readonly queued: NullType;
+                            readonly ready: NullType;
+                            readonly dispatched: NullType;
+                        }>;
+                    }>;
+                    patch: VariantType<{
+                        readonly queued: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly ready: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly dispatched: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly pallets: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/**
+ * The print works (`Plan Builder Spec.md` §3.3): two resource kinds grouped
+ * by hall, nested finishing resources and deliveries on bays or vans. Jobs
+ * draw as bars, stops and plates as marks
+ * at their instants, shifts as chips — a utilisation heat row under each
+ * press, and a pinned chart of the sheets printed each day. Each
+ * kind declares its templates. Its library (#1195) lists every kind's
+ * templates, the backlog, the series a viewer shows and hides, and the
+ * customers, a card apiece that sets the customer of the job it is dropped
+ * on. Its inspector (#1197) shows what is selected: a job through the form
+ * its customer, stock and sheets are hinted for, and a stop through the
+ * stop kind's own inspector, which chooses a plate change or a service on a
+ * segment. The same Slice owns the range and resolution; links connect the
+ * plates, printing, binding and dispatch. Delivery readiness holds Save for
+ * an invalid pallet count, while the drop veto explains a press in service.
+ */
+export declare const planPrintWorks: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * Every way a link draws (`Plan links.html`, `Plan Builder Spec.md` §4.3,
+ * PB10, #1258): a print works' jobs from the plates that start them, across its
+ * presses, through the bindery to the dispatch bay — each link's ends named by
+ * event (`Plan.eventRef`), so it draws between the elements wherever they draw.
+ * Press a row's link control to see them. Each link is one of the grammar's
+ * cases, its quantity sizing it against the family's largest:
+ *
+ * - from the plates, a mark, into the catalogue covers: an S down, with no
+ *   quantity — the thinnest weight, no caption;
+ * - from the covers, a two-hour job drawn the narrowest bar, into the
+ *   catalogue: an S down, out of the bar's end as drawn;
+ * - from the card stock up into the menu cards: an S up;
+ * - from the catalogue inserts into the store flyers, which start first: the
+ *   loopback down, on the lane halfway between them;
+ * - from the report covers up into the annual report: the loopback up;
+ * - from the seed catalogue into the seed packets on the press below: the
+ *   loopback between adjacent rows;
+ * - from the gift tags into the gift boxes on one press: a straight feed;
+ * - from the desk calendars into the calendar pads, back to back on one press:
+ *   the runoff stubs;
+ * - from the proof run, in from before the window, into the night run at its
+ *   start: the loopback that drops onto the night run's start — nothing of a
+ *   link crosses into the gutter;
+ * - from the proof sheets, ended before the window, and into the spring
+ *   brochure, after it: each end in a dashed slot on the plot's edge;
+ * - from the book sections into the folder's two jobs: two S's out of one end,
+ *   the second caption stepped under the first; then from the folder into the
+ *   binder, chip to chip, and from the binder into the books' delivery, met at
+ *   its week's cell;
+ * - from the shop posters straight to their delivery: an S down the canvas,
+ *   and from the exhibition book back into its binding: a loopback down.
+ *
+ * The canvas is bounded, so its rows scroll: a link to a row out of view meets
+ * the view's edge in a stub pointing at it, and one between rows past both
+ * edges crosses the view as a band. The now line and the row controls draw
+ * over the links.
+ *
+ * Below the event kinds' rows, the paper in stock is a table over a dataset
+ * (`Plan.over`), a reading a week, read only: a Plan's edits go through its
+ * event kinds.
+ */
+export declare const planEventLinks: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=plan-events.examples.d.ts.map