@elaraai/e3-ui 1.0.98 → 1.0.100

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

@@ -3,22 +3,20 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /** @jsxImportSource @elaraai/e3-ui */
-import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, OptionType, StringType, StructType, variant } from "@elaraai/east";
-/** A job dropped on a press: a decision at the bucket it landed in. */
+import { DateTimeType, DictType, FloatType, IntegerType, OptionType, StringType, StructType, variant } from "@elaraai/east";
+/** A job dropped on a press, under its id: a mark at the bucket it landed in. */
 export declare const PlanPressJob: StructType<{
-    readonly key: StringType;
     readonly at: import("@elaraai/east").VariantType<{
         readonly time: DateTimeType;
         readonly number: FloatType;
         readonly ordinal: StringType;
     }>;
 }>;
-/** A press: its name, the crew that runs it (none yet), and the jobs dropped on it. */
+/** A press: its name, the crew that runs it (none yet), and the jobs dropped on it, by their ids (#1436). */
 export declare const PlanPress: StructType<{
     readonly label: StringType;
     readonly crew: OptionType<StringType>;
-    readonly jobs: ArrayType<StructType<{
-        readonly key: StringType;
+    readonly jobs: DictType<StringType, StructType<{
         readonly at: import("@elaraai/east").VariantType<{
             readonly time: DateTimeType;
             readonly number: FloatType;
@@ -30,152 +28,91 @@ export declare const PlanPress: StructType<{
 export declare const planPresses: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly label: StringType;
     readonly crew: OptionType<StringType>;
-    readonly jobs: ArrayType<StructType<{
-        readonly key: StringType;
+    readonly jobs: DictType<StringType, StructType<{
         readonly at: import("@elaraai/east").VariantType<{
             readonly time: DateTimeType;
             readonly number: FloatType;
             readonly ordinal: StringType;
         }>;
     }>>;
-}>>, [variant<"field", "records">, variant<"field", "plan_presses">]>;
-/** The presses' patch door: a canvas's Save commits through it. */
-export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_presses">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly label: StringType;
     readonly crew: OptionType<StringType>;
-    readonly jobs: ArrayType<StructType<{
-        readonly key: StringType;
+    readonly jobs: DictType<StringType, StructType<{
         readonly at: import("@elaraai/east").VariantType<{
             readonly time: DateTimeType;
             readonly number: FloatType;
             readonly ordinal: StringType;
         }>;
     }>>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly label: StringType;
-            readonly crew: OptionType<StringType>;
-            readonly jobs: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: DateTimeType;
-                    readonly number: FloatType;
-                    readonly ordinal: StringType;
-                }>;
-            }>>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly label: StringType;
-            readonly crew: OptionType<StringType>;
-            readonly jobs: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: DateTimeType;
-                    readonly number: FloatType;
-                    readonly ordinal: StringType;
-                }>;
-            }>>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly label: StringType;
-            readonly crew: OptionType<StringType>;
-            readonly jobs: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: DateTimeType;
-                    readonly number: FloatType;
-                    readonly ordinal: StringType;
-                }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly label: StringType;
+                readonly crew: OptionType<StringType>;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                }>>;
             }>>;
-        }>;
-        insert: StructType<{
-            readonly label: StringType;
-            readonly crew: OptionType<StringType>;
-            readonly jobs: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly at: import("@elaraai/east").VariantType<{
-                    readonly time: DateTimeType;
-                    readonly number: FloatType;
-                    readonly ordinal: StringType;
-                }>;
+            after: DictType<StringType, StructType<{
+                readonly label: StringType;
+                readonly crew: OptionType<StringType>;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
+                    }>;
+                }>>;
             }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly label: StringType;
-                    readonly crew: OptionType<StringType>;
-                    readonly jobs: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: DateTimeType;
-                            readonly number: FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                    }>>;
-                }>;
-                after: StructType<{
-                    readonly label: StringType;
-                    readonly crew: OptionType<StringType>;
-                    readonly jobs: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly at: import("@elaraai/east").VariantType<{
-                            readonly time: DateTimeType;
-                            readonly number: FloatType;
-                            readonly ordinal: StringType;
-                        }>;
-                    }>>;
-                }>;
-            }>;
-            patch: StructType<{
-                readonly label: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly label: StringType;
+                readonly crew: OptionType<StringType>;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
                     }>;
-                }>;
-                readonly crew: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
+                }>>;
+            }>;
+            insert: StructType<{
+                readonly label: StringType;
+                readonly crew: OptionType<StringType>;
+                readonly jobs: DictType<StringType, StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        readonly time: DateTimeType;
+                        readonly number: FloatType;
+                        readonly ordinal: StringType;
                     }>;
-                }>;
-                readonly jobs: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: ArrayType<StructType<{
-                            readonly key: StringType;
+                }>>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly label: StringType;
+                        readonly crew: OptionType<StringType>;
+                        readonly jobs: DictType<StringType, StructType<{
                             readonly at: import("@elaraai/east").VariantType<{
                                 readonly time: DateTimeType;
                                 readonly number: FloatType;
                                 readonly ordinal: StringType;
                             }>;
                         }>>;
-                        after: ArrayType<StructType<{
-                            readonly key: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly label: StringType;
+                        readonly crew: OptionType<StringType>;
+                        readonly jobs: DictType<StringType, StructType<{
                             readonly at: import("@elaraai/east").VariantType<{
                                 readonly time: DateTimeType;
                                 readonly number: FloatType;
@@ -183,12 +120,58 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                             }>;
                         }>>;
                     }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: import("@elaraai/east").VariantType<{
+                }>;
+                patch: StructType<{
+                    readonly label: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly crew: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly jobs: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: DictType<StringType, StructType<{
+                                readonly at: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                            }>>;
+                            after: DictType<StringType, StructType<{
+                                readonly at: import("@elaraai/east").VariantType<{
+                                    readonly time: DateTimeType;
+                                    readonly number: FloatType;
+                                    readonly ordinal: StringType;
+                                }>;
+                            }>>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
                             delete: StructType<{
-                                readonly key: StringType;
                                 readonly at: import("@elaraai/east").VariantType<{
                                     readonly time: DateTimeType;
                                     readonly number: FloatType;
@@ -196,7 +179,6 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                                 }>;
                             }>;
                             insert: StructType<{
-                                readonly key: StringType;
                                 readonly at: import("@elaraai/east").VariantType<{
                                     readonly time: DateTimeType;
                                     readonly number: FloatType;
@@ -207,7 +189,6 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                                 unchanged: import("@elaraai/east").NullType;
                                 replace: StructType<{
                                     before: StructType<{
-                                        readonly key: StringType;
                                         readonly at: import("@elaraai/east").VariantType<{
                                             readonly time: DateTimeType;
                                             readonly number: FloatType;
@@ -215,7 +196,6 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                                         }>;
                                     }>;
                                     after: StructType<{
-                                        readonly key: StringType;
                                         readonly at: import("@elaraai/east").VariantType<{
                                             readonly time: DateTimeType;
                                             readonly number: FloatType;
@@ -224,13 +204,6 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                                     }>;
                                 }>;
                                 patch: StructType<{
-                                    readonly key: import("@elaraai/east").VariantType<{
-                                        unchanged: import("@elaraai/east").NullType;
-                                        replace: StructType<{
-                                            before: StringType;
-                                            after: StringType;
-                                        }>;
-                                    }>;
                                     readonly at: import("@elaraai/east").VariantType<{
                                         unchanged: import("@elaraai/east").NullType;
                                         replace: StructType<{
@@ -271,13 +244,23 @@ export declare const planPressesPatch: import("@elaraai/e3").MutationDef<"patch"
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                    }>>;
+                        }>>;
+                    }>;
                 }>;
             }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly crew: OptionType<StringType>;
+    readonly jobs: DictType<StringType, StructType<{
+        readonly at: import("@elaraai/east").VariantType<{
+            readonly time: DateTimeType;
+            readonly number: FloatType;
+            readonly ordinal: StringType;
         }>;
     }>>;
-}>]>;
+}>>>>;
 /** A row a canvas narrows through its rail: when it falls, its owner and its hall. */
 export declare const PlanDatedRow: StructType<{
     readonly at: DateTimeType;
@@ -289,101 +272,91 @@ export declare const planDatedRows: import("@elaraai/e3").RecordDef<DictType<Str
     readonly at: DateTimeType;
     readonly owner: StringType;
     readonly hall: StringType;
-}>>, [variant<"field", "records">, variant<"field", "plan_dated_rows">]>;
-/** The rows' patch door: another session's rows go in through it. */
-export declare const planDatedRowsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_dated_rows">], import("@elaraai/e3").IndexesOf<{
+    plan_dated_rows_by_at: import("@elaraai/e3").IndexDraft<DateTimeType, import("@elaraai/east").NullType, readonly ["at"], unknown>;
+    plan_dated_rows_by_owner_at: import("@elaraai/e3").IndexDraft<StructType<{
+        at: DateTimeType;
+        owner: StringType;
+    }>, import("@elaraai/east").NullType, readonly ["owner", "at"], unknown>;
+    plan_dated_rows_by_hall_at: import("@elaraai/e3").IndexDraft<StructType<{
+        at: DateTimeType;
+        hall: StringType;
+    }>, import("@elaraai/east").NullType, readonly ["hall", "at"], unknown>;
+}, DictType<StringType, StructType<{
     readonly at: DateTimeType;
     readonly owner: StringType;
     readonly hall: StringType;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly at: DateTimeType;
-            readonly owner: StringType;
-            readonly hall: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly at: DateTimeType;
-            readonly owner: StringType;
-            readonly hall: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly at: DateTimeType;
-            readonly owner: StringType;
-            readonly hall: StringType;
-        }>;
-        insert: StructType<{
-            readonly at: DateTimeType;
-            readonly owner: StringType;
-            readonly hall: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly at: DateTimeType;
+                readonly owner: StringType;
+                readonly hall: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly at: DateTimeType;
+                readonly owner: StringType;
+                readonly hall: StringType;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly at: DateTimeType;
-                    readonly owner: StringType;
-                    readonly hall: StringType;
-                }>;
-                after: StructType<{
-                    readonly at: DateTimeType;
-                    readonly owner: StringType;
-                    readonly hall: StringType;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly at: DateTimeType;
+                readonly owner: StringType;
+                readonly hall: StringType;
+            }>;
+            insert: StructType<{
+                readonly at: DateTimeType;
+                readonly owner: StringType;
+                readonly hall: StringType;
             }>;
-            patch: StructType<{
-                readonly at: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly at: DateTimeType;
+                        readonly owner: StringType;
+                        readonly hall: StringType;
                     }>;
-                }>;
-                readonly owner: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: StructType<{
+                        readonly at: DateTimeType;
+                        readonly owner: StringType;
+                        readonly hall: StringType;
                     }>;
                 }>;
-                readonly hall: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                patch: StructType<{
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                    readonly owner: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly hall: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The rows by date: the window's index. */
-export declare const planDatedRowsByAt: import("@elaraai/e3").RecordIndexDef<"plan_dated_rows_by_at", DictType<StringType, StructType<{
-    readonly at: DateTimeType;
-    readonly owner: StringType;
-    readonly hall: StringType;
-}>>, DateTimeType, import("@elaraai/east").NullType, readonly ["at"]>;
-/** The rows by owner, then date: an owner chosen beside the window. */
-export declare const planDatedRowsByOwnerAt: import("@elaraai/e3").RecordIndexDef<"plan_dated_rows_by_owner_at", DictType<StringType, StructType<{
-    readonly at: DateTimeType;
-    readonly owner: StringType;
-    readonly hall: StringType;
-}>>, StructType<{
-    at: DateTimeType;
-    owner: StringType;
-}>, import("@elaraai/east").NullType, readonly ["owner", "at"]>;
-/** The rows by hall, then date: a hall chosen beside the window. */
-export declare const planDatedRowsByHallAt: import("@elaraai/e3").RecordIndexDef<"plan_dated_rows_by_hall_at", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly at: DateTimeType;
     readonly owner: StringType;
     readonly hall: StringType;
-}>>, StructType<{
-    at: DateTimeType;
-    hall: StringType;
-}>, import("@elaraai/east").NullType, readonly ["hall", "at"]>;
+}>>>>;
 /** An order on a number axis: the day it is due. */
 export declare const PlanDayOrder: StructType<{
     readonly day: IntegerType;
@@ -391,11 +364,13 @@ export declare const PlanDayOrder: StructType<{
 /** Twelve orders, one a day from day 1 to day 12: a number axis's window is a range of their days. */
 export declare const planDayOrders: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly day: IntegerType;
-}>>, [variant<"field", "records">, variant<"field", "plan_day_orders">]>;
-/** The orders by day. */
-export declare const planDayOrdersByDay: import("@elaraai/e3").RecordIndexDef<"plan_day_orders_by_day", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_day_orders">], import("@elaraai/e3").IndexesOf<{
+    plan_day_orders_by_day: import("@elaraai/e3").IndexDraft<IntegerType, import("@elaraai/east").NullType, readonly ["day"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly day: IntegerType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
     readonly day: IntegerType;
-}>>, IntegerType, import("@elaraai/east").NullType, readonly ["day"]>;
+}>>>>;
 /** A van's run on a number axis: the day it leaves, which may fall part way through one. */
 export declare const PlanDayVan: StructType<{
     readonly day: FloatType;
@@ -403,11 +378,13 @@ export declare const PlanDayVan: StructType<{
 /** Two vans, leaving on day 1 and on day 12: a number axis's window is a range of their days. */
 export declare const planDayVans: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly day: FloatType;
-}>>, [variant<"field", "records">, variant<"field", "plan_day_vans">]>;
-/** The vans by day. */
-export declare const planDayVansByDay: import("@elaraai/e3").RecordIndexDef<"plan_day_vans_by_day", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_day_vans">], import("@elaraai/e3").IndexesOf<{
+    plan_day_vans_by_day: import("@elaraai/e3").IndexDraft<FloatType, import("@elaraai/east").NullType, readonly ["day"], unknown>;
+}, DictType<StringType, StructType<{
     readonly day: FloatType;
-}>>, FloatType, import("@elaraai/east").NullType, readonly ["day"]>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly day: FloatType;
+}>>>>;
 /** An operation on a work order: the order it is on, by its key, the work it does, and when it runs. */
 export declare const PlanOperation: StructType<{
     readonly work: StringType;
@@ -430,151 +407,140 @@ export declare const planOperations: import("@elaraai/e3").RecordDef<DictType<St
     readonly label: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-}>>, [variant<"field", "records">, variant<"field", "plan_operations">]>;
-/** The operations' patch door: a canvas's Save commits through it, by the operation's key. */
-export declare const planOperationsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_operations">], import("@elaraai/e3").IndexesOf<{
+    plan_operations_by_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: DateTimeType;
+    }>, import("@elaraai/east").NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    plan_operations_by_work_week: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        key: StringType;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, StructType<{
+        readonly work: StringType;
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>, readonly [], {
+        readonly series: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "work";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
+        }>;
+    }>;
+    plan_operations_by_work_month: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        key: StringType;
+        tile: DateTimeType;
+    }>, StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly [], {
+        readonly summary: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "work";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
     readonly work: StringType;
     readonly label: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly work: StringType;
-            readonly label: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly work: StringType;
-            readonly label: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly work: StringType;
-            readonly label: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>;
-        insert: StructType<{
-            readonly work: StringType;
-            readonly label: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly work: StringType;
+                readonly label: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly work: StringType;
+                readonly label: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly work: StringType;
-                    readonly label: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                }>;
-                after: StructType<{
-                    readonly work: StringType;
-                    readonly label: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly work: StringType;
+                readonly label: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
             }>;
-            patch: StructType<{
-                readonly work: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            insert: StructType<{
+                readonly work: StringType;
+                readonly label: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly work: StringType;
+                        readonly label: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
                     }>;
-                }>;
-                readonly label: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: StructType<{
+                        readonly work: StringType;
+                        readonly label: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
                     }>;
                 }>;
-                readonly start: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                patch: StructType<{
+                    readonly work: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    readonly label: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The operations over the interval each runs: the canvas's window, and the rail's exact count of the operations in it. */
-export declare const planOperationsByTime: import("@elaraai/e3").RecordIndexDef<"plan_operations_by_time", DictType<StringType, StructType<{
-    readonly work: StringType;
-    readonly label: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>>, StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: DateTimeType;
-}>, import("@elaraai/east").NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-/** The operations by their work order and the weeks they touch: a cell is the operations of fifty orders in one week. */
-export declare const planOperationsByWorkWeek: import("@elaraai/e3").RecordIndexDef<"plan_operations_by_work_week", DictType<StringType, StructType<{
-    readonly work: StringType;
-    readonly label: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>>, StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    work: StringType;
-}>, StructType<{
-    readonly work: StringType;
-    readonly label: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>, readonly ["__tile", "work"]> & {
-    series: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "work";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "week";
-    }>;
-};
-/** How busy each work order is, a month at a time: what the canvas shades where the operations in view are too many to draw. */
-export declare const planOperationsByWorkMonth: import("@elaraai/e3").RecordIndexDef<"plan_operations_by_work_month", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly work: StringType;
     readonly label: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-}>>, StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    work: StringType;
-}>, StructType<{
-    readonly count: IntegerType;
-    readonly ms: IntegerType;
-}>, readonly ["__tile", "work"]> & {
-    summary: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "work";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "month";
-    }>;
-};
+}>>>>;
 /**
  * The Sheet's 50,000 work orders on a Plan, a row each, and their operations
  * a record of their own placed on them (#1344, #1039). The work orders are a