@elaraai/e3-ui 1.0.94 → 1.0.96

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

@@ -118,6 +118,114 @@ export declare const sheetJobsPatch: import("@elaraai/e3").MutationDef<"patch",
         }>;
     }>>;
 }>]>;
+/** The jobs again, as the edge bander's week holds them: a Save over them is refused for a reason the record gives. */
+export declare const sheetBookedJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly task: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly qty: OptionType<FloatType>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_booked_jobs">]>;
+/** The booked jobs' patch door: it commits a patch unless a job it leaves bands both edges — the edge bander is booked that week. */
+export declare const sheetBookedJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly task: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly qty: OptionType<FloatType>;
+}>>, [VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly task: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly qty: OptionType<FloatType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly task: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly qty: OptionType<FloatType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, VariantType<{
+        delete: StructType<{
+            readonly task: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly qty: OptionType<FloatType>;
+        }>;
+        insert: StructType<{
+            readonly task: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly qty: OptionType<FloatType>;
+        }>;
+        update: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly task: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly qty: OptionType<FloatType>;
+                }>;
+                after: StructType<{
+                    readonly task: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly qty: OptionType<FloatType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly task: 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 qty: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<FloatType>;
+                        after: OptionType<FloatType>;
+                    }>;
+                    patch: VariantType<{
+                        none: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
 /**
  * The smallest sheet (§3.1) — the jobs an e3 record holds, in its frame: one
  * row per job in key order and a blank tail for the next, three typed
@@ -411,9 +519,6 @@ export declare const StressJob: StructType<{
     readonly status: StringType;
     readonly qty: OptionType<FloatType>;
 }>;
-/** How many jobs the stress sheet holds — a small authored constant;
- *  {@link sheetStressJobs} makes the rows. */
-export declare const sheetStressJobCount: import("@elaraai/e3").DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "sheet_stress_job_count">]>;
 /**
  * The jobs, generated from their count — four a day from 5 January, the
  * activities in turn: every fifth a routing run naming a count of routers,
@@ -460,8 +565,133 @@ export declare const generateStressJobs: import("@elaraai/east").CallableFunctio
     readonly status: StringType;
     readonly qty: OptionType<FloatType>;
 }>>>;
-/** The task that generates the jobs — its output is what the stress sheet reads. */
-export declare const sheetStressJobs: import("@elaraai/e3").TaskDef<ArrayType<StructType<{
+/** The jobs, keyed by their id — two thousand made by {@link generateStressJobs}: what the stress sheet pages and its rail narrows (#1345). */
+export declare const sheetStressJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly activity: StringType;
+    readonly notes: StringType;
+    readonly stations: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+    readonly status: StringType;
+    readonly qty: OptionType<FloatType>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_stress_jobs">]>;
+/** The jobs by activity, by status and by their notes: what the rail narrows them by, each choice one index's runs. */
+export declare const sheetStressByActivity: import("@elaraai/e3").RecordIndexDef<"sheet_stress_by_activity", DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly activity: StringType;
+    readonly notes: StringType;
+    readonly stations: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+    readonly status: StringType;
+    readonly qty: OptionType<FloatType>;
+}>>, StringType, NullType, readonly ["activity"]> & {
+    interval: undefined;
+};
+export declare const sheetStressByStatus: import("@elaraai/e3").RecordIndexDef<"sheet_stress_by_status", DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly activity: StringType;
+    readonly notes: StringType;
+    readonly stations: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+    readonly status: StringType;
+    readonly qty: OptionType<FloatType>;
+}>>, StringType, NullType, readonly ["status"]> & {
+    interval: undefined;
+};
+export declare const sheetStressByNotes: import("@elaraai/e3").RecordIndexDef<"sheet_stress_by_notes", DictType<StringType, StructType<{
     readonly id: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly activity: StringType;
@@ -500,18 +730,18 @@ export declare const sheetStressJobs: import("@elaraai/e3").TaskDef<ArrayType<St
     }>;
     readonly status: StringType;
     readonly qty: OptionType<FloatType>;
-}>>, [variant<"field", "tasks">, variant<"field", "sheet_stress_jobs">, variant<"field", "output">]>;
+}>>, StringType, NullType, readonly ["notes"]> & {
+    interval: undefined;
+};
 /**
- * Stress, and the lens (§3.8) — two thousand jobs an e3 task generates, the
- * host's rows (`data`), read only, every row virtualised. Search and filter
- * run through the bound slice; the sheet never narrows, it draws the rows the
- * narrowing leaves as collapsed context bands while hits keep their row
- * numbers. The work centres are a set column searched through its display
- * form (`text: r => Sheet.link.print(r.stations)`); saved views are
- * slice-state snapshots evaluated live, with their context and reveals, the
- * first one open, kept per viewer through a `State` bind handle. The rows
- * are a task's output, made where data is made, so the sheet only reads
- * them. It is given no pane.
+ * Stress (§3.8) — two thousand jobs of an e3 record, read only, every row
+ * virtualised, paged a window at a time. The rail is the sheet's
+ * `Slice.bindRecords`: its `rows` source narrows the jobs by activity, by
+ * status and by a prefix of their notes, each through the record's own index,
+ * and the sheet pages what it narrows to. Saved views each keep every
+ * source's narrowing (`Sheet.Types.RecordView`, its values `.east` literals),
+ * the first one open, kept per viewer through a `State` bind handle. It is
+ * given no pane.
  */
 export declare const sheetStress: import("@elaraai/east").ExampleDef<[], any>;
 /** A task a job takes, and the stage of the work it belongs to. */
@@ -1910,7 +2140,357 @@ export declare const sheetWorkshopOrdersPatch: import("@elaraai/e3").MutationDef
             }>;
         }>;
     }>>;
-}>]>;
+}>]>;
+/** The orders by status and by customer: what the rail narrows them by, each choice one index's runs. */
+export declare const sheetWorkshopOrdersByStatus: import("@elaraai/e3").RecordIndexDef<"sheet_workshop_orders_by_status", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly customer: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly status: StringType;
+    readonly ops: ArrayType<StructType<{
+        readonly activity: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly qty: OptionType<FloatType>;
+        readonly machines: StructType<{
+            readonly from: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+        readonly notes: StringType;
+        readonly created_by: StringType;
+    }>>;
+}>>, StringType, NullType, readonly ["status"]> & {
+    interval: undefined;
+};
+export declare const sheetWorkshopOrdersByCustomer: import("@elaraai/e3").RecordIndexDef<"sheet_workshop_orders_by_customer", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly customer: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly status: StringType;
+    readonly ops: ArrayType<StructType<{
+        readonly activity: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly qty: OptionType<FloatType>;
+        readonly machines: StructType<{
+            readonly from: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+        readonly notes: StringType;
+        readonly created_by: StringType;
+    }>>;
+}>>, StringType, NullType, readonly ["customer"]> & {
+    interval: undefined;
+};
+/** An operation template — the Rows tab's card, the group it sits under, and the activity and work centres it drops. */
+export declare const WorkshopOperationTemplate: StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly activity: StringType;
+    readonly machines: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+}>;
+/** The operation templates, keyed by their key: a record of their own, the rail's `rowTemplates` source (#1345). */
+export declare const sheetWorkshopOperationTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly activity: StringType;
+    readonly machines: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_workshop_operation_templates">]>;
+/** The operation templates by their group: what the rail narrows them by. */
+export declare const sheetWorkshopOperationTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"sheet_workshop_operation_templates_by_group", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly activity: StringType;
+    readonly machines: StructType<{
+        readonly from: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+        readonly to: ArrayType<VariantType<{
+            readonly identified: StructType<{
+                readonly key: StringType;
+            }>;
+            readonly range: StructType<{
+                readonly from: StringType;
+                readonly to: StringType;
+            }>;
+            readonly counted: StructType<{
+                readonly n: IntegerType;
+                readonly key: StringType;
+            }>;
+            readonly placeholder: NullType;
+            readonly text: StringType;
+        }>>;
+    }>;
+}>>, StringType, NullType, readonly ["group"]> & {
+    interval: undefined;
+};
+/** An order template — the Rows tab's card, the group it sits under, and the operations each kind of order starts with. */
+export declare const WorkshopOrderTemplate: StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly ops: ArrayType<StructType<{
+        readonly activity: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly qty: OptionType<FloatType>;
+        readonly machines: StructType<{
+            readonly from: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+        readonly notes: StringType;
+        readonly created_by: StringType;
+    }>>;
+}>;
+/** The order templates, keyed by their key: a record of their own, the rail's `groupTemplates` source (#1345). */
+export declare const sheetWorkshopOrderTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly ops: ArrayType<StructType<{
+        readonly activity: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly qty: OptionType<FloatType>;
+        readonly machines: StructType<{
+            readonly from: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+        readonly notes: StringType;
+        readonly created_by: StringType;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_workshop_order_templates">]>;
+/** The order templates by their group: what the rail narrows them by. */
+export declare const sheetWorkshopOrderTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"sheet_workshop_order_templates_by_group", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly ops: ArrayType<StructType<{
+        readonly activity: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly qty: OptionType<FloatType>;
+        readonly machines: StructType<{
+            readonly from: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+        readonly notes: StringType;
+        readonly created_by: StringType;
+    }>>;
+}>>, StringType, NullType, readonly ["group"]> & {
+    interval: undefined;
+};
 /**
  * The flagship (§3.3) — the joinery workshop's orders, a grouped sheet over a
  * record: each order a group, its operations its lines, the order's status and
@@ -1923,13 +2503,16 @@ export declare const sheetWorkshopOrdersPatch: import("@elaraai/e3").MutationDef
  * half the activity does not use, implies how many machines a quantity needs,
  * and checks each machine named. The copilot fills dates, quantities, notes
  * and work centres, and proposes the lines that follow — a pattern, one
- * learned from the order, and an async model. A check on each order, templates
- * for whole orders and single operations, the slice's search and filter with
- * the work centres searched by their display text, views kept per viewer and
- * a footer. Both panes: the library lists the templates, the statuses — a
- * card dropped on an order's band sets its status — and the columns; the
- * inspector shows every field of the selected operation, `created_by` (no
- * column) read only, and the order with no customer is the batch's issue.
+ * learned from the order, and an async model. A check on each order, and a
+ * footer counting every operation. One rail, its `Slice.bindRecords` over
+ * three records (#1345): the orders, by status and customer — the sheet's
+ * rows, paged from it, Save committing through the record's patch door — and
+ * the operation and order templates, each a record of its own, by their
+ * group; views kept per viewer hold every source's narrowing. Both panes: the
+ * library lists the templates the rail shows, the statuses — a card dropped
+ * on an order's band sets its status — and the columns; the inspector shows
+ * every field of the selected operation, `created_by` (no column) read only,
+ * and the order with no customer is the batch's issue.
  */
 export declare const sheetWorkshop: import("@elaraai/east").ExampleDef<[], any>;
 /** A plan row — what it is, when it starts (read at its own level) and when it
@@ -4394,6 +4977,109 @@ export declare const sheetBatchDaysPatch: import("@elaraai/e3").MutationDef<"pat
         }>;
     }>>;
 }>]>;
+/** A step template — the Rows tab's card, the group it sits under, and the task of the step it drops. */
+export declare const BatchStepTemplate: StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly task: StringType;
+}>;
+/** The step templates, keyed by their key: a record of their own, the rail's `rowTemplates` source (#1345). */
+export declare const sheetBatchStepTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly task: StringType;
+}>>, [variant<"field", "records">, variant<"field", "sheet_batch_step_templates">]>;
+/** The step templates by their group: what the rail narrows them by. */
+export declare const sheetBatchStepTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"sheet_batch_step_templates_by_group", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly task: StringType;
+}>>, StringType, NullType, readonly ["group"]> & {
+    interval: undefined;
+};
+/** A batch template — the Rows tab's card, the group it sits under, the batch's name and the steps it starts with. */
+export declare const BatchTemplate: StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly batch: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly task: StringType;
+        readonly qty: OptionType<FloatType>;
+        readonly parts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly code: StringType;
+            readonly name: StringType;
+            readonly materials: ArrayType<StringType>;
+            readonly station: OptionType<StringType>;
+        }>>;
+        readonly bookings: ArrayType<VariantType<{
+            readonly labour: StructType<{
+                readonly team: StringType;
+                readonly people: IntegerType;
+                readonly hours: FloatType;
+            }>;
+            readonly equipment: StructType<{
+                readonly resource: StringType;
+            }>;
+        }>>;
+    }>>;
+}>;
+/** The batch templates, keyed by their key: a record of their own, the rail's `groupTemplates` source (#1345). */
+export declare const sheetBatchTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly batch: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly task: StringType;
+        readonly qty: OptionType<FloatType>;
+        readonly parts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly code: StringType;
+            readonly name: StringType;
+            readonly materials: ArrayType<StringType>;
+            readonly station: OptionType<StringType>;
+        }>>;
+        readonly bookings: ArrayType<VariantType<{
+            readonly labour: StructType<{
+                readonly team: StringType;
+                readonly people: IntegerType;
+                readonly hours: FloatType;
+            }>;
+            readonly equipment: StructType<{
+                readonly resource: StringType;
+            }>;
+        }>>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_batch_templates">]>;
+/** The batch templates by their group: what the rail narrows them by. */
+export declare const sheetBatchTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"sheet_batch_templates_by_group", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly batch: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly task: StringType;
+        readonly qty: OptionType<FloatType>;
+        readonly parts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly code: StringType;
+            readonly name: StringType;
+            readonly materials: ArrayType<StringType>;
+            readonly station: OptionType<StringType>;
+        }>>;
+        readonly bookings: ArrayType<VariantType<{
+            readonly labour: StructType<{
+                readonly team: StringType;
+                readonly people: IntegerType;
+                readonly hours: FloatType;
+            }>;
+            readonly equipment: StructType<{
+                readonly resource: StringType;
+            }>;
+        }>>;
+    }>>;
+}>>, StringType, NullType, readonly ["group"]> & {
+    interval: undefined;
+};
 /**
  * One day's batches, in the planner's order (#1187, SB39, SB40, SB44) — a
  * grouped sheet over one entry's groups, each batch a group of its steps. A
@@ -4406,7 +5092,10 @@ export declare const sheetBatchDaysPatch: import("@elaraai/e3").MutationDef<"pat
  * (a struct source — chips and labelled facets, a `none` facet dropping out)
  * and its bookings (a variant source matched arm by arm). Its chevron opens
  * them. Both panes: the library holds the templates and the columns, and the
- * inspector a step's form, which leaves the sub rows' fields out.
+ * inspector a step's form, which leaves the sub rows' fields out. The
+ * templates are two records, the step templates and the batch templates, each
+ * a source of the sheet's one rail (#1345), which narrows their cards by
+ * their group.
  */
 export declare const sheetBatches: import("@elaraai/east").ExampleDef<[], any>;
 /** A task — a package's line, or a loose task that belongs to no package; `id` identifies a loose one. */
@@ -4984,7 +5673,7 @@ export declare const sheetLooseWorkPatch: import("@elaraai/e3").MutationDef<"pat
 export declare const sheetLoose: import("@elaraai/east").ExampleDef<[], any>;
 /**
  * A record read a window at a time (§3.4) — the jobs, paged in key order: the
- * key search seeks a job by its key, and the lens narrows the loaded rows. Its
+ * key search seeks a job by its key. Its
  * `edits` let rows be added — from a gutter seam, the selection strip, or
  * Alt+Insert — and never removed: a job leaves through the record's own
  * process, not the sheet. It is given no pane.