@elaraai/e3-ui 1.0.93 → 1.0.95

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

@@ -3,305 +3,422 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /** @jsxImportSource @elaraai/e3-ui */
-import { ArrayType, DateTimeType, DictType, NullType, StringType, StructType } from "@elaraai/east";
-export declare const rosterWeeks: import("@elaraai/e3").RecordDef<DictType<DateTimeType, StructType<{
-    readonly status: import("@elaraai/east").VariantType<{
-        readonly draft: NullType;
-        readonly published: StructType<{
-            readonly at: DateTimeType;
-        }>;
+import { ArrayType, BooleanType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, variant } from "@elaraai/east";
+export { WarehouseCover, WarehouseDuty, WarehouseRosterWeek, warehouseNextStart, warehousePrevious, warehousePreviousStart, warehouseStart, warehouseWeek, } from "./warehouse.js";
+/** The duties, both weeks', each the warehouse's own row. */
+export declare const rosterDuties: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
     }>;
-    readonly assignments: DictType<StringType, StructType<{
-        readonly slot: StructType<{
-            readonly day: import("@elaraai/east").IntegerType;
-            readonly group: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [variant<"field", "records">, variant<"field", "roster_duties">]>;
+export declare const rosterDutiesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
             readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
         }>;
-        readonly who: import("@elaraai/east").VariantType<{
-            readonly person: StringType;
-            readonly request: StringType;
+        insert: StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly who: import("@elaraai/east").VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+                after: StructType<{
+                    readonly who: import("@elaraai/east").VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: import("@elaraai/east").VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                        after: import("@elaraai/east").VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        readonly staff: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly agency: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly start: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly shift: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly role: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly task: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly unpaidBreak: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly agreed: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<BooleanType>;
+                        after: OptionType<BooleanType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: BooleanType;
+                                after: BooleanType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly costCentre: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly note: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
         }>;
-        readonly position: StringType;
-        readonly activity: import("@elaraai/east").OptionType<StringType>;
-        readonly offset: import("@elaraai/east").FloatType;
-        readonly overtime: import("@elaraai/east").FloatType;
-        readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-    }>>;
-    readonly requirements: DictType<StructType<{
-        readonly day: import("@elaraai/east").IntegerType;
-        readonly group: StringType;
-        readonly shift: StringType;
-    }>, StructType<{
-        readonly positions: import("@elaraai/east").IntegerType;
-        readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
     }>>;
+}>]>;
+/** The duties by their times: what the Roster's slice reads a week of them through, its navigation writing the range. */
+export declare const rosterDutiesByTime: import("@elaraai/e3").RecordIndexDef<"roster_duties_by_time", DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, StructType<Record<never, never> & {
+    __interval: IntegerType;
+} & {
+    start: DateTimeType;
+}>, NullType, readonly ["start"]> & {
+    interval: {
+        readonly from: "start";
+        readonly to: "end";
+    };
+};
+/** The weeks of the rota: the one before issued, this one open. */
+export declare const rosterWeeks: import("@elaraai/e3").RecordDef<DictType<DateTimeType, StructType<{
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly open: NullType;
+        readonly issued: StructType<{
+            readonly at: DateTimeType;
+        }>;
+    }>;
     readonly dismissed: import("@elaraai/east").SetType<StringType>;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").variant<"field", "roster_weeks">]>;
+    readonly approver: OptionType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "roster_rota_weeks">]>;
 export declare const rosterWeeksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, StructType<{
-    readonly status: import("@elaraai/east").VariantType<{
-        readonly draft: NullType;
-        readonly published: StructType<{
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly open: NullType;
+        readonly issued: StructType<{
             readonly at: DateTimeType;
         }>;
     }>;
-    readonly assignments: DictType<StringType, StructType<{
-        readonly slot: StructType<{
-            readonly day: import("@elaraai/east").IntegerType;
-            readonly group: StringType;
-            readonly shift: StringType;
-        }>;
-        readonly who: import("@elaraai/east").VariantType<{
-            readonly person: StringType;
-            readonly request: StringType;
-        }>;
-        readonly position: StringType;
-        readonly activity: import("@elaraai/east").OptionType<StringType>;
-        readonly offset: import("@elaraai/east").FloatType;
-        readonly overtime: import("@elaraai/east").FloatType;
-        readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-    }>>;
-    readonly requirements: DictType<StructType<{
-        readonly day: import("@elaraai/east").IntegerType;
-        readonly group: StringType;
-        readonly shift: StringType;
-    }>, StructType<{
-        readonly positions: import("@elaraai/east").IntegerType;
-        readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-    }>>;
     readonly dismissed: import("@elaraai/east").SetType<StringType>;
+    readonly approver: OptionType<StringType>;
 }>>, [import("@elaraai/east").VariantType<{
     unchanged: NullType;
     replace: StructType<{
         before: DictType<DateTimeType, StructType<{
-            readonly status: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly published: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
                     readonly at: DateTimeType;
                 }>;
             }>;
-            readonly assignments: DictType<StringType, StructType<{
-                readonly slot: StructType<{
-                    readonly day: import("@elaraai/east").IntegerType;
-                    readonly group: StringType;
-                    readonly shift: StringType;
-                }>;
-                readonly who: import("@elaraai/east").VariantType<{
-                    readonly person: StringType;
-                    readonly request: StringType;
-                }>;
-                readonly position: StringType;
-                readonly activity: import("@elaraai/east").OptionType<StringType>;
-                readonly offset: import("@elaraai/east").FloatType;
-                readonly overtime: import("@elaraai/east").FloatType;
-                readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-            }>>;
-            readonly requirements: DictType<StructType<{
-                readonly day: import("@elaraai/east").IntegerType;
-                readonly group: StringType;
-                readonly shift: StringType;
-            }>, StructType<{
-                readonly positions: import("@elaraai/east").IntegerType;
-                readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-            }>>;
             readonly dismissed: import("@elaraai/east").SetType<StringType>;
+            readonly approver: OptionType<StringType>;
         }>>;
         after: DictType<DateTimeType, StructType<{
-            readonly status: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly published: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
                     readonly at: DateTimeType;
                 }>;
             }>;
-            readonly assignments: DictType<StringType, StructType<{
-                readonly slot: StructType<{
-                    readonly day: import("@elaraai/east").IntegerType;
-                    readonly group: StringType;
-                    readonly shift: StringType;
-                }>;
-                readonly who: import("@elaraai/east").VariantType<{
-                    readonly person: StringType;
-                    readonly request: StringType;
-                }>;
-                readonly position: StringType;
-                readonly activity: import("@elaraai/east").OptionType<StringType>;
-                readonly offset: import("@elaraai/east").FloatType;
-                readonly overtime: import("@elaraai/east").FloatType;
-                readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-            }>>;
-            readonly requirements: DictType<StructType<{
-                readonly day: import("@elaraai/east").IntegerType;
-                readonly group: StringType;
-                readonly shift: StringType;
-            }>, StructType<{
-                readonly positions: import("@elaraai/east").IntegerType;
-                readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-            }>>;
             readonly dismissed: import("@elaraai/east").SetType<StringType>;
+            readonly approver: OptionType<StringType>;
         }>>;
     }>;
     patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
         delete: StructType<{
-            readonly status: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly published: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
                     readonly at: DateTimeType;
                 }>;
             }>;
-            readonly assignments: DictType<StringType, StructType<{
-                readonly slot: StructType<{
-                    readonly day: import("@elaraai/east").IntegerType;
-                    readonly group: StringType;
-                    readonly shift: StringType;
-                }>;
-                readonly who: import("@elaraai/east").VariantType<{
-                    readonly person: StringType;
-                    readonly request: StringType;
-                }>;
-                readonly position: StringType;
-                readonly activity: import("@elaraai/east").OptionType<StringType>;
-                readonly offset: import("@elaraai/east").FloatType;
-                readonly overtime: import("@elaraai/east").FloatType;
-                readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-            }>>;
-            readonly requirements: DictType<StructType<{
-                readonly day: import("@elaraai/east").IntegerType;
-                readonly group: StringType;
-                readonly shift: StringType;
-            }>, StructType<{
-                readonly positions: import("@elaraai/east").IntegerType;
-                readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-            }>>;
             readonly dismissed: import("@elaraai/east").SetType<StringType>;
+            readonly approver: OptionType<StringType>;
         }>;
         insert: StructType<{
-            readonly status: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly published: StructType<{
+            readonly state: import("@elaraai/east").VariantType<{
+                readonly open: NullType;
+                readonly issued: StructType<{
                     readonly at: DateTimeType;
                 }>;
             }>;
-            readonly assignments: DictType<StringType, StructType<{
-                readonly slot: StructType<{
-                    readonly day: import("@elaraai/east").IntegerType;
-                    readonly group: StringType;
-                    readonly shift: StringType;
-                }>;
-                readonly who: import("@elaraai/east").VariantType<{
-                    readonly person: StringType;
-                    readonly request: StringType;
-                }>;
-                readonly position: StringType;
-                readonly activity: import("@elaraai/east").OptionType<StringType>;
-                readonly offset: import("@elaraai/east").FloatType;
-                readonly overtime: import("@elaraai/east").FloatType;
-                readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-            }>>;
-            readonly requirements: DictType<StructType<{
-                readonly day: import("@elaraai/east").IntegerType;
-                readonly group: StringType;
-                readonly shift: StringType;
-            }>, StructType<{
-                readonly positions: import("@elaraai/east").IntegerType;
-                readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-            }>>;
             readonly dismissed: import("@elaraai/east").SetType<StringType>;
+            readonly approver: OptionType<StringType>;
         }>;
         update: import("@elaraai/east").VariantType<{
             unchanged: NullType;
             replace: StructType<{
                 before: StructType<{
-                    readonly status: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly published: StructType<{
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly open: NullType;
+                        readonly issued: StructType<{
                             readonly at: DateTimeType;
                         }>;
                     }>;
-                    readonly assignments: DictType<StringType, StructType<{
-                        readonly slot: StructType<{
-                            readonly day: import("@elaraai/east").IntegerType;
-                            readonly group: StringType;
-                            readonly shift: StringType;
-                        }>;
-                        readonly who: import("@elaraai/east").VariantType<{
-                            readonly person: StringType;
-                            readonly request: StringType;
-                        }>;
-                        readonly position: StringType;
-                        readonly activity: import("@elaraai/east").OptionType<StringType>;
-                        readonly offset: import("@elaraai/east").FloatType;
-                        readonly overtime: import("@elaraai/east").FloatType;
-                        readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                    }>>;
-                    readonly requirements: DictType<StructType<{
-                        readonly day: import("@elaraai/east").IntegerType;
-                        readonly group: StringType;
-                        readonly shift: StringType;
-                    }>, StructType<{
-                        readonly positions: import("@elaraai/east").IntegerType;
-                        readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                    }>>;
                     readonly dismissed: import("@elaraai/east").SetType<StringType>;
+                    readonly approver: OptionType<StringType>;
                 }>;
                 after: StructType<{
-                    readonly status: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly published: StructType<{
+                    readonly state: import("@elaraai/east").VariantType<{
+                        readonly open: NullType;
+                        readonly issued: StructType<{
                             readonly at: DateTimeType;
                         }>;
                     }>;
-                    readonly assignments: DictType<StringType, StructType<{
-                        readonly slot: StructType<{
-                            readonly day: import("@elaraai/east").IntegerType;
-                            readonly group: StringType;
-                            readonly shift: StringType;
-                        }>;
-                        readonly who: import("@elaraai/east").VariantType<{
-                            readonly person: StringType;
-                            readonly request: StringType;
-                        }>;
-                        readonly position: StringType;
-                        readonly activity: import("@elaraai/east").OptionType<StringType>;
-                        readonly offset: import("@elaraai/east").FloatType;
-                        readonly overtime: import("@elaraai/east").FloatType;
-                        readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                    }>>;
-                    readonly requirements: DictType<StructType<{
-                        readonly day: import("@elaraai/east").IntegerType;
-                        readonly group: StringType;
-                        readonly shift: StringType;
-                    }>, StructType<{
-                        readonly positions: import("@elaraai/east").IntegerType;
-                        readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                    }>>;
                     readonly dismissed: import("@elaraai/east").SetType<StringType>;
+                    readonly approver: OptionType<StringType>;
                 }>;
             }>;
             patch: StructType<{
-                readonly status: import("@elaraai/east").VariantType<{
+                readonly state: import("@elaraai/east").VariantType<{
                     unchanged: NullType;
                     replace: StructType<{
                         before: import("@elaraai/east").VariantType<{
-                            readonly draft: NullType;
-                            readonly published: StructType<{
+                            readonly open: NullType;
+                            readonly issued: StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
                         after: import("@elaraai/east").VariantType<{
-                            readonly draft: NullType;
-                            readonly published: StructType<{
+                            readonly open: NullType;
+                            readonly issued: StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
                     }>;
                     patch: import("@elaraai/east").VariantType<{
-                        readonly draft: import("@elaraai/east").VariantType<{
+                        readonly open: import("@elaraai/east").VariantType<{
                             unchanged: NullType;
                             replace: StructType<{
                                 before: NullType;
                                 after: NullType;
                             }>;
                         }>;
-                        readonly published: import("@elaraai/east").VariantType<{
+                        readonly issued: import("@elaraai/east").VariantType<{
                             unchanged: NullType;
                             replace: StructType<{
                                 before: StructType<{
@@ -323,427 +440,2023 @@ export declare const rosterWeeksPatch: import("@elaraai/e3").MutationDef<"patch"
                         }>;
                     }>;
                 }>;
-                readonly assignments: import("@elaraai/east").VariantType<{
+                readonly dismissed: import("@elaraai/east").VariantType<{
                     unchanged: NullType;
                     replace: StructType<{
-                        before: DictType<StringType, StructType<{
-                            readonly slot: StructType<{
-                                readonly day: import("@elaraai/east").IntegerType;
-                                readonly group: StringType;
-                                readonly shift: StringType;
-                            }>;
-                            readonly who: import("@elaraai/east").VariantType<{
-                                readonly person: StringType;
-                                readonly request: StringType;
-                            }>;
-                            readonly position: StringType;
-                            readonly activity: import("@elaraai/east").OptionType<StringType>;
-                            readonly offset: import("@elaraai/east").FloatType;
-                            readonly overtime: import("@elaraai/east").FloatType;
-                            readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                        }>>;
-                        after: DictType<StringType, StructType<{
-                            readonly slot: StructType<{
-                                readonly day: import("@elaraai/east").IntegerType;
-                                readonly group: StringType;
-                                readonly shift: StringType;
-                            }>;
-                            readonly who: import("@elaraai/east").VariantType<{
-                                readonly person: StringType;
-                                readonly request: StringType;
-                            }>;
-                            readonly position: StringType;
-                            readonly activity: import("@elaraai/east").OptionType<StringType>;
-                            readonly offset: import("@elaraai/east").FloatType;
-                            readonly overtime: import("@elaraai/east").FloatType;
-                            readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                        }>>;
+                        before: import("@elaraai/east").SetType<StringType>;
+                        after: import("@elaraai/east").SetType<StringType>;
                     }>;
                     patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: StructType<{
-                            readonly slot: StructType<{
-                                readonly day: import("@elaraai/east").IntegerType;
-                                readonly group: StringType;
-                                readonly shift: StringType;
-                            }>;
-                            readonly who: import("@elaraai/east").VariantType<{
-                                readonly person: StringType;
-                                readonly request: StringType;
-                            }>;
-                            readonly position: StringType;
-                            readonly activity: import("@elaraai/east").OptionType<StringType>;
-                            readonly offset: import("@elaraai/east").FloatType;
-                            readonly overtime: import("@elaraai/east").FloatType;
-                            readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                        }>;
-                        insert: StructType<{
-                            readonly slot: StructType<{
-                                readonly day: import("@elaraai/east").IntegerType;
-                                readonly group: StringType;
-                                readonly shift: StringType;
-                            }>;
-                            readonly who: import("@elaraai/east").VariantType<{
-                                readonly person: StringType;
-                                readonly request: StringType;
-                            }>;
-                            readonly position: StringType;
-                            readonly activity: import("@elaraai/east").OptionType<StringType>;
-                            readonly offset: import("@elaraai/east").FloatType;
-                            readonly overtime: import("@elaraai/east").FloatType;
-                            readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                        }>;
-                        update: import("@elaraai/east").VariantType<{
+                        delete: NullType;
+                        insert: NullType;
+                    }>>;
+                }>;
+                readonly approver: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
                             unchanged: NullType;
                             replace: StructType<{
-                                before: StructType<{
-                                    readonly slot: StructType<{
-                                        readonly day: import("@elaraai/east").IntegerType;
-                                        readonly group: StringType;
-                                        readonly shift: StringType;
-                                    }>;
-                                    readonly who: import("@elaraai/east").VariantType<{
-                                        readonly person: StringType;
-                                        readonly request: StringType;
-                                    }>;
-                                    readonly position: StringType;
-                                    readonly activity: import("@elaraai/east").OptionType<StringType>;
-                                    readonly offset: import("@elaraai/east").FloatType;
-                                    readonly overtime: import("@elaraai/east").FloatType;
-                                    readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                                }>;
-                                after: StructType<{
-                                    readonly slot: StructType<{
-                                        readonly day: import("@elaraai/east").IntegerType;
-                                        readonly group: StringType;
-                                        readonly shift: StringType;
-                                    }>;
-                                    readonly who: import("@elaraai/east").VariantType<{
-                                        readonly person: StringType;
-                                        readonly request: StringType;
-                                    }>;
-                                    readonly position: StringType;
-                                    readonly activity: import("@elaraai/east").OptionType<StringType>;
-                                    readonly offset: import("@elaraai/east").FloatType;
-                                    readonly overtime: import("@elaraai/east").FloatType;
-                                    readonly agreed: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                                }>;
-                            }>;
-                            patch: StructType<{
-                                readonly slot: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: StructType<{
-                                            readonly day: import("@elaraai/east").IntegerType;
-                                            readonly group: StringType;
-                                            readonly shift: StringType;
-                                        }>;
-                                        after: StructType<{
-                                            readonly day: import("@elaraai/east").IntegerType;
-                                            readonly group: StringType;
-                                            readonly shift: StringType;
-                                        }>;
-                                    }>;
-                                    patch: StructType<{
-                                        readonly day: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: import("@elaraai/east").IntegerType;
-                                                after: import("@elaraai/east").IntegerType;
-                                            }>;
-                                        }>;
-                                        readonly group: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: StringType;
-                                                after: StringType;
-                                            }>;
-                                        }>;
-                                        readonly shift: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: StringType;
-                                                after: StringType;
-                                            }>;
-                                        }>;
-                                    }>;
-                                }>;
-                                readonly who: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").VariantType<{
-                                            readonly person: StringType;
-                                            readonly request: StringType;
-                                        }>;
-                                        after: import("@elaraai/east").VariantType<{
-                                            readonly person: StringType;
-                                            readonly request: StringType;
-                                        }>;
-                                    }>;
-                                    patch: import("@elaraai/east").VariantType<{
-                                        readonly person: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: StringType;
-                                                after: StringType;
-                                            }>;
-                                        }>;
-                                        readonly request: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: StringType;
-                                                after: StringType;
-                                            }>;
-                                        }>;
-                                    }>;
-                                }>;
-                                readonly position: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: StringType;
-                                        after: StringType;
-                                    }>;
-                                }>;
-                                readonly activity: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").OptionType<StringType>;
-                                        after: import("@elaraai/east").OptionType<StringType>;
-                                    }>;
-                                    patch: import("@elaraai/east").VariantType<{
-                                        none: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: NullType;
-                                                after: NullType;
-                                            }>;
-                                        }>;
-                                        some: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: StringType;
-                                                after: StringType;
-                                            }>;
-                                        }>;
-                                    }>;
-                                }>;
-                                readonly offset: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").FloatType;
-                                        after: import("@elaraai/east").FloatType;
-                                    }>;
-                                }>;
-                                readonly overtime: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").FloatType;
-                                        after: import("@elaraai/east").FloatType;
-                                    }>;
-                                }>;
-                                readonly agreed: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                                        after: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
-                                    }>;
-                                    patch: import("@elaraai/east").VariantType<{
-                                        none: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: NullType;
-                                                after: NullType;
-                                            }>;
-                                        }>;
-                                        some: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: import("@elaraai/east").BooleanType;
-                                                after: import("@elaraai/east").BooleanType;
-                                            }>;
-                                        }>;
-                                    }>;
-                                }>;
+                                before: NullType;
+                                after: NullType;
                             }>;
                         }>;
-                    }>>;
-                }>;
-                readonly requirements: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DictType<StructType<{
-                            readonly day: import("@elaraai/east").IntegerType;
-                            readonly group: StringType;
-                            readonly shift: StringType;
-                        }>, StructType<{
-                            readonly positions: import("@elaraai/east").IntegerType;
-                            readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                        }>>;
-                        after: DictType<StructType<{
-                            readonly day: import("@elaraai/east").IntegerType;
-                            readonly group: StringType;
-                            readonly shift: StringType;
-                        }>, StructType<{
-                            readonly positions: import("@elaraai/east").IntegerType;
-                            readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                        }>>;
-                    }>;
-                    patch: DictType<StructType<{
-                        readonly day: import("@elaraai/east").IntegerType;
-                        readonly group: StringType;
-                        readonly shift: StringType;
-                    }>, import("@elaraai/east").VariantType<{
-                        delete: StructType<{
-                            readonly positions: import("@elaraai/east").IntegerType;
-                            readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                        }>;
-                        insert: StructType<{
-                            readonly positions: import("@elaraai/east").IntegerType;
-                            readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                        }>;
-                        update: import("@elaraai/east").VariantType<{
+                        some: import("@elaraai/east").VariantType<{
                             unchanged: NullType;
                             replace: StructType<{
-                                before: StructType<{
-                                    readonly positions: import("@elaraai/east").IntegerType;
-                                    readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                                }>;
-                                after: StructType<{
-                                    readonly positions: import("@elaraai/east").IntegerType;
-                                    readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-                                }>;
-                            }>;
-                            patch: StructType<{
-                                readonly positions: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: import("@elaraai/east").IntegerType;
-                                        after: import("@elaraai/east").IntegerType;
-                                    }>;
-                                }>;
-                                readonly hours: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: DictType<StringType, import("@elaraai/east").FloatType>;
-                                        after: DictType<StringType, import("@elaraai/east").FloatType>;
-                                    }>;
-                                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                                        delete: import("@elaraai/east").FloatType;
-                                        insert: import("@elaraai/east").FloatType;
-                                        update: import("@elaraai/east").VariantType<{
-                                            unchanged: NullType;
-                                            replace: StructType<{
-                                                before: import("@elaraai/east").FloatType;
-                                                after: import("@elaraai/east").FloatType;
-                                            }>;
-                                        }>;
-                                    }>>;
-                                }>;
+                                before: StringType;
+                                after: StringType;
                             }>;
                         }>;
-                    }>>;
+                    }>;
                 }>;
-                readonly dismissed: import("@elaraai/east").VariantType<{
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The cover targets, a row per slot: the week before's, this week's and the forecast's for the week after. */
+export declare const rosterCover: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly day: DateTimeType;
+    readonly team: StringType;
+    readonly shift: StringType;
+    readonly heads: IntegerType;
+    readonly hours: DictType<StringType, FloatType>;
+    readonly basis: StringType;
+}>>, [variant<"field", "records">, variant<"field", "roster_cover">]>;
+export declare const rosterCoverPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly day: DateTimeType;
+    readonly team: StringType;
+    readonly shift: StringType;
+    readonly heads: IntegerType;
+    readonly hours: DictType<StringType, FloatType>;
+    readonly basis: StringType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly heads: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+            readonly basis: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly heads: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+            readonly basis: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly heads: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+            readonly basis: StringType;
+        }>;
+        insert: StructType<{
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly heads: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+            readonly basis: StringType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly day: DateTimeType;
+                    readonly team: StringType;
+                    readonly shift: StringType;
+                    readonly heads: IntegerType;
+                    readonly hours: DictType<StringType, FloatType>;
+                    readonly basis: StringType;
+                }>;
+                after: StructType<{
+                    readonly day: DateTimeType;
+                    readonly team: StringType;
+                    readonly shift: StringType;
+                    readonly heads: IntegerType;
+                    readonly hours: DictType<StringType, FloatType>;
+                    readonly basis: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly day: import("@elaraai/east").VariantType<{
                     unchanged: NullType;
                     replace: StructType<{
-                        before: import("@elaraai/east").SetType<StringType>;
-                        after: import("@elaraai/east").SetType<StringType>;
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly shift: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly heads: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+                readonly hours: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DictType<StringType, FloatType>;
+                        after: DictType<StringType, FloatType>;
                     }>;
                     patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: NullType;
-                        insert: NullType;
+                        delete: FloatType;
+                        insert: FloatType;
+                        update: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: FloatType;
+                                after: FloatType;
+                            }>;
+                        }>;
                     }>>;
                 }>;
+                readonly basis: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
             }>;
         }>;
     }>>;
 }>]>;
+/** The suggestions: someone for a slot, and why. */
+export declare const rosterSuggestions: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly day: DateTimeType;
+    readonly team: StringType;
+    readonly shift: StringType;
+    readonly why: StringType;
+}>>, [variant<"field", "records">, variant<"field", "roster_suggestions">]>;
+/** The pay rates, an hour, by the warehouse's own pay codes. */
+export declare const rosterPayRates: import("@elaraai/e3").RecordDef<DictType<StringType, FloatType>, [variant<"field", "records">, variant<"field", "roster_pay_rates">]>;
 export declare const rosterStaff: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly team: StringType;
     readonly position: StringType;
     readonly skills: import("@elaraai/east").SetType<StringType>;
-    readonly contract: import("@elaraai/east").FloatType;
-    readonly agency: import("@elaraai/east").BooleanType;
-    readonly trainer: import("@elaraai/east").BooleanType;
-    readonly trainee: import("@elaraai/east").BooleanType;
-    readonly usual: import("@elaraai/east").OptionType<StringType>;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").variant<"field", "roster_staff">]>;
-export declare const rosterConfiguration: import("@elaraai/e3").RecordDef<StructType<{
-    readonly groups: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly skills: ArrayType<StructType<{
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "roster_staff">]>;
+export declare const rosterAgencies: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "roster_agencies">]>;
+export declare const rosterShiftTimes: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly start: StructType<{
+        readonly hour: IntegerType;
+        readonly minute: IntegerType;
+    }>;
+    readonly hours: FloatType;
+    readonly order: IntegerType;
+}>>, [variant<"field", "records">, variant<"field", "roster_shift_times">]>;
+export declare const rosterTeams: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly order: IntegerType;
+}>>, [variant<"field", "records">, variant<"field", "roster_teams">]>;
+export declare const rosterPositions: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly lead: BooleanType;
+    readonly order: IntegerType;
+}>>, [variant<"field", "records">, variant<"field", "roster_positions">]>;
+/** Every activity by its key: each group's skills, and the duty of none (#1342). */
+export declare const rosterActivities: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly group: OptionType<StringType>;
+    readonly order: IntegerType;
+}>>, [variant<"field", "records">, variant<"field", "roster_activities">]>;
+export declare const rosterStaffByTeamName: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_team_name", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, StructType<{
+    name: StringType;
+    team: StringType;
+}>, NullType, readonly ["team", "name"]> & {
+    interval: undefined;
+};
+export declare const rosterStaffByPosition: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_position", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, StringType, NullType, readonly ["position"]> & {
+    interval: undefined;
+};
+export declare const rosterStaffByTrainer: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_trainer", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, BooleanType, NullType, readonly ["trainer"]> & {
+    interval: undefined;
+};
+export declare const rosterStaffByAgency: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_agency", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, BooleanType, NullType, readonly ["agency"]> & {
+    interval: undefined;
+};
+export declare const rosterStaffBySkill: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_skill", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, StringType, NullType, readonly ["skills"]> & {
+    interval: undefined;
+};
+export declare const rosterStaffByName: import("@elaraai/e3").RecordIndexDef<"roster_staff_by_name", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, StringType, NullType, readonly ["name"]> & {
+    interval: undefined;
+};
+export declare const rosterActivitiesByGroup: import("@elaraai/e3").RecordIndexDef<"roster_activities_by_group", DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly group: OptionType<StringType>;
+    readonly order: IntegerType;
+}>>, OptionType<StringType>, NullType, readonly ["group"]> & {
+    interval: undefined;
+};
+/** The warehouse's fit's body: the ready-made rule, then a greedy order — the people off that day with the most spare contract hours first, whatever their group. */
+export declare const rosterStaffFitBody: import("@elaraai/east").CallableFunctionExpr<[StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly week: StructType<{
+        readonly status: import("@elaraai/east").VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: OptionType<DateTimeType>;
+            }>;
+            readonly other: StringType;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly hours: FloatType;
+            readonly row: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    readonly staff: StringType;
+                    readonly agency: StringType;
+                }>;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly shift: StringType;
+                readonly team: StringType;
+                readonly role: StringType;
+                readonly task: OptionType<StringType>;
+                readonly unpaidBreak: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+                readonly costCentre: StringType;
+                readonly note: StringType;
+            }>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: import("@elaraai/east").SetType<StringType>;
+    }>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+        readonly groups: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly activities: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
             readonly code: StringType;
+            readonly group: OptionType<StringType>;
         }>>;
+        readonly shifts: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+        }>>;
+        readonly positions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+        }>>;
+        readonly agencies: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+        }>>;
+        readonly rules: StructType<{
+            readonly rest: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+            readonly skill: BooleanType;
+        }>;
+    }>;
+    readonly coverage: DictType<StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: IntegerType;
+        readonly filled: IntegerType;
+        readonly open: IntegerType;
+        readonly people: IntegerType;
+        readonly hours: StructType<{
+            readonly permanent: FloatType;
+            readonly agency: FloatType;
+            readonly requested: FloatType;
+            readonly needed: FloatType;
+            readonly rostered: FloatType;
+        }>;
+        readonly lines: ArrayType<StructType<{
+            readonly skill: StringType;
+            readonly needed: FloatType;
+            readonly holders: OptionType<IntegerType>;
+            readonly capacity: OptionType<FloatType>;
+            readonly gap: FloatType;
+            readonly assigned: FloatType;
+        }>>;
+        readonly cost: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
     }>>;
-    readonly shifts: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly code: StringType;
-        readonly start: StructType<{
-            readonly hour: import("@elaraai/east").IntegerType;
-            readonly minute: import("@elaraai/east").IntegerType;
-        }>;
-        readonly hours: import("@elaraai/east").FloatType;
-    }>>;
-    readonly duties: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly code: StringType;
-    }>>;
-    readonly positions: DictType<StringType, StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly code: StringType;
-        readonly lead: import("@elaraai/east").BooleanType;
+}>], StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly people: DictType<StringType, import("@elaraai/east").VariantType<{
+        readonly fits: StructType<{
+            readonly score: FloatType;
+            readonly why: StringType;
+            readonly warn: OptionType<StringType>;
+        }>;
+        readonly refused: StructType<{
+            readonly group: StringType;
+            readonly reason: StringType;
+            readonly measure: import("@elaraai/east").VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
     }>>;
-    readonly agencies: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly name: StringType;
+}>>;
+export declare const rosterStaffFit: import("@elaraai/e3").FunctionDef<[StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly week: StructType<{
+        readonly status: import("@elaraai/east").VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: OptionType<DateTimeType>;
+            }>;
+            readonly other: StringType;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly hours: FloatType;
+            readonly row: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    readonly staff: StringType;
+                    readonly agency: StringType;
+                }>;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly shift: StringType;
+                readonly team: StringType;
+                readonly role: StringType;
+                readonly task: OptionType<StringType>;
+                readonly unpaidBreak: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+                readonly costCentre: StringType;
+                readonly note: StringType;
+            }>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: import("@elaraai/east").SetType<StringType>;
+    }>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+        readonly groups: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly activities: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly group: OptionType<StringType>;
+        }>>;
+        readonly shifts: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+        }>>;
+        readonly positions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+        }>>;
+        readonly agencies: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+        }>>;
+        readonly rules: StructType<{
+            readonly rest: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+            readonly skill: BooleanType;
+        }>;
+    }>;
+    readonly coverage: DictType<StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: IntegerType;
+        readonly filled: IntegerType;
+        readonly open: IntegerType;
+        readonly people: IntegerType;
+        readonly hours: StructType<{
+            readonly permanent: FloatType;
+            readonly agency: FloatType;
+            readonly requested: FloatType;
+            readonly needed: FloatType;
+            readonly rostered: FloatType;
+        }>;
+        readonly lines: ArrayType<StructType<{
+            readonly skill: StringType;
+            readonly needed: FloatType;
+            readonly holders: OptionType<IntegerType>;
+            readonly capacity: OptionType<FloatType>;
+            readonly gap: FloatType;
+            readonly assigned: FloatType;
+        }>>;
+        readonly cost: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
     }>>;
-    readonly rules: StructType<{
-        readonly rest: import("@elaraai/east").FloatType;
-        readonly lead: import("@elaraai/east").BooleanType;
-        readonly trainer: import("@elaraai/east").BooleanType;
-        readonly skill: import("@elaraai/east").BooleanType;
-        readonly agree: import("@elaraai/east").BooleanType;
-    }>;
-    readonly costs: StructType<{
-        readonly currency: StringType;
-        readonly rates: StructType<{
-            readonly permanent: import("@elaraai/east").FloatType;
-            readonly overtime: import("@elaraai/east").FloatType;
-            readonly agency: import("@elaraai/east").FloatType;
-        }>;
-        readonly budget: import("@elaraai/east").OptionType<import("@elaraai/east").FloatType>;
-    }>;
-}>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").variant<"field", "roster_configuration">]>;
-export declare const rosterForecast: import("@elaraai/e3").RecordDef<DictType<DateTimeType, DictType<StructType<{
-    readonly day: import("@elaraai/east").IntegerType;
-    readonly group: StringType;
-    readonly shift: StringType;
-}>, StructType<{
-    readonly positions: import("@elaraai/east").IntegerType;
-    readonly hours: DictType<StringType, import("@elaraai/east").FloatType>;
-}>>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").variant<"field", "roster_forecast">]>;
-export declare const rosterProposals: import("@elaraai/e3").RecordDef<ArrayType<StructType<{
-    readonly key: StringType;
-    readonly week: DateTimeType;
+}>], StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
     readonly slot: StructType<{
-        readonly day: import("@elaraai/east").IntegerType;
+        readonly day: IntegerType;
         readonly group: StringType;
         readonly shift: StringType;
     }>;
-    readonly person: StringType;
-    readonly reason: StringType;
-}>>, [import("@elaraai/east").variant<"field", "records">, import("@elaraai/east").variant<"field", "roster_proposals">]>;
-export declare const rosterWarehouse: import("@elaraai/east").ExampleDef<[], any>;
-export declare const rosterMobile: import("@elaraai/east").ExampleDef<[], any>;
-export declare const rosterPeople: import("@elaraai/east").ExampleDef<[], any>;
-export declare const rosterWeek: import("@elaraai/east").ExampleDef<[], any>;
-export declare const rosterWindowed: import("@elaraai/east").ExampleDef<[], any>;
+    readonly people: DictType<StringType, import("@elaraai/east").VariantType<{
+        readonly fits: StructType<{
+            readonly score: FloatType;
+            readonly why: StringType;
+            readonly warn: OptionType<StringType>;
+        }>;
+        readonly refused: StructType<{
+            readonly group: StringType;
+            readonly reason: StringType;
+            readonly measure: import("@elaraai/east").VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>>;
+/** The staff's patch door: another session's edit of the staff. */
+export declare const rosterStaffPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+    readonly position: StringType;
+    readonly skills: import("@elaraai/east").SetType<StringType>;
+    readonly contract: FloatType;
+    readonly agency: BooleanType;
+    readonly trainer: BooleanType;
+    readonly trainee: BooleanType;
+    readonly usual: OptionType<StringType>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly team: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly team: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly team: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly team: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly team: StringType;
+                    readonly position: StringType;
+                    readonly skills: import("@elaraai/east").SetType<StringType>;
+                    readonly contract: FloatType;
+                    readonly agency: BooleanType;
+                    readonly trainer: BooleanType;
+                    readonly trainee: BooleanType;
+                    readonly usual: OptionType<StringType>;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly team: StringType;
+                    readonly position: StringType;
+                    readonly skills: import("@elaraai/east").SetType<StringType>;
+                    readonly contract: FloatType;
+                    readonly agency: BooleanType;
+                    readonly trainer: BooleanType;
+                    readonly trainee: BooleanType;
+                    readonly usual: OptionType<StringType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly name: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly position: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly skills: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: import("@elaraai/east").SetType<StringType>;
+                        after: import("@elaraai/east").SetType<StringType>;
+                    }>;
+                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                        delete: NullType;
+                        insert: NullType;
+                    }>>;
+                }>;
+                readonly contract: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly agency: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: BooleanType;
+                        after: BooleanType;
+                    }>;
+                }>;
+                readonly trainer: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: BooleanType;
+                        after: BooleanType;
+                    }>;
+                }>;
+                readonly trainee: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: BooleanType;
+                        after: BooleanType;
+                    }>;
+                }>;
+                readonly usual: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The shift times' patch door: another session's edit of them. */
+export declare const rosterShiftTimesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly start: StructType<{
+        readonly hour: IntegerType;
+        readonly minute: IntegerType;
+    }>;
+    readonly hours: FloatType;
+    readonly order: IntegerType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+            readonly order: IntegerType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+            readonly order: IntegerType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+            readonly order: IntegerType;
+        }>;
+        insert: StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+            readonly order: IntegerType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly label: StringType;
+                    readonly code: StringType;
+                    readonly start: StructType<{
+                        readonly hour: IntegerType;
+                        readonly minute: IntegerType;
+                    }>;
+                    readonly hours: FloatType;
+                    readonly order: IntegerType;
+                }>;
+                after: StructType<{
+                    readonly label: StringType;
+                    readonly code: StringType;
+                    readonly start: StructType<{
+                        readonly hour: IntegerType;
+                        readonly minute: IntegerType;
+                    }>;
+                    readonly hours: FloatType;
+                    readonly order: IntegerType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly label: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly code: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StructType<{
+                            readonly hour: IntegerType;
+                            readonly minute: IntegerType;
+                        }>;
+                        after: StructType<{
+                            readonly hour: IntegerType;
+                            readonly minute: IntegerType;
+                        }>;
+                    }>;
+                    patch: StructType<{
+                        readonly hour: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: IntegerType;
+                                after: IntegerType;
+                            }>;
+                        }>;
+                        readonly minute: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: IntegerType;
+                                after: IntegerType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly hours: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly order: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The teams' patch door: another session's edit of them. */
+export declare const rosterTeamsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly order: IntegerType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly order: IntegerType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly order: IntegerType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly label: StringType;
+            readonly order: IntegerType;
+        }>;
+        insert: StructType<{
+            readonly label: StringType;
+            readonly order: IntegerType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly label: StringType;
+                    readonly order: IntegerType;
+                }>;
+                after: StructType<{
+                    readonly label: StringType;
+                    readonly order: IntegerType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly label: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly order: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The positions' patch door: another session's edit of them. */
+export declare const rosterPositionsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly lead: BooleanType;
+    readonly order: IntegerType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+            readonly order: IntegerType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+            readonly order: IntegerType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+            readonly order: IntegerType;
+        }>;
+        insert: StructType<{
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+            readonly order: IntegerType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly label: StringType;
+                    readonly code: StringType;
+                    readonly lead: BooleanType;
+                    readonly order: IntegerType;
+                }>;
+                after: StructType<{
+                    readonly label: StringType;
+                    readonly code: StringType;
+                    readonly lead: BooleanType;
+                    readonly order: IntegerType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly label: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly code: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly lead: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: BooleanType;
+                        after: BooleanType;
+                    }>;
+                }>;
+                readonly order: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: IntegerType;
+                        after: IntegerType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The suggestions' patch door: another session's edit of them. */
+export declare const rosterSuggestionsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly day: DateTimeType;
+    readonly team: StringType;
+    readonly shift: StringType;
+    readonly why: StringType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly why: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly why: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly person: StringType;
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly why: StringType;
+        }>;
+        insert: StructType<{
+            readonly person: StringType;
+            readonly day: DateTimeType;
+            readonly team: StringType;
+            readonly shift: StringType;
+            readonly why: StringType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly person: StringType;
+                    readonly day: DateTimeType;
+                    readonly team: StringType;
+                    readonly shift: StringType;
+                    readonly why: StringType;
+                }>;
+                after: StructType<{
+                    readonly person: StringType;
+                    readonly day: DateTimeType;
+                    readonly team: StringType;
+                    readonly shift: StringType;
+                    readonly why: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly person: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly day: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly shift: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly why: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/** The duties of a roster the warehouse has locked: the warehouse's own duties, which no Save changes. */
+export declare const rosterLockedDuties: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [variant<"field", "records">, variant<"field", "roster_locked_duties">]>;
+/** The locked duties by their times: what a roster over them reads a week of them through. */
+export declare const rosterLockedDutiesByTime: import("@elaraai/e3").RecordIndexDef<"roster_locked_duties_by_time", DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, StructType<Record<never, never> & {
+    __interval: IntegerType;
+} & {
+    start: DateTimeType;
+}>, NullType, readonly ["start"]> & {
+    interval: {
+        readonly from: "start";
+        readonly to: "end";
+    };
+};
+/** The locked roster's door, a checked one: it refuses every change, naming why — what a Save over it is answered. */
+export declare const rosterLockedDutiesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly who: import("@elaraai/east").VariantType<{
+        readonly staff: StringType;
+        readonly agency: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+    readonly role: StringType;
+    readonly task: OptionType<StringType>;
+    readonly unpaidBreak: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+    readonly costCentre: StringType;
+    readonly note: StringType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>;
+        insert: StructType<{
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly staff: StringType;
+                readonly agency: StringType;
+            }>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+            readonly role: StringType;
+            readonly task: OptionType<StringType>;
+            readonly unpaidBreak: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+            readonly costCentre: StringType;
+            readonly note: StringType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly who: import("@elaraai/east").VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+                after: StructType<{
+                    readonly who: import("@elaraai/east").VariantType<{
+                        readonly staff: StringType;
+                        readonly agency: StringType;
+                    }>;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                    readonly role: StringType;
+                    readonly task: OptionType<StringType>;
+                    readonly unpaidBreak: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                    readonly costCentre: StringType;
+                    readonly note: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: import("@elaraai/east").VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                        after: import("@elaraai/east").VariantType<{
+                            readonly staff: StringType;
+                            readonly agency: StringType;
+                        }>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        readonly staff: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                        readonly agency: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly start: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly shift: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly role: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly task: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly unpaidBreak: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: FloatType;
+                        after: FloatType;
+                    }>;
+                }>;
+                readonly agreed: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<BooleanType>;
+                        after: OptionType<BooleanType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: BooleanType;
+                                after: BooleanType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly costCentre: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly note: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+/**
+ * Another app's fit over the same staff: the warehouse's order — the most spare contract hours first, whatever
+ * their group — and a warning on whoever the slot's shift would take past their contract.
+ */
+export declare const rosterContractFitBody: import("@elaraai/east").CallableFunctionExpr<[StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly week: StructType<{
+        readonly status: import("@elaraai/east").VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: OptionType<DateTimeType>;
+            }>;
+            readonly other: StringType;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly hours: FloatType;
+            readonly row: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    readonly staff: StringType;
+                    readonly agency: StringType;
+                }>;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly shift: StringType;
+                readonly team: StringType;
+                readonly role: StringType;
+                readonly task: OptionType<StringType>;
+                readonly unpaidBreak: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+                readonly costCentre: StringType;
+                readonly note: StringType;
+            }>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: import("@elaraai/east").SetType<StringType>;
+    }>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+        readonly groups: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly activities: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly group: OptionType<StringType>;
+        }>>;
+        readonly shifts: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+        }>>;
+        readonly positions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+        }>>;
+        readonly agencies: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+        }>>;
+        readonly rules: StructType<{
+            readonly rest: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+            readonly skill: BooleanType;
+        }>;
+    }>;
+    readonly coverage: DictType<StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: IntegerType;
+        readonly filled: IntegerType;
+        readonly open: IntegerType;
+        readonly people: IntegerType;
+        readonly hours: StructType<{
+            readonly permanent: FloatType;
+            readonly agency: FloatType;
+            readonly requested: FloatType;
+            readonly needed: FloatType;
+            readonly rostered: FloatType;
+        }>;
+        readonly lines: ArrayType<StructType<{
+            readonly skill: StringType;
+            readonly needed: FloatType;
+            readonly holders: OptionType<IntegerType>;
+            readonly capacity: OptionType<FloatType>;
+            readonly gap: FloatType;
+            readonly assigned: FloatType;
+        }>>;
+        readonly cost: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
+    }>>;
+}>], StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly people: DictType<StringType, import("@elaraai/east").VariantType<{
+        readonly fits: StructType<{
+            readonly score: FloatType;
+            readonly why: StringType;
+            readonly warn: OptionType<StringType>;
+        }>;
+        readonly refused: StructType<{
+            readonly group: StringType;
+            readonly reason: StringType;
+            readonly measure: import("@elaraai/east").VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>>;
+export declare const rosterContractFit: import("@elaraai/e3").FunctionDef<[StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly week: StructType<{
+        readonly status: import("@elaraai/east").VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: OptionType<DateTimeType>;
+            }>;
+            readonly other: StringType;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: import("@elaraai/east").VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly hours: FloatType;
+            readonly row: StructType<{
+                readonly who: import("@elaraai/east").VariantType<{
+                    readonly staff: StringType;
+                    readonly agency: StringType;
+                }>;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly shift: StringType;
+                readonly team: StringType;
+                readonly role: StringType;
+                readonly task: OptionType<StringType>;
+                readonly unpaidBreak: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+                readonly costCentre: StringType;
+                readonly note: StringType;
+            }>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: import("@elaraai/east").SetType<StringType>;
+    }>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: import("@elaraai/east").SetType<StringType>;
+            readonly contract: FloatType;
+            readonly agency: BooleanType;
+            readonly trainer: BooleanType;
+            readonly trainee: BooleanType;
+            readonly usual: OptionType<StringType>;
+        }>>;
+        readonly groups: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly activities: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly group: OptionType<StringType>;
+        }>>;
+        readonly shifts: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly start: StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>;
+            readonly hours: FloatType;
+        }>>;
+        readonly positions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+            readonly lead: BooleanType;
+        }>>;
+        readonly agencies: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+        }>>;
+        readonly rules: StructType<{
+            readonly rest: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+            readonly skill: BooleanType;
+        }>;
+    }>;
+    readonly coverage: DictType<StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: IntegerType;
+        readonly filled: IntegerType;
+        readonly open: IntegerType;
+        readonly people: IntegerType;
+        readonly hours: StructType<{
+            readonly permanent: FloatType;
+            readonly agency: FloatType;
+            readonly requested: FloatType;
+            readonly needed: FloatType;
+            readonly rostered: FloatType;
+        }>;
+        readonly lines: ArrayType<StructType<{
+            readonly skill: StringType;
+            readonly needed: FloatType;
+            readonly holders: OptionType<IntegerType>;
+            readonly capacity: OptionType<FloatType>;
+            readonly gap: FloatType;
+            readonly assigned: FloatType;
+        }>>;
+        readonly cost: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
+    }>>;
+}>], StructType<{
+    readonly need: import("@elaraai/east").VariantType<{
+        readonly leads: NullType;
+        readonly trainers: NullType;
+        readonly skill: StringType;
+    }>;
+    readonly slot: StructType<{
+        readonly day: IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly people: DictType<StringType, import("@elaraai/east").VariantType<{
+        readonly fits: StructType<{
+            readonly score: FloatType;
+            readonly why: StringType;
+            readonly warn: OptionType<StringType>;
+        }>;
+        readonly refused: StructType<{
+            readonly group: StringType;
+            readonly reason: StringType;
+            readonly measure: import("@elaraai/east").VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>>;
+export declare const rosterWarehouse: import("@elaraai/east").ExampleDef<[], any>;
+export declare const rosterMobile: import("@elaraai/east").ExampleDef<[], any>;
+export declare const rosterPeople: import("@elaraai/east").ExampleDef<[], any>;
+export declare const rosterWeek: import("@elaraai/east").ExampleDef<[], any>;
+export declare const rosterWindowed: import("@elaraai/east").ExampleDef<[], any>;
+/** A duty of the smallest roster: who, as a staff key; when, as worked; its shift and its team. */
+export declare const MinimalDuty: StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>;
+/** One of its staff: a name and a team. */
+export declare const MinimalWorker: StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+}>;
+/** One of its shifts: a name, a code, when it starts, its hours and where it shows. */
+export declare const MinimalShiftTime: StructType<{
+    readonly name: StringType;
+    readonly code: StringType;
+    readonly starts: StructType<{
+        readonly hour: IntegerType;
+        readonly minute: IntegerType;
+    }>;
+    readonly hours: FloatType;
+    readonly order: IntegerType;
+}>;
+/** One of its teams: a name. */
+export declare const MinimalTeam: StructType<{
+    readonly name: StringType;
+}>;
+export declare const minimalDuties: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>>, [variant<"field", "records">, variant<"field", "rota_minimal_duties">]>;
+export declare const minimalDutiesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly person: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly shift: StringType;
+    readonly team: StringType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>;
+        insert: StructType<{
+            readonly person: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly shift: StringType;
+            readonly team: StringType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly person: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                }>;
+                after: StructType<{
+                    readonly person: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                    readonly shift: StringType;
+                    readonly team: StringType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly person: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly end: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+                readonly shift: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly team: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const minimalWorkers: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+}>>, [variant<"field", "records">, variant<"field", "rota_minimal_workers">]>;
+export declare const minimalShiftTimes: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly code: StringType;
+    readonly starts: StructType<{
+        readonly hour: IntegerType;
+        readonly minute: IntegerType;
+    }>;
+    readonly hours: FloatType;
+    readonly order: IntegerType;
+}>>, [variant<"field", "records">, variant<"field", "rota_minimal_shift_times">]>;
+export declare const minimalTeams: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "rota_minimal_teams">]>;
 export declare const rosterMinimal: import("@elaraai/east").ExampleDef<[], any>;
 export declare const rosterPublished: import("@elaraai/east").ExampleDef<[], any>;
 export declare const rosterCustomInspector: import("@elaraai/east").ExampleDef<[], any>;