@feedmepos/mf-hrm-portal 2.3.2-dev → 2.3.2-dev.2

package/dist/src/views/scheduling/schedule-store.d.ts

@@ -0,0 +1,140 @@
+import ScheduleAPI from '@/api/schedule';
+import type { IFdtoPosUserSummary } from '@/types/employee';
+import type { FdtoScheduleAssignment, FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleApplyResult, FdtoScheduleAutoScheduleCapabilities, FdtoScheduleAutoScheduleGenerateReq, FdtoScheduleAutoScheduleResult, FdtoScheduleBulkUpdateAssignmentStatusReq, FdtoScheduleCreateEmployeeProfileReq, FdtoScheduleSaveAssignmentReq, FdtoScheduleSavePositionReq, FdtoScheduleSaveScheduleDayReq, FdtoScheduleSaveSettingsReq, FdtoScheduleSettings, FdtoScheduleUpdateEmployeeProfileReq, FdtoScheduleValidatePosAccessReq, FdtoScheduleCreateTimeOffReq, FdtoScheduleTimeOff, FdtoScheduleUpdateTimeOffStatusReq, FdtoScheduleSaveEmployeeConfigsReq, ScheduleReplaceDemandReq } from '@/types/schedule';
+import { isoDateKey } from './composables/schedule-calendar';
+export { businessEmployees, dataVersion, employeeOutletIds, loadError, loading, outletId, payload, restaurantEmployees, employeeConfigs, rosterLoading, scheduleSetupCompleted, } from './schedule-state';
+/** dayjs-free local-date key — the board's own isoDateKey, repeated here so the store does not
+ * have to import a composable. Local Y/M/D, never UTC: a BSON-free 'YYYY-MM-DD' that survives
+ * a timezone west of Greenwich. */
+export declare const isoDate: typeof isoDateKey;
+/** Called from the scheduling page's setup with `useI18n().t`, so the store's errors follow
+ * the portal locale. Pass `null` to fall back to English. */
+export declare function setScheduleStoreTranslator(t: ((key: string) => string) | null): void;
+/** Points the board at an outlet. Switching throws the held window away rather than widening
+ * it — two outlets' rosters are not one dataset, and half of each is not a schedule.
+ *
+ * Returns whether anything changed, so a caller that has to follow up with a fetch can skip
+ * the round trip when the picker was set to what was already showing. */
+export declare function setOutlet(restaurantId: string): boolean;
+/** Fetches (once per outlet) who the POS roster says works here, straight off the same
+ * `restaurantIds`-filterable endpoint the portal's own Employee List uses — no Schedule-side
+ * concept of outlet membership to keep in sync with it. Bumps `dataVersion` on arrival so the
+ * board's per-week employee cache (keyed off it already) picks the roster up without a second,
+ * separate invalidation path. A generous page size rather than looping pages: real restaurant
+ * headcounts sit nowhere near it. */
+export declare function ensureRestaurantEmployeesLoaded(restaurantId: string): Promise<void>;
+export declare function saveEmployeeConfigs(configs: FdtoScheduleSaveEmployeeConfigsReq['configs']): Promise<void>;
+/** Saves outlet settings and keeps the board payload authoritative for any later cache rebuild. */
+export declare function saveScheduleSettings(req: FdtoScheduleSaveSettingsReq): Promise<FdtoScheduleSettings>;
+export declare function setEmployeeSchedulingEnabled(employeeId: string, enabled: boolean): Promise<void>;
+/** Removes this employee's future shifts before disabling their scheduling row. */
+export declare function deleteEmployeeFutureAssignments(employeeId: string, from?: string): Promise<void>;
+/** Re-reads this outlet's POS roster. The roster is what the board's rows are built from and is
+ * otherwise fetched once per outlet, so any write that changes who works here (add, remove)
+ * has to call this for the grid to show it. */
+export declare function refreshRestaurantEmployees(): Promise<void>;
+/** Gives an existing POS user a role at this outlet, so they land on its roster. */
+export declare function addEmployeeToOutlet(employeeId: string, roleId: string): Promise<void>;
+/** Adds an employee to several outlets at once. Scheduling does not require a POS role, so the
+ * caller may pass an empty role id and assign the POS role later from Employee. */
+export declare function addEmployeeToOutlets(employeeId: string, restaurantIds: string[], roleId?: string, enableScheduling?: boolean): Promise<void>;
+/** Takes a POS user off the given outlets' rosters; their other outlets are untouched. */
+export declare function removeEmployeeFromOutlets(employeeId: string, restaurantIds: string[]): Promise<void>;
+/** Takes a POS user off this outlet's roster only. */
+export declare function removeEmployeeFromOutlet(employeeId: string): Promise<void>;
+/** Sets the POS role each of these outlets grants a user — every other outlet on their roster
+ * is untouched. An empty roleId means "linked to this outlet, no role assigned" (the same thing
+ * `addEmployeeToOutlets`' default gives), not "remove them from it" — use
+ * `removeEmployeeFromOutlets` for that. A duplicate restaurantId keeps only the last entry. */
+export declare function setEmployeePosRoles(employeeId: string, assignments: {
+    restaurantId: string;
+    roleId: string;
+}[]): Promise<void>;
+/** Saves the POS-owned part of an existing scheduling employee. The scheduling profile and the
+ * POS user are separate records, so passcode/master-user changes must use the POS user API too.
+ * A normalized comparison avoids rewriting the POS user when the employee form was unchanged. */
+export declare function saveEmployeePosAccess(employeeId: string, request: {
+    name: string;
+    passcode: string;
+    masterUser: boolean;
+    masterCode: string;
+    roles: {
+        restaurantId: string;
+        roleId: string;
+    }[];
+}, knownEmployee?: IFdtoPosUserSummary): Promise<void>;
+/** The cached business roster, fetched on first use. `force` re-reads it (after a write, or to
+ * refresh a list that is already on screen). Concurrent callers share one request. */
+export declare function ensureBusinessEmployees(force?: boolean): Promise<IFdtoPosUserSummary[]>;
+/** Guarantees the week starting `weekStart` is in memory, fetching a padded window around it
+ * if it is not. Safe to call on every navigation: a week already covered costs nothing. */
+export declare function ensureWeekLoaded(weekStart: Date): Promise<void>;
+/** Re-reads the currently held window from the API — what a write path calls once it has
+ * saved, and what the page offers after a failure. */
+export declare function reload(): Promise<void>;
+/** Puts an existing employee onto the current outlet's schedule. Pushes the record the API
+ * hands back straight onto the held payload instead of reloading — a reload re-derives every
+ * employee's shifts from what's actually stored, and shifts have no write path of their own
+ * yet, so it would silently discard any shift assigned to anyone else on the board earlier in
+ * the same sitting (the same bug shape saveDemand's callers used to have). data.ts's
+ * `employeeNumberOf` assigns the new hire a board id the next time it runs, same as it does for
+ * everyone loaded from the initial read, so nothing here needs to know that mapping itself.
+ * Throws on failure (a duplicate profile, a network error) — the caller decides how to show
+ * that, this just doesn't pretend it succeeded. */
+export declare function createEmployeeProfile(req: FdtoScheduleCreateEmployeeProfileReq): Promise<void>;
+export declare function validateSchedulePosAccess(req: FdtoScheduleValidatePosAccessReq): Promise<void>;
+/** Edits a profile already on this outlet's schedule. The caller (useScheduleAddEmployee's
+ * `updateExisting`) applies the form to the live `Employee` object itself for instant feedback,
+ * so this does not bump `dataVersion` — nothing needs a board cache rebuild. The raw payload is
+ * still replaced immutably so other views, such as the position usage counter, observe the
+ * profile change immediately instead of waiting for the next full board reload. */
+export declare function updateEmployeeProfile(employeeId: string, req: FdtoScheduleUpdateEmployeeProfileReq): Promise<void>;
+/** Positions are business-level, not per-outlet (see `ScheduleAPI.createPosition`'s own note)
+ * — so unlike the shift-shaped writes below, there's no "discards an unsaved shift" risk in
+ * refreshing the catalogue here: `payload` is reassigned as a NEW top-level object (same
+ * `employees`/`assignments`/etc. array references, only `positions` itself replaced) so
+ * data.ts's `watch(payload, applyCatalogues)` re-derives `POSITIONS`/`POSITION_RECORDS` —
+ * without touching `dataVersion`, which would otherwise invalidate the board's per-week
+ * employee cache and risk reverting a shift committed earlier in the same sitting that hasn't
+ * round-tripped into `payload.value.assignments` yet (see createAssignment's own note below). */
+export declare function createPosition(req: FdtoScheduleSavePositionReq): Promise<void>;
+export declare function updatePosition(id: string, req: FdtoScheduleSavePositionReq): Promise<void>;
+export declare function deletePosition(id: string): Promise<void>;
+/** Replaces one date's note/holiday-mark. Same shallow `payload` reassignment as the position
+ * writes above and for the same reason: `useScheduleBoard.ts` seeds its `dayNotes`/
+ * `manualHolidays` state from `payload.value.days` on every `payload` reassignment, so this has
+ * to land there for that seed to stay correct — without a `dataVersion` bump, which would
+ * invalidate the per-week employee cache and risk reverting an unsaved shift. */
+export declare function saveScheduleDay(date: string, req: FdtoScheduleSaveScheduleDayReq): Promise<void>;
+/** Replaces one date's UI demand by expanding every period into flat ShiftDemand rows.
+ * Position-specific headcount becomes its own row; any remaining headcount becomes an
+ * unpositioned row for the same time range. */
+export declare function saveDemand(req: ScheduleReplaceDemandReq): Promise<void>;
+export declare function saveDemandsBulk(requests: ScheduleReplaceDemandReq[]): Promise<void>;
+/** Copies one date's own demand rows onto another date, as that date's own rows. A date that
+ * already has demand of its own is left alone (nothing is overwritten), and a source date with
+ * no explicit rows has nothing to copy. Returns how many rows were written. */
+export declare function copyDateDemand(fromDate: string, toDate: string): Promise<number>;
+export declare function generateAutoSchedule(req: FdtoScheduleAutoScheduleGenerateReq): Promise<FdtoScheduleAutoScheduleResult>;
+export declare function getAutoScheduleCapabilities(): Promise<FdtoScheduleAutoScheduleCapabilities>;
+export declare function applyAutoSchedule(req: FdtoScheduleAutoScheduleApplyReq): Promise<FdtoScheduleAutoScheduleApplyResult>;
+/** A one-off shift assignment — someone working these hours on this date, not answering any
+ * Shift requirement. Keep the raw payload in sync without bumping `dataVersion`: the current
+ * board owns the live draft, while a later roster refresh may rebuild the week cache from this
+ * payload. */
+export declare function createAssignment(req: FdtoScheduleSaveAssignmentReq): Promise<FdtoScheduleAssignment>;
+export declare function updateAssignment(id: string, req: FdtoScheduleSaveAssignmentReq): Promise<FdtoScheduleAssignment | null>;
+export declare function bulkSaveAssignments(req: Parameters<typeof ScheduleAPI.bulkSaveAssignments>[1]): Promise<Awaited<ReturnType<typeof ScheduleAPI.bulkSaveAssignments>>>;
+/** Replaces demand and/or assignments in one backend transaction. */
+export declare function copySchedule(req: Parameters<typeof ScheduleAPI.copySchedule>[1]): Promise<Awaited<ReturnType<typeof ScheduleAPI.copySchedule>>>;
+/** Clears demand and/or assignments in one backend transaction. */
+export declare function clearSchedule(req: Parameters<typeof ScheduleAPI.clearSchedule>[1]): Promise<Awaited<ReturnType<typeof ScheduleAPI.clearSchedule>>>;
+/** Deletes a batch of existing assignments in a single request — see
+ * `ScheduleAPI.deleteAssignments`. Deleting one is just this with a single-id array. */
+export declare function deleteAssignments(ids: string[]): Promise<void>;
+export declare function createTimeOff(req: FdtoScheduleCreateTimeOffReq): Promise<FdtoScheduleTimeOff>;
+export declare function updateTimeOffStatus(id: string, req: FdtoScheduleUpdateTimeOffStatusReq): Promise<FdtoScheduleTimeOff | null>;
+export declare function deleteTimeOff(id: string): Promise<void>;
+/** Flips a batch of existing assignments to one status in a single request — see
+ * `ScheduleAPI.bulkUpdateAssignmentStatus`. */
+export declare function bulkUpdateAssignmentStatus(req: FdtoScheduleBulkUpdateAssignmentStatusReq): Promise<FdtoScheduleAssignment[]>;

package/dist/src/views/scheduling/types.d.ts

@@ -0,0 +1,381 @@
+export type ShiftStatus = 'confirmed' | 'pending' | 'ot';
+export interface ShiftClock {
+    in: string | null;
+    out: string | null;
+    status: 'on-time' | 'late' | 'early-out' | 'absent';
+}
+export interface WorkSlot {
+    start: string;
+    end: string;
+    role: string;
+    /** The persisted position identity, retained even when the position is soft-deleted. */
+    positionId?: string;
+    status: ShiftStatus;
+    clock?: ShiftClock;
+    conflict?: boolean;
+    conflictReason?: string;
+    /** Set when this slot is the filled form of an OpenShift record. */
+    openId?: number;
+    /** Unpaid break length in minutes, authored in the shift popover. Not currently
+     * subtracted by the cost rail / stats row's hour totals — those stay gross-hours,
+     * matching how this board priced shifts before the popover surfaced a break field. */
+    breakMins?: number;
+    /** Breaks as persisted by ScheduleShiftAssignments. `breakMins` remains a derived board calculation
+     * value; API writes use only this array. */
+    breaks?: Array<{
+        type: 'DURATION';
+        minutes: number;
+        breakPayType: 'PAID' | 'UNPAID';
+    } | {
+        type: 'TIME_RANGE';
+        startTime: string;
+        endTime: string;
+        breakPayType: 'PAID' | 'UNPAID';
+    }>;
+    /** The ScheduleShiftAssignments document this slot is saved as, once it has one — see
+     * useScheduleBoard's commitShift/removeShift/moveShift. Absent means either it hasn't
+     * round-tripped to the backend yet, or it's an OpenShift fill (see openId), which has its
+     * own record shape and no write path of its own yet. */
+    assignmentId?: string;
+    /** Server timestamp used to reject stale background saves. */
+    updatedAt?: string;
+    /** Client-only — never sent to the backend (there's no linking field in
+     * FdtoScheduleAssignment to persist it against). Shared by every period of ONE shift
+     * authored through the popover's "+ Split", set there and nowhere else. Two workslots on
+     * the same day with no matching `splitGroupId` are two independent shifts, not one split
+     * shift — e.g. a day where a swap landed a second shift alongside one the person already
+     * had. Lost on reload, which is the safe direction to fail in: an unrecognised pair just
+     * reads as two separate shifts rather than a false merge. */
+    splitGroupId?: string;
+}
+export interface LeaveBalance {
+    type: string;
+    entitled: number;
+    used: number;
+}
+export interface LeaveSlot {
+    timeOff: 'approved' | 'pending';
+    requestId?: string;
+    type?: 'OFF_DAY' | 'LEAVE';
+    leaveType?: 'ANNUAL' | 'MEDICAL' | 'EMERGENCY' | 'UNPAID';
+    reason: string;
+    half?: boolean;
+    halfPart?: 'AM' | 'PM';
+    /** Half-day leave's displayed time window, when supplied by the board data. */
+    from?: string;
+    to?: string;
+    appliedOn?: string;
+    note?: string;
+    cert?: {
+        name: string;
+        size: string;
+    } | null;
+    bal?: LeaveBalance;
+}
+export type DaySlot = WorkSlot | WorkSlot[] | LeaveSlot | null;
+export interface EmployeeRemark {
+    author: string;
+    date: string;
+    type: 'note' | 'warning' | 'praise';
+    text: string;
+}
+/** One weekday's availability window, used only for the part-timer "hours they can work"
+ * editor on the Add Employee form — informational HR data, not read by the grid. This board
+ * has no standing weekly rest-day pattern (see cellStateClasses); a day someone is actually
+ * away is booked as dated leave, not derived from this. */
+export interface EmployeeAvailHours {
+    from: string;
+    to: string;
+}
+export interface Employee {
+    id: number;
+    /** Stable backend identity. The numeric id is only a board/view-model id. */
+    sourceId: string;
+    name: string;
+    employmentType: 'FULLTIME' | 'PARTTIME';
+    role: string;
+    initials: string;
+    color: string;
+    weekHours: number;
+    /** Full-time-equivalent percentage, e.g. 100 for a full-timer, 60 for 0.6 FTE. */
+    pct: number;
+    /** Hours per week this person is contracted to, as agreed with them. Per-person rather than
+     * a venue default: ScheduleSettings holds pay rates and employee-hour defaults, and EmployeeProfiles.workingHours
+     * is where the figure is actually stated. Undefined means nobody has agreed one. */
+    contractHours?: number;
+    rate: number;
+    positions: string[];
+    /** Position references that remain on the employee profile but are no longer active in the catalogue. */
+    archivedPositions?: string[];
+    /** One entry per visible day of the horizon; null = day off. */
+    shifts: DaySlot[];
+    /** Dated time-off records are kept beside shifts so an off/leave card remains visible when
+     * a manager adds a shift on the same day. */
+    timeOff?: Array<LeaveSlot | null>;
+    remarks: EmployeeRemark[];
+    section: string;
+    compGroup?: string;
+    mobile?: string;
+    dial?: string;
+    /** Outlets this person may be rostered at. */
+    locations?: string[];
+    payBasis?: 'hourly' | 'monthly';
+    /** The figure as agreed with them, in payBasis's unit — `rate` above is always the
+     * hourly figure derived from this and is what the grid actually costs shifts with. */
+    payAmount?: number;
+    maxHours?: number;
+    /** Shortest shift, in hours, this person will come in for. Asking for less is allowed but
+     * warned about in the shift popover. */
+    minHours?: number;
+    minHoursPerDay?: number;
+    workingHours?: {
+        minHoursPerDay: number | null;
+        maxHoursPerDay: number | null;
+        maxHoursPerWeek: number | null;
+    };
+    overtime?: {
+        maxHoursPerMonth: number | null;
+    };
+    preferences?: string[];
+    seniority?: 'senior' | 'junior' | '';
+    /** Recurring days off (full-timer) or days available (part-timer) — see
+     * EmployeeAvailHours above for why the grid does not read this. */
+    availDays?: boolean[];
+    availHours?: EmployeeAvailHours[];
+    /** POS sign-in code. Optional: rostering, costing and publishing never depend on it. */
+    passcode?: string;
+    /** POS master-user code, when this employee is a master user. */
+    code?: string;
+    masterUser?: boolean;
+}
+export interface Section {
+    id: string;
+    label: string;
+    roles: string[];
+    /** The "Unassigned" bucket — always present, never deletable. */
+    system?: boolean;
+}
+export interface OpenShift {
+    id: number;
+    dayIdx: number;
+    position: string;
+    required: number;
+    filledBy: number | null;
+    sen?: 'junior' | 'senior';
+    empType?: 'full' | 'part';
+    /** Optional custom label for this open shift, shown above the time on its card
+     * (e.g. "Weekend cover") — distinct from the position it asks for. */
+    name?: string;
+    /** Hours this record asks for. Defaults to the active shift template's hours at
+     * creation, but the shift popover lets a manager retime one open shift on its own. */
+    start: string;
+    end: string;
+    breakMins?: number;
+}
+export interface ShiftTemplate {
+    key: string;
+    label: string;
+    start: string;
+    end: string;
+    color: string;
+    active: boolean;
+    breakMins: number;
+}
+/** Coverage requirement for one shift template: position -> [Mon..Sun] headcount. */
+export type CoverageRow = Record<string, number[]>;
+/** What an hour costs, by the kind of day it falls on — the ScheduleSettings document's whole
+ * content. `regular` multiplies ORDINARY hours and `overtime` multiplies hours past the OT
+ * threshold; a NORMAL day has no `regular` because an ordinary hour at ordinary pay is 1×.
+ *
+ * REST_DAY is carried but unread: this board has no standing weekly rest-day pattern to decide
+ * which dates are rest days (see cellStateClasses), so nothing can ask for its rates yet. */
+export interface PayRate {
+    NORMAL: {
+        overtime: number;
+    };
+    REST_DAY: {
+        regular: number;
+        overtime: number;
+    };
+    PUBLIC_HOLIDAY: {
+        regular: number;
+        overtime: number;
+    };
+}
+export interface ScheduleRules {
+    coverage: Record<string, CoverageRow>;
+    openFrom: string;
+    openTo: string;
+    /** Per grid day (0 = Mon) trading windows straight off the outlet's own profile — one or
+     * more `{start, end}` pairs a day (a lunch/dinner split reads as two windows, not one that
+     * spans the gap between them), empty for a structurally closed day. `openFrom`/`openTo`
+     * above stay the widest span across the whole week: the coverage bar, day timeline and shift
+     * forms are still drawn against one axis for the whole board, not a different one per day. */
+    dayHours: Array<{
+        start: string;
+        end: string;
+    }>[];
+    payRate: PayRate;
+    /** Weekly sales forecast (RM) — the stats row's editable input and the figure the
+     * per-day forecast curve distributes across the week. */
+    salesForecast: number;
+    /** Weekday indices (0 = Mon) the venue never opens on. Empty by default — this seed venue
+     * runs every day. Feeds copy-week's and export's "Closed" labeling. */
+    closedWeekdays: number[];
+    /** Labour cost target as a % of sales — Settings page "Labour budget" tab. */
+    labourTarget: number;
+    /** When true, the weekly labour cap is derived from salesForecast * labourTarget instead
+     * of being a standalone figure. */
+    budgetFromSales: boolean;
+    /** Weekly labour cap (RM), editable directly when budgetFromSales is false. */
+    budget: number;
+    /** Monthly OT cap (hours) — Settings page "Overtime" tab. */
+    otCapHours: number | null;
+    workingHours: {
+        minHoursPerDay: number | null;
+        maxHoursPerDay: number | null;
+        maxHoursPerWeek: number | null;
+    };
+    /** Monthly OT budget (RM), advisory only. */
+    otBudget: number;
+    notify: {
+        waConnected: boolean;
+        waNumber: string;
+        waDisplayName: string;
+        defaults: {
+            wa: boolean;
+            push: boolean;
+            email: boolean;
+        };
+    };
+}
+export interface PendingChange {
+    empId: number;
+    employeeKey: string;
+    dayIdx: number;
+    kind: 'add' | 'change' | 'remove';
+    label: string;
+    conflict?: boolean;
+}
+export type NotifyChannel = 'wa' | 'push' | 'email';
+export interface ScheduleVersionSnapshot {
+    id: number;
+    name: string;
+    weekHours: number;
+    shifts: DaySlot[];
+}
+export interface ScheduleVersion {
+    v: number;
+    at: Date;
+    by: string;
+    note: string;
+    changeCount: number;
+    staffAffected: number;
+    snapshot: ScheduleVersionSnapshot[];
+}
+export type ScheduleStatusTone = 'neutral' | 'warn' | 'ok' | 'locked';
+export interface ScheduleStatusInfo {
+    tone: ScheduleStatusTone;
+    label: string;
+    hint: string;
+    allLocked: boolean;
+}
+/** Someone in the business's employee directory who is not yet on THIS outlet's schedule —
+ * they may already be scheduled elsewhere (see `otherOutlets`), or nowhere at all. Picking one
+ * puts a second, independent EmployeeProfiles document against their `employeeId`; it does not
+ * move or copy their profile from wherever else they work. */
+export interface ExistingStaffCandidate {
+    employeeId: string;
+    name: string;
+    /** Other outlets this person already has a POS/HR association with — not necessarily a
+     * scheduling profile there, just enough context to tell two same-named people apart and to
+     * warn against loaning someone who's clearly based elsewhere. */
+    otherOutlets: string[];
+    /** Every outlet the person works at, by name (this one included when the POS lists it). */
+    locations: string[];
+}
+export interface CompGroupMeta {
+    basis: 'Hourly' | 'Monthly';
+    rate: number;
+    note: string;
+}
+/** A manager's note on a DATE, not on a shift — it survives every shift on that date being
+ * deleted, because a day with nothing rostered can still be an event day. The title is what
+ * makes the note visible on the day card; the description shows on hover. */
+export interface ScheduleDayNote {
+    title: string;
+    desc: string;
+}
+/** One named slice of a staffing-demand period: "of the 8 people, 2 on grill". Named rows are
+ * a PART of the period's headcount, never an addition to it — whatever they don't name is the
+ * "any position" remainder, which is derived and never stored. */
+export interface DemandRole {
+    position: string;
+    /** Persisted position identity; the name is only the display label. */
+    positionId?: string;
+    n: number;
+}
+/** A stretch of a day and how many people the floor needs across it. Deliberately not a shift:
+ * it carries no person and no times anybody works, so five staggered shifts can add up to the
+ * five people it asks for at 4pm without any of them being "the" shift for it. */
+export interface DemandPeriod {
+    from: string;
+    to: string;
+    n: number;
+    /** Absent and empty mean the same thing — "anybody" — so only a stated breakdown is kept. */
+    roles?: DemandRole[];
+}
+/** One slice of a day where neither what was asked for nor who is on the floor changes. The
+ * timeline draws one of these per segment and the day's percentage is their weighted sum. */
+export interface CoverageSegment {
+    from: number;
+    to: number;
+    required: number;
+    scheduled: number;
+    /** Heads asked for that nobody present answers — which is not the same as "too few bodies":
+     * eight people none of whom is a cook leaves a 2-grill ask two short with nobody missing. */
+    short: number;
+    over: number;
+    roles: Array<DemandRole & {
+        required: number;
+        got: number;
+        short: number;
+    }>;
+    /** The unnamed remainder of the period's headcount, and how much of it is covered. */
+    anyReq: number;
+    anyGot: number;
+    /** Nothing was asked for in these hours — an absence of a question, not a gap in one. */
+    none: boolean;
+}
+export type DemandApplyMode = 'day' | 'every' | 'weekday' | 'weekdays' | 'custom';
+export interface NoticeBanner {
+    variant: 'holiday' | 'info' | 'warning';
+    dayIdx: number;
+    label: string;
+    detail: string;
+    action?: string;
+}
+/** One Auto-Schedule suggestion: put `empId` on `dayIdx` for the given hours/position.
+ * Phase 2 only ever proposes filling an empty day (an open shift or a coverage gap),
+ * so there is no 'change'/'remove' kind like the mockup's fuller engine. */
+export interface Proposal {
+    id: number;
+    empId: number;
+    dayIdx: number;
+    start: string;
+    end: string;
+    role: string;
+    /** The position backing `role`, when the auto-schedule result named one. `null`/absent means
+     * any position (an unnamed need). */
+    positionId?: string | null;
+    /** Set when this proposal would fill a named OpenShift record. */
+    openId?: number;
+    status: 'pending' | 'rejected';
+    /** The week these belong to: its first day's date. Proposals are day positions, so without
+     * this they would appear on whichever week is showing. */
+    weekKey?: string;
+    /** Why this person, for the card's tooltip. */
+    reason?: string;
+    /** Set when the server already knows applying this row would be refused; it starts rejected. */
+    rejectReason?: string;
+}

package/dist/src/views/team/components/MemberGrantFields.vue.d.ts

@@ -31,9 +31,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     readGrantData: typeof readGrantData;
     isModified: typeof isModified;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "create-pos-role": () => any;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     initialValue: {
         type: PropType<MemberGrantInitialValue | null>;
     };
@@ -46,9 +44,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & Readonly<{
-    "onCreate-pos-role"?: (() => any) | undefined;
-}>, {
+}>> & Readonly<{}>, {
     loading: boolean;
     fallbackName: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/src/views/team/components/PortalConditionForm.vue.d.ts

@@ -17,21 +17,21 @@ type __VLS_Props = {
     title?: string;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    apply: () => any;
     "update-form": (payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any;
+    apply: () => any;
     "update-inherit-mode": (payload: {
         builder: ConditionBuilder;
         mode: "inherit" | "custom";
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onApply?: (() => any) | undefined;
     "onUpdate-form"?: ((payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any) | undefined;
+    onApply?: (() => any) | undefined;
     "onUpdate-inherit-mode"?: ((payload: {
         builder: ConditionBuilder;
         mode: "inherit" | "custom";

package/dist/src/views/team/components/PosAssignmentRows.vue.d.ts

@@ -21,7 +21,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (roles: IFdtoPermissionPosUserRole[]) => any;
-    "create-role": () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: {
         type: PropType<IFdtoPermissionPosUserRole[]>;
@@ -41,6 +40,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((roles: IFdtoPermissionPosUserRole[]) => any) | undefined;
-    "onCreate-role"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/views/team/condition-builders/ConditionBuilderForm.vue.d.ts

@@ -14,17 +14,17 @@ type __VLS_Slots = {} & {
     section?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    apply: () => any;
     "update-form": (payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any;
+    apply: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onApply?: (() => any) | undefined;
     "onUpdate-form"?: ((payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any) | undefined;
+    onApply?: (() => any) | undefined;
 }>, {
     title: string;
     disable: boolean;

package/dist/src/views/team/member/AddMemberForm.vue.d.ts

@@ -65,7 +65,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     providerLabel: import("vue").ComputedRef<string>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update-existing": (existing: IFdtoStaffInviteLookup) => any;
-    "create-pos-role": () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     initialValue: {
         type: PropType<TeamDialogData>;
@@ -88,7 +87,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{
     "onUpdate-existing"?: ((existing: IFdtoStaffInviteLookup) => any) | undefined;
-    "onCreate-pos-role"?: (() => any) | undefined;
 }>, {
     loading: boolean;
     roleErrorMessage: string;

package/dist/src/views/team/member/TeamMemberMasterUser.vue.d.ts

@@ -33,7 +33,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:model-value": (user: IFdtoPermissionPosUser | null | undefined) => any;
-    "create-role": () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: {
         type: PropType<IFdtoPermissionPosUser | null>;
@@ -65,7 +64,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{
     "onUpdate:model-value"?: ((user: IFdtoPermissionPosUser | null | undefined) => any) | undefined;
-    "onCreate-role"?: (() => any) | undefined;
 }>, {
     modelValue: IFdtoPermissionPosUser | null;
     fallbackPasscode: string;