@elaraai/e3-ui 1.0.97 → 1.0.99

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 } 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;
         }>;
     }>>;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").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;
-                    }>;
-                }>;
-                readonly crew: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<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;
                     }>;
-                    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,107 +272,91 @@ export declare const planDatedRows: import("@elaraai/e3").RecordDef<DictType<Str
     readonly at: DateTimeType;
     readonly owner: StringType;
     readonly hall: StringType;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").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"]> & {
-    interval: undefined;
-};
-/** 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"]> & {
-    interval: undefined;
-};
-/** 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"]> & {
-    interval: undefined;
-};
+}>>>>;
 /** An order on a number axis: the day it is due. */
 export declare const PlanDayOrder: StructType<{
     readonly day: IntegerType;
@@ -397,13 +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;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").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"]> & {
-    interval: undefined;
-};
+}>>>>;
 /** 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;
@@ -411,13 +378,193 @@ 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;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").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"]> & {
-    interval: undefined;
-};
+}>>>, 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;
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>;
+/** How many work orders' operations the task generates: the Sheet's 50,000 orders'. */
+export declare const planOperationCount: import("@elaraai/e3").DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "plan_operation_count">]>;
+/** The task that generates the operations from their count. */
+export declare const planOperationsGenerated: import("@elaraai/e3").TaskDef<DictType<StringType, StructType<{
+    readonly work: StringType;
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>, [variant<"field", "tasks">, variant<"field", "plan_operations_generated">, variant<"field", "output">]>;
+/** The 50,000 work orders' operations, one an order, keyed by the operation's key: read through the indexes below, never whole. */
+export declare const planOperations: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly work: StringType;
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>, [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/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;
+            }>>;
+        }>;
+        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;
+            }>;
+            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: StructType<{
+                    readonly work: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    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;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly work: StringType;
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>>>;
+/**
+ * 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
+ * paged resource kind, narrowed through the rail's `orders` source — named
+ * after the kind's slot — over their indexes: by Status, Due, Job, Quantity,
+ * Urgent and Tag, with the presets and the search, opening on the orders Ready
+ * and due in the first fortnight of October. The canvas pages the narrowing's
+ * orders themselves, in its index's order, and the dates on screen never
+ * decide which are listed: Due is a field of the rail the viewer sets. The
+ * rail's `operation` source lists the operations' interval index, their series
+ * index and their summary, its range their start, so it holds the canvas's
+ * window: the canvas reads the operations of the orders in view a cell at a
+ * time, a pan within the weeks it holds reads nothing, and the orders' rows
+ * stay where they are as the dates move. Moving or resizing an operation
+ * drafts it in the operations kind's session, whatever the rail shows, and
+ * Save commits it through the operations' patch door by its key — so a
+ * million work orders, each with a year of operations, read what is on screen.
+ */
 export declare const planRecordIndexes: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * The work orders Plan of `planRecordIndexes` in a phone-width frame: the same
+ * paged work orders narrowed through the same rail, on the toolbar's responsive
+ * ladder, and the same operations read a cell at a time, their source holding
+ * the canvas's window — the narrow layout's cards drawn from the same reads.
+ */
 export declare const planRecordIndexesMobile: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=plan-records.examples.d.ts.map