@elaraai/e3-ui 1.0.94 → 1.0.95

package/dist/src/roster/types.d.ts

@@ -2,11 +2,21 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { ArrayType, BooleanType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, SetType, StringType, StructType, VariantType } from "@elaraai/east";
 /**
- * One shift of one group on one day. Day zero is the record key's UTC date.
+ * The Roster's East types (#1368, `Builder Interfaces Spec.md` §5.3). A week
+ * is the Roster's reading of the app's own rows — each duty the app's row,
+ * with the roles the Roster reads from it — carried in the fit's, the pay's
+ * and the check's requests and in the renderer, and stored nowhere. The types
+ * over a week take the app's duty row type, `R`: each is a constructor, and
+ * the same `R` gives the same East type (`isTypeEqual`).
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, VariantType, type EastType } from "@elaraai/east";
+/**
+ * One shift of one group on one day of the week.
  * @remarks Slot keys compare by East value, including when decoded in the browser.
- * @property day - Day within the week, from zero to six
+ * @property day - Day within the week, from zero to six: the duty's day (§5.5, rule 1) less the week's first
  * @property group - Group key
  * @property shift - Shift key
  */
@@ -17,10 +27,10 @@ export declare const RosterSlotType: StructType<{
 }>;
 export type RosterSlotType = typeof RosterSlotType;
 /**
- * The subject of an assignment.
+ * Who a duty is: a person, or an agency asked to send someone.
  * @remarks Requests reserve positions without pretending an agency has supplied a named person.
- * @property person - The original staff record key
- * @property request - The agency asked to supply someone
+ * @property person - The person's key, of the `people` resource kind
+ * @property request - The agency's key, of the `agencies` resource kind
  */
 export declare const RosterWhoType: VariantType<{
     readonly person: StringType;
@@ -28,17 +38,15 @@ export declare const RosterWhoType: VariantType<{
 }>;
 export type RosterWhoType = typeof RosterWhoType;
 /**
- * An assignment stored within one week.
- * @remarks A start offset moves the start; overtime extends the end. Agreement is absent for an unchanged shift.
- * @property slot - The day, group and shift
- * @property who - A named person or an agency request
- * @property position - Position held on this assignment
- * @property activity - One skill or duty, or none
- * @property offset - Start offset in hours, negative for an early start
- * @property overtime - Additional hours after the shift
- * @property agreed - Whether the person agreed to changed hours
- */
-export declare const RosterAssignmentType: StructType<{
+ * One duty, as the Roster reads it from the app's row (`R`): its slot, who it
+ * is, and its roles, beside the row itself, every field of it.
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The assignment type over it
+ * @remarks Its times are the duty's own; the Roster gives them no name and no worth (§5.5). Its `hours` are what the duty counts.
+ */
+export declare function RosterAssignmentTypeFor<R extends EastType>(row: R): StructType<{
     readonly slot: StructType<{
         readonly day: IntegerType;
         readonly group: StringType;
@@ -50,11 +58,13 @@ export declare const RosterAssignmentType: StructType<{
     }>;
     readonly position: StringType;
     readonly activity: OptionType<StringType>;
-    readonly offset: FloatType;
-    readonly overtime: FloatType;
-    readonly agreed: OptionType<BooleanType>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly hours: FloatType;
+    readonly row: R;
 }>;
-export type RosterAssignmentType = typeof RosterAssignmentType;
+/** Type representing {@link RosterAssignmentTypeFor}. */
+export type RosterAssignmentTypeFor<R extends EastType> = ReturnType<typeof RosterAssignmentTypeFor<R>>;
 /**
  * A slot's staffing and work targets.
  * @remarks A duty needs assigned hours, whereas a skill also has holder capacity.
@@ -77,32 +87,35 @@ export declare const RosterRequirementsType: DictType<StructType<{
 }>>;
 export type RosterRequirementsType = typeof RosterRequirementsType;
 /**
- * The durable status of a week.
- * @remarks Publishing saves the complete week and its status atomically.
+ * A week's status: Schedule's period status, read from the app's weeks record
+ * (`Schedule.periods`).
  * @property draft - An editable week
- * @property published - A read-only week and its publication instant
+ * @property published - A read-only week, and when it was published when the app's published case holds the time
+ * @property other - Another case of the app's status, by its name: read-only
  */
 export declare const RosterStatusType: VariantType<{
     readonly draft: NullType;
     readonly published: StructType<{
-        readonly at: DateTimeType;
+        readonly at: OptionType<DateTimeType>;
     }>;
+    readonly other: StringType;
 }>;
 export type RosterStatusType = typeof RosterStatusType;
 /**
- * The single atomic entry in the roster record.
- * @remarks Assignments, targets, dismissals and publication share one optimistic patch baseline.
- * @property status - Draft or published
- * @property assignments - Assignments by stable identifier
- * @property requirements - Targets by slot
- * @property dismissed - Proposal identifiers rejected for this week
+ * One week of the app's rows, as the Roster reads them.
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The week type over it
+ * @remarks Its assignments are the week's duties by their keys; its requirements the app's targets by slot; its status and its dismissals the app's week row's.
  */
-export declare const RosterWeekType: StructType<{
+export declare function RosterWeekTypeFor<R extends EastType>(row: R): StructType<{
     readonly status: VariantType<{
         readonly draft: NullType;
         readonly published: StructType<{
-            readonly at: DateTimeType;
+            readonly at: OptionType<DateTimeType>;
         }>;
+        readonly other: StringType;
     }>;
     readonly assignments: DictType<StringType, StructType<{
         readonly slot: StructType<{
@@ -116,9 +129,10 @@ export declare const RosterWeekType: StructType<{
         }>;
         readonly position: StringType;
         readonly activity: OptionType<StringType>;
-        readonly offset: FloatType;
-        readonly overtime: FloatType;
-        readonly agreed: OptionType<BooleanType>;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly hours: FloatType;
+        readonly row: R;
     }>>;
     readonly requirements: DictType<StructType<{
         readonly day: IntegerType;
@@ -130,80 +144,57 @@ export declare const RosterWeekType: StructType<{
     }>>;
     readonly dismissed: SetType<StringType>;
 }>;
-export type RosterWeekType = typeof RosterWeekType;
-/** Weeks keyed by their first day at UTC midnight. @remarks This is the roster record's stored wire type. */
-export declare const RosterWeeksType: DictType<DateTimeType, StructType<{
-    readonly status: VariantType<{
-        readonly draft: NullType;
-        readonly published: StructType<{
-            readonly at: DateTimeType;
-        }>;
-    }>;
-    readonly assignments: DictType<StringType, StructType<{
-        readonly slot: StructType<{
-            readonly day: IntegerType;
-            readonly group: StringType;
-            readonly shift: StringType;
-        }>;
-        readonly who: VariantType<{
-            readonly person: StringType;
-            readonly request: StringType;
-        }>;
-        readonly position: StringType;
-        readonly activity: OptionType<StringType>;
-        readonly offset: FloatType;
-        readonly overtime: FloatType;
-        readonly agreed: OptionType<BooleanType>;
-    }>>;
-    readonly requirements: DictType<StructType<{
-        readonly day: IntegerType;
-        readonly group: StringType;
-        readonly shift: StringType;
-    }>, StructType<{
-        readonly positions: IntegerType;
-        readonly hours: DictType<StringType, FloatType>;
-    }>>;
-    readonly dismissed: SetType<StringType>;
-}>>;
-export type RosterWeeksType = typeof RosterWeeksType;
+/** Type representing {@link RosterWeekTypeFor}. */
+export type RosterWeekTypeFor<R extends EastType> = ReturnType<typeof RosterWeekTypeFor<R>>;
 /**
- * A skill within a group, or a duty available to every group.
- * @remarks Keys are unique across all skills and duties.
- * @property key - Stable identifier
+ * One row of an activities record, keyed by the activity's key: a skill of one
+ * group, or a duty of none, which every group may assign (#1342).
+ * @remarks `Roster.activities` reads a record of these, or of the app's own rows through its accessors.
  * @property label - Display name
  * @property code - Short code on assignment chips
+ * @property group - The group whose skill it is; none, a duty every group shares
+ */
+export declare const RosterActivityType: StructType<{
+    readonly label: StringType;
+    readonly code: StringType;
+    readonly group: OptionType<StringType>;
+}>;
+export type RosterActivityType = typeof RosterActivityType;
+/**
+ * An activity resolved from the author's keyed activities: a skill within a
+ * group, or a duty available to every group.
+ * @remarks Keys are unique across all skills and duties: they are the activities record's keys.
+ * @property key - Stable identifier: its key in the activities record
+ * @property label - Display name
+ * @property code - Short code on assignment chips
+ * @property group - The group whose skill it is; none, a duty
  */
 export declare const RosterSkillType: StructType<{
     readonly key: StringType;
     readonly label: StringType;
     readonly code: StringType;
+    readonly group: OptionType<StringType>;
 }>;
 export type RosterSkillType = typeof RosterSkillType;
 /**
- * A group of people and the skills its work requires.
+ * A group of people. Its skills are the activities of that group.
  * @remarks The array order controls the grid and library order.
  * @property key - Stable identifier
  * @property label - Display name
- * @property skills - Skills in display order
  */
 export declare const RosterGroupType: StructType<{
     readonly key: StringType;
     readonly label: StringType;
-    readonly skills: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly code: StringType;
-    }>>;
 }>;
 export type RosterGroupType = typeof RosterGroupType;
 /**
- * A recurring shift's time and nominal hours.
- * @remarks An end past midnight belongs to the following day; the assignment still belongs to its start day.
+ * A recurring shift's start and nominal hours.
+ * @remarks An end past midnight belongs to the following day; a duty still belongs to its shift's start day.
  * @property key - Stable identifier
  * @property label - Display name
  * @property code - Short code in the week layout
  * @property start - Start time in UTC, shared with Schedule
- * @property hours - Nominal shift duration
+ * @property hours - Nominal shift duration: what a new duty runs, and a skill holder's capacity
  */
 export declare const RosterShiftType: StructType<{
     readonly key: StringType;
@@ -234,7 +225,7 @@ export type RosterPositionType = typeof RosterPositionType;
 /**
  * An agency from which positions may be requested.
  * @remarks The first agency supplies the suggested open-position fix.
- * @property key - Stable identifier
+ * @property key - Stable identifier: its key in the `agencies` resource kind
  * @property name - Display name
  */
 export declare const RosterAgencyType: StructType<{
@@ -243,8 +234,8 @@ export declare const RosterAgencyType: StructType<{
 }>;
 export type RosterAgencyType = typeof RosterAgencyType;
 /**
- * A person resolved from the author's keyed staff data.
- * @remarks Roster reads staff; all edits go to the weeks record.
+ * A person resolved from the app's staff rows (the `people` resource kind).
+ * @remarks Roster reads staff; it never writes them.
  * @property key - Original staff key
  * @property name - Display name
  * @property group - Home group
@@ -272,48 +263,28 @@ export type RosterPersonType = typeof RosterPersonType;
 /**
  * Built-in checks enabled for the roster.
  * @remarks Rest reads this week only; double booking is always reported.
- * @property rest - Minimum hours between shifts; zero disables the rest check
+ * @property rest - Minimum hours between duties; zero disables the rest check
  * @property lead - Check staffed slots for a lead
  * @property trainer - Check trainees have a trainer
  * @property skill - Check activities against held skills
- * @property agree - Report unagreed changed hours
  */
 export declare const RosterRulesType: StructType<{
     readonly rest: FloatType;
     readonly lead: BooleanType;
     readonly trainer: BooleanType;
     readonly skill: BooleanType;
-    readonly agree: BooleanType;
 }>;
 export type RosterRulesType = typeof RosterRulesType;
-/**
- * Optional costing configuration.
- * @remarks Omitting costs hides monetary readouts; it does not affect staffing checks.
- * @property currency - Currency identifier for the shared formatter
- * @property rates - Permanent, overtime and agency hourly rates
- * @property budget - Daily budget, or none
- */
-export declare const RosterCostsType: StructType<{
-    readonly currency: StringType;
-    readonly rates: StructType<{
-        readonly permanent: FloatType;
-        readonly overtime: FloatType;
-        readonly agency: FloatType;
-    }>;
-    readonly budget: OptionType<FloatType>;
-}>;
-export type RosterCostsType = typeof RosterCostsType;
 /**
  * Complete reference data used by coverage and checks.
- * @remarks Visibility filters never remove people from this context.
+ * @remarks Visibility filters never remove people or activities from this context.
  * @property people - All resolved staff by original key
- * @property groups - Groups and their skills
- * @property duties - Activities available to every group
+ * @property groups - Groups
+ * @property activities - Every activity: each group's skills, and the duties of no group
  * @property shifts - Shift definitions
  * @property positions - Position definitions
  * @property agencies - Agencies available for gap fixes
  * @property rules - Enabled rules
- * @property costs - Optional monetary configuration
  */
 export declare const RosterContextType: StructType<{
     readonly people: DictType<StringType, StructType<{
@@ -331,16 +302,12 @@ export declare const RosterContextType: StructType<{
     readonly groups: ArrayType<StructType<{
         readonly key: StringType;
         readonly label: StringType;
-        readonly skills: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly label: StringType;
-            readonly code: StringType;
-        }>>;
     }>>;
-    readonly duties: ArrayType<StructType<{
+    readonly activities: ArrayType<StructType<{
         readonly key: StringType;
         readonly label: StringType;
         readonly code: StringType;
+        readonly group: OptionType<StringType>;
     }>>;
     readonly shifts: ArrayType<StructType<{
         readonly key: StringType;
@@ -367,17 +334,7 @@ export declare const RosterContextType: StructType<{
         readonly lead: BooleanType;
         readonly trainer: BooleanType;
         readonly skill: BooleanType;
-        readonly agree: BooleanType;
     }>;
-    readonly costs: OptionType<StructType<{
-        readonly currency: StringType;
-        readonly rates: StructType<{
-            readonly permanent: FloatType;
-            readonly overtime: FloatType;
-            readonly agency: FloatType;
-        }>;
-        readonly budget: OptionType<FloatType>;
-    }>>;
 }>;
 export type RosterContextType = typeof RosterContextType;
 /**
@@ -388,7 +345,7 @@ export type RosterContextType = typeof RosterContextType;
  * @property holders - Number of people holding the skill, or none for a duty
  * @property capacity - Nominal hours available from holders, or none for a duty
  * @property gap - Positive shortfall in skill capacity
- * @property assigned - Hours explicitly assigned to this activity
+ * @property assigned - Hours of the duties assigned to this activity
  */
 export declare const RosterCoverageLineType: StructType<{
     readonly skill: StringType;
@@ -400,15 +357,15 @@ export declare const RosterCoverageLineType: StructType<{
 }>;
 export type RosterCoverageLineType = typeof RosterCoverageLineType;
 /**
- * Staffing, work and costs for a complete slot.
- * @remarks Requests fill positions and contribute requested hours, but never count as named people or skilled holders.
+ * Staffing, work and pay for a complete slot.
+ * @remarks Requests fill positions and contribute their hours, but never count as named people or skilled holders.
  * @property positions - Required positions
  * @property filled - Assignments including requests
  * @property open - Unfilled positions, at least zero
  * @property people - Named people assigned
- * @property hours - Permanent, agency, overtime, requested, needed and total rostered hours
+ * @property hours - Permanent, agency, requested, needed and total rostered hours: each duty's hours
  * @property lines - Required skills in group order, then duties
- * @property cost - Total cost, zero when costs are absent
+ * @property cost - The slot's pay: its duties' costs summed over every code; zero without `pay`
  * @property lead - A named person holds a lead position
  * @property trainer - A trainer is assigned
  */
@@ -420,7 +377,6 @@ export declare const RosterCoverageType: StructType<{
     readonly hours: StructType<{
         readonly permanent: FloatType;
         readonly agency: FloatType;
-        readonly overtime: FloatType;
         readonly requested: FloatType;
         readonly needed: FloatType;
         readonly rostered: FloatType;
@@ -439,42 +395,51 @@ export declare const RosterCoverageType: StructType<{
 }>;
 export type RosterCoverageType = typeof RosterCoverageType;
 /**
- * An externally computed staffing proposal.
- * @remarks Acceptance creates an assignment; rejection stores this key in the week's dismissed set.
- * @property key - Proposal identifier
- * @property week - Week's first day
- * @property slot - Suggested destination
+ * A suggested placement, as the Roster reads it from the app's rows
+ * (`Roster.proposals`).
+ * @remarks Acceptance creates a duty; rejection keeps this key in the week's dismissed set.
+ * @property key - Its row's key
+ * @property day - The day it suggests, a UTC midnight
+ * @property group - The group it suggests
+ * @property shift - The shift it suggests
  * @property person - Original staff key
  * @property reason - Explanation presented to the planner
  */
 export declare const RosterProposalType: StructType<{
     readonly key: StringType;
-    readonly week: DateTimeType;
-    readonly slot: StructType<{
-        readonly day: IntegerType;
-        readonly group: StringType;
-        readonly shift: StringType;
-    }>;
+    readonly day: DateTimeType;
+    readonly group: StringType;
+    readonly shift: StringType;
     readonly person: StringType;
     readonly reason: StringType;
 }>;
 export type RosterProposalType = typeof RosterProposalType;
+/**
+ * What a Find fix looks for (#1334): what the app's fit is asked who fits.
+ * @property leads - Someone in a lead position
+ * @property trainers - Someone who trains others
+ * @property skill - Someone who holds this skill, by its activity key
+ */
+export declare const RosterNeedType: VariantType<{
+    readonly leads: NullType;
+    readonly trainers: NullType;
+    readonly skill: StringType;
+}>;
+export type RosterNeedType = typeof RosterNeedType;
 /**
  * A corrective action offered for an issue.
- * @remarks Every data-changing action is one gesture of the shared edit session.
+ * @remarks Every data-changing action is one gesture of the shared edit history. A find edits nothing: it asks the app's fit who fits its need on the issue's slot, and is offered only when the Roster has a `fit` (#1334).
  * @property request - Request someone from this agency
- * @property agree - Mark the assignment agreed
  * @property accept - Accept this proposal key
- * @property move - Move the assignment to this shift
- * @property start - Set this start offset in hours
- * @property find - Show leads, trainers or holders of a skill in the library
+ * @property move - Move the duty to this shift
+ * @property start - Move the duty to start at this later time, its length kept
+ * @property find - Find who fits this need on the issue's slot: the app's fit's answer, in the People tab
  */
 export declare const RosterFixType: VariantType<{
     readonly request: StringType;
-    readonly agree: NullType;
     readonly accept: StringType;
     readonly move: StringType;
-    readonly start: FloatType;
+    readonly start: DateTimeType;
     readonly find: VariantType<{
         readonly leads: NullType;
         readonly trainers: NullType;
@@ -485,12 +450,12 @@ export type RosterFixType = typeof RosterFixType;
 /**
  * One explanation or warning about the drafted roster.
  * @remarks Warnings do not introduce a separate validation barrier to Save or Publish.
- * @property kind - Breach, gap, agreement or proposal
+ * @property kind - Breach, gap or proposal
  * @property tone - Shared semantic tone
  * @property title - Short explanation
  * @property detail - Supporting explanation
  * @property slot - Affected slot, or none
- * @property assignment - Affected assignment key, or none
+ * @property assignment - Affected duty key, or none
  * @property flag - Short text on a chip, or none
  * @property fix - Offered action, or none
  */
@@ -498,7 +463,6 @@ export declare const RosterIssueType: StructType<{
     readonly kind: VariantType<{
         readonly breach: NullType;
         readonly gap: NullType;
-        readonly agree: NullType;
         readonly proposal: NullType;
     }>;
     readonly tone: VariantType<{
@@ -519,10 +483,9 @@ export declare const RosterIssueType: StructType<{
     readonly flag: OptionType<StringType>;
     readonly fix: OptionType<VariantType<{
         readonly request: StringType;
-        readonly agree: NullType;
         readonly accept: StringType;
         readonly move: StringType;
-        readonly start: FloatType;
+        readonly start: DateTimeType;
         readonly find: VariantType<{
             readonly leads: NullType;
             readonly trainers: NullType;
@@ -531,22 +494,115 @@ export declare const RosterIssueType: StructType<{
     }>>;
 }>;
 export type RosterIssueType = typeof RosterIssueType;
+/**
+ * The app's pay's answer (§5.6): each duty's cost, by its key, in the app's
+ * own pay codes.
+ * @remarks The Roster knows no pay code in advance: it totals what the app gives, by code and in all.
+ */
+export declare const RosterPayType: DictType<StringType, DictType<StringType, FloatType>>;
+export type RosterPayType = typeof RosterPayType;
+/**
+ * One question to the app's pay (§5.6): one person's duties for the week, or
+ * one agency's requests.
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The request type over it
+ * @remarks `who` is the person or the agency; `duties` its duties, by key; `context` the complete staff and configuration.
+ */
+export declare function RosterPayRequestTypeFor<R extends EastType>(row: R): StructType<{
+    readonly who: VariantType<{
+        readonly person: StringType;
+        readonly request: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly duties: DictType<StringType, StructType<{
+        readonly slot: StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly who: 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: R;
+    }>>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: 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;
+        }>;
+    }>;
+}>;
+/** Type representing {@link RosterPayRequestTypeFor}. */
+export type RosterPayRequestTypeFor<R extends EastType> = ReturnType<typeof RosterPayRequestTypeFor<R>>;
 /**
  * Input to an application's additional roster checks.
- * @remarks The built-in coverage has already been calculated for the same draft.
- * @property start - Week's first day
- * @property week - Drafted week
- * @property context - Complete reference data
- * @property coverage - Coverage for every configured slot
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The check's context over it
+ * @remarks The built-in coverage has already been calculated for the same draft, and so have the pay's costs: `start` the week's first day, `week` the drafted week, `context` the complete reference data, `coverage` every configured slot's, `pay` each duty's costs by code.
  */
-export declare const RosterCheckContextType: StructType<{
+export declare function RosterCheckContextTypeFor<R extends EastType>(row: R): StructType<{
     readonly start: DateTimeType;
     readonly week: StructType<{
         readonly status: VariantType<{
             readonly draft: NullType;
             readonly published: StructType<{
-                readonly at: DateTimeType;
+                readonly at: OptionType<DateTimeType>;
             }>;
+            readonly other: StringType;
         }>;
         readonly assignments: DictType<StringType, StructType<{
             readonly slot: StructType<{
@@ -560,9 +616,10 @@ export declare const RosterCheckContextType: StructType<{
             }>;
             readonly position: StringType;
             readonly activity: OptionType<StringType>;
-            readonly offset: FloatType;
-            readonly overtime: FloatType;
-            readonly agreed: OptionType<BooleanType>;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly hours: FloatType;
+            readonly row: R;
         }>>;
         readonly requirements: DictType<StructType<{
             readonly day: IntegerType;
@@ -590,16 +647,12 @@ export declare const RosterCheckContextType: StructType<{
         readonly groups: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
-            readonly skills: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly code: StringType;
-            }>>;
         }>>;
-        readonly duties: ArrayType<StructType<{
+        readonly activities: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
             readonly code: StringType;
+            readonly group: OptionType<StringType>;
         }>>;
         readonly shifts: ArrayType<StructType<{
             readonly key: StringType;
@@ -626,17 +679,186 @@ export declare const RosterCheckContextType: StructType<{
             readonly lead: BooleanType;
             readonly trainer: BooleanType;
             readonly skill: BooleanType;
-            readonly agree: BooleanType;
         }>;
-        readonly costs: OptionType<StructType<{
-            readonly currency: StringType;
-            readonly rates: StructType<{
-                readonly permanent: FloatType;
-                readonly overtime: FloatType;
-                readonly agency: FloatType;
+    }>;
+    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 pay: DictType<StringType, DictType<StringType, FloatType>>;
+}>;
+/** Type representing {@link RosterCheckContextTypeFor}. */
+export type RosterCheckContextTypeFor<R extends EastType> = ReturnType<typeof RosterCheckContextTypeFor<R>>;
+/** Why someone does not fit a need: Schedule's, shared with the Allocation (#1334). */
+export declare const RosterRefusalType: StructType<{
+    readonly group: StringType;
+    readonly reason: StringType;
+    readonly measure: VariantType<{
+        readonly none: NullType;
+        readonly amount: StructType<{
+            readonly lead: StringType;
+            readonly value: FloatType;
+        }>;
+        readonly day: StructType<{
+            readonly lead: StringType;
+            readonly at: DateTimeType;
+        }>;
+    }>;
+}>;
+export type RosterRefusalType = typeof RosterRefusalType;
+/** One verdict of the app's fit: Schedule's, shared with the Allocation — it fits with a score, a reason and a warning, or it is refused (#1334). */
+export declare const RosterFitType: 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: VariantType<{
+            readonly none: NullType;
+            readonly amount: StructType<{
+                readonly lead: StringType;
+                readonly value: FloatType;
+            }>;
+            readonly day: StructType<{
+                readonly lead: StringType;
+                readonly at: DateTimeType;
             }>;
-            readonly budget: OptionType<FloatType>;
+        }>;
+    }>;
+}>;
+export type RosterFitType = typeof RosterFitType;
+/**
+ * One question to the app's fit (#1334): who fits a Find fix's need on its
+ * issue's slot, over the drafted week.
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The request type over it
+ * @remarks `need` what is looked for, `slot` the issue's, `start` the week's first day, `week` the drafted week, `context` the complete staff and configuration — every person, whatever the rail shows — and `coverage` the drafted week's.
+ */
+export declare function RosterFitRequestTypeFor<R extends EastType>(row: R): StructType<{
+    readonly need: 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: 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: 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: R;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: SetType<StringType>;
+    }>;
+    readonly context: StructType<{
+        readonly people: DictType<StringType, StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: StringType;
+            readonly position: StringType;
+            readonly skills: 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;
@@ -650,7 +872,6 @@ export declare const RosterCheckContextType: StructType<{
         readonly hours: StructType<{
             readonly permanent: FloatType;
             readonly agency: FloatType;
-            readonly overtime: FloatType;
             readonly requested: FloatType;
             readonly needed: FloatType;
             readonly rostered: FloatType;
@@ -668,5 +889,429 @@ export declare const RosterCheckContextType: StructType<{
         readonly trainer: BooleanType;
     }>>;
 }>;
-export type RosterCheckContextType = typeof RosterCheckContextType;
+/** Type representing {@link RosterFitRequestTypeFor}. */
+export type RosterFitRequestTypeFor<R extends EastType> = ReturnType<typeof RosterFitRequestTypeFor<R>>;
+/**
+ * Where a duty sits, as the Roster reads it from its roles (§5.5, rules 1 and
+ * 8): placed in the week, another week's, or a duty the Roster cannot place —
+ * one whose shift or group isn't configured, or that names no one — which it
+ * lists in Issues and keeps as stored.
+ *
+ * @typeParam R - The app's duty row type
+ * @param row - The app's duty row type
+ * @returns The placement type over it
+ * @remarks `placed` the duty as the week holds it; `elsewhere` a duty of another week; `unplaced` the issue that lists it.
+ */
+export declare function RosterPlacementTypeFor<R extends EastType>(row: R): VariantType<{
+    readonly placed: StructType<{
+        readonly slot: StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly who: 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: R;
+    }>;
+    readonly elsewhere: NullType;
+    readonly unplaced: StructType<{
+        readonly kind: VariantType<{
+            readonly breach: NullType;
+            readonly gap: NullType;
+            readonly proposal: NullType;
+        }>;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly title: StringType;
+        readonly detail: StringType;
+        readonly slot: OptionType<StructType<{
+            readonly day: IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>>;
+        readonly assignment: OptionType<StringType>;
+        readonly flag: OptionType<StringType>;
+        readonly fix: OptionType<VariantType<{
+            readonly request: StringType;
+            readonly accept: StringType;
+            readonly move: StringType;
+            readonly start: DateTimeType;
+            readonly find: VariantType<{
+                readonly leads: NullType;
+                readonly trainers: NullType;
+                readonly skill: StringType;
+            }>;
+        }>>;
+    }>;
+}>;
+/** Type representing {@link RosterPlacementTypeFor}. */
+export type RosterPlacementTypeFor<R extends EastType> = ReturnType<typeof RosterPlacementTypeFor<R>>;
+/**
+ * A target's roles, as the Roster reads them from the app's row
+ * (`Roster.targets`): the slot it is for, and what it asks of it.
+ * @property day - The day, a UTC midnight
+ * @property group - The group's key
+ * @property shift - The shift's key
+ * @property positions - Positions to fill
+ * @property hours - Hours required, by activity key
+ */
+export declare const RosterTargetRolesType: StructType<{
+    readonly day: DateTimeType;
+    readonly group: StringType;
+    readonly shift: StringType;
+    readonly positions: IntegerType;
+    readonly hours: DictType<StringType, FloatType>;
+}>;
+export type RosterTargetRolesType = typeof RosterTargetRolesType;
+/**
+ * One stored target, as the targets' `rows` gives it: its roles, read in the
+ * pass that reads the row, and the row as bytes at the row type.
+ * @property roles - Its roles
+ * @property row - Its row, as bytes at the row type
+ */
+export declare const RosterTargetEntryType: StructType<{
+    readonly roles: StructType<{
+        readonly day: DateTimeType;
+        readonly group: StringType;
+        readonly shift: StringType;
+        readonly positions: IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>;
+    readonly row: BlobType;
+}>;
+export type RosterTargetEntryType = typeof RosterTargetEntryType;
+/**
+ * The app's targets, closed (`Roster.targets`): its record of targets, a row
+ * per slot, read and written through its roles over bytes, so the Roster's
+ * payload is one type whatever the record holds.
+ * @property editing - The shared session over the record: whole rows by their key, its patch door
+ * @property entries - The record read by key, when it is given `entries`; `none` for a record read whole
+ * @property rows - The targets whose day falls in `[from, to)`, by key, each its roles and its row; `none` while a read is in flight
+ * @property read - A drafted row's roles, from its bytes
+ * @property write - The row with its roles written, and every other field as it was
+ * @property create - A new row from the roles, every other field its type's default
+ * @property history - The record's commits, newest first
+ * @property inspector - The app's own form for one target, over its row as bytes; `none`, the Roster's
+ * @property rowType - The row type
+ */
+export declare const RosterTargetsKindType: StructType<{
+    readonly editing: StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly rows: FunctionType<[DateTimeType, DateTimeType], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly day: DateTimeType;
+            readonly group: StringType;
+            readonly shift: StringType;
+            readonly positions: IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType], StructType<{
+        readonly day: DateTimeType;
+        readonly group: StringType;
+        readonly shift: StringType;
+        readonly positions: IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>>;
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly day: DateTimeType;
+        readonly group: StringType;
+        readonly shift: StringType;
+        readonly positions: IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>], BlobType>;
+    readonly create: FunctionType<[StructType<{
+        readonly day: DateTimeType;
+        readonly group: StringType;
+        readonly shift: StringType;
+        readonly positions: IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>], BlobType>;
+    readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+}>;
+export type RosterTargetsKindType = typeof RosterTargetsKindType;
+/**
+ * The app's fit's answer (#1334). It echoes its question, so the Roster
+ * matches each answer to the question it asked.
+ * @property need - The need answered
+ * @property slot - The slot answered
+ * @property people - A verdict for every person, by staff key; the People tab shows the fits, best first
+ */
+export declare const RosterFitResultType: StructType<{
+    readonly need: 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, 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: VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>;
+export type RosterFitResultType = typeof RosterFitResultType;
 //# sourceMappingURL=types.d.ts.map