@feedmepos/mf-hrm-portal 2.2.5-dev → 2.2.5-dev.4

package/dist/src/views/scheduling/composables/schedule-board-helpers.d.ts

@@ -0,0 +1,38 @@
+import type { DaySlot, Employee, LeaveSlot, WorkSlot } from '../types';
+import type { FdtoScheduleSaveAssignmentReq } from '@/types/schedule';
+/** dayjs-free local-date key — matches on the browser's local Y/M/D, not UTC, so this stays
+ * correct regardless of timezone. */
+export declare function isoDateKey(d: Date): string;
+export declare function isWorkSlot(slot: DaySlot): slot is WorkSlot;
+export declare function isLeaveSlot(slot: DaySlot): slot is LeaveSlot;
+export declare function workSlotsOf(day: DaySlot): WorkSlot[];
+/** A WorkSlot, in the shape ShiftAssignments actually stores. `pending` is the only status
+ * this board's own writers ever set on a fresh slot (see commitShift's callers) — `ot` is
+ * derived at cost-rail time, never authored, so it has nowhere sensible to map but PUBLISHED. */
+export declare function toAssignmentReq(employeeId: string, date: string, slot: WorkSlot): FdtoScheduleSaveAssignmentReq;
+/** Which coverage-position (a RULES.coverage.full key, e.g. 'grill', 'customer service') a
+ * work slot's `role` counts toward for area-view grouping and cost-by-position breakdowns.
+ * The shift popover's "Position needed" field writes a coverage-position key directly into
+ * `role` for anything authored through it — so a role that's already a coverage key is
+ * used as-is. Seed data instead recorded a station label ('FOH', 'Kitchen', ...), which
+ * ROLE_POSITIONS translates to that station's first/primary position. This can't tell a
+ * Kitchen employee's grill shifts apart from their prep shifts when the seed data only
+ * ever recorded the station — that distinction only exists once a shift is authored (or
+ * re-saved) through the popover, which does record the specific position. */
+export declare function positionKeyOf(role: string): string;
+/** The hours this employee is contracted to in a week — what "18h / 44h" measures against.
+ * Stated per person on their own profile now that ScheduleSettings carries pay rates alone, so
+ * there is no venue-wide full/part pair to fall back to: somebody nobody has agreed hours with
+ * reads 0, which is the truth rather than a default they never signed. */
+export declare function contractCapFor(emp: Employee): number;
+/** Whether `hours` runs past what this person is contracted to.
+ *
+ * A cap of 0 means no hours were ever agreed, which is NOT a contract of zero hours: read
+ * naively, `hours > 0` makes every rostered minute overtime, flags everybody on the cost rail's
+ * over-contract list and makes copy-week refuse every shift. An unknown limit cannot be
+ * exceeded, so it is treated as no limit and the question is answered false. */
+export declare function overContract(emp: Employee, hours: number): boolean;
+export declare function isPartTime(emp: Employee): boolean;
+/** Which weekday (0 = Mon) is today, relative to no particular week — used to seed
+ * focusDayIdx whenever "today" needs a weekday index rather than a date. */
+export declare function todayWeekdayIdx(): number;

package/dist/src/views/scheduling/composables/schedule-day-meta.d.ts

@@ -0,0 +1,29 @@
+import { type Ref } from 'vue';
+import type { Employee, ScheduleDayNote } from '../types';
+/** Everything a manager authors about a DATE rather than about a shift — the note on its
+ * card, whether the venue opens, whether it bills at the holiday rate. Keyed by ISO date
+ * (via the board's `dateKey`), not by weekday index: the mockup's flat single-week horizon
+ * could use the weekday index directly, but the board pages through weeks, and a note put on
+ * this Monday must not reappear on every other Monday. */
+export declare function useScheduleDayMeta(employees: Ref<Employee[]>, dateKey: (dayIdx: number) => string | null, handlers?: {
+    onPersistError?: (message: string) => void;
+}): {
+    dayNote: (dayIdx: number) => ScheduleDayNote | null;
+    setDayNote: (dayIdx: number, title: string, desc: string) => void;
+    clearDayNote: (dayIdx: number) => void;
+    toggleClosed: (dayIdx: number) => {
+        closed: boolean;
+        rostered: number;
+    };
+    isManuallyClosed: (dayIdx: number) => boolean;
+    isStandingClosedWeekday: (dayIdx: number) => boolean;
+    holidayName: (dayIdx: number) => string | null;
+    holidayIsAuto: (dayIdx: number) => boolean;
+    isPublicHoliday: (dayIdx: number) => boolean;
+    holidayRateApplies: (dayIdx: number) => boolean;
+    setHolidayNormal: (dayIdx: number, toNormal: boolean) => void;
+    setPublicHoliday: (dayIdx: number, on: boolean) => void;
+    otRateOn: (dayIdx: number) => number;
+    regularRateOn: (dayIdx: number) => number;
+    isHoliday: (dayIdx: number) => boolean;
+};

package/dist/src/views/scheduling/composables/schedule-employee-profile.d.ts

@@ -0,0 +1,7 @@
+import type { Employee } from '../types';
+/** Adds `positionName` to the employee's own profile — the backend write path a real
+ * "existing employee" record has (see `useScheduleAddEmployee.ts`'s `toEmployeeProfileFields`
+ * for the same shape, built from the add-employee form instead of a live `Employee`).
+ * Fire-and-forget: the local roster already shows the grant, and a failed profile write isn't
+ * worth a second error dialog on top of whatever caller-side save this followed. */
+export declare function grantSkillToEmployee(emp: Employee, positionName: string): void;

package/dist/src/views/scheduling/composables/schedule-shift-time.d.ts

@@ -0,0 +1,14 @@
+export type ScheduleBreakChoice = 0 | 30 | 60 | 90 | 120 | 'custom';
+export interface ScheduleShiftSegment {
+    start: string;
+    end: string;
+}
+/** A break length that doesn't match one of the presets becomes 'custom', carrying its own
+ * minutes/unit back out for the caller to seed its custom-break fields from. */
+export declare function normalizeBreak(mins: number | undefined): {
+    choice: ScheduleBreakChoice;
+    customMins?: number;
+    customUnit?: 'mins' | 'hrs';
+};
+export declare function resolvedBreakMins(choice: ScheduleBreakChoice, customMins: number, customUnit: 'mins' | 'hrs'): number | undefined;
+export declare function segmentHours(seg: ScheduleShiftSegment, breakMins: number): number;

package/dist/src/views/scheduling/composables/schedule-week-cache.d.ts

@@ -0,0 +1,10 @@
+import type { Employee, OpenShift } from '../types';
+export declare const RANGE_LEN = 7;
+export declare function mostRecentMonday(from: Date): Date;
+export declare function weekDates(offset: number): Date[];
+export declare function weeksBetween(a: Date, b: Date): number;
+export interface WeekBucket {
+    employees: Employee[];
+    openShifts: OpenShift[];
+}
+export declare function weekData(offset: number): WeekBucket;

package/dist/src/views/scheduling/composables/useScheduleAddEmployee.d.ts

@@ -0,0 +1,86 @@
+import type { Employee } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import { type ScheduleAddEmployeeMode, type ScheduleAddEmployeeStep } from './schedule-add-employee-form';
+export type { ScheduleAddEmployeeForm, ScheduleAddEmployeeMode, ScheduleAddEmployeeStep, } from './schedule-add-employee-form';
+/** Add-employee wizard: a "how do you want to add them" step, then one detail form covering
+ * identity, locations, pay, scheduling caps, availability, positions and POS access — plus
+ * the "select existing POS staff" side dialog the first step can hand off to. */
+export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
+    open: import("vue").Ref<boolean, boolean>;
+    selectExistingOpen: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleAddEmployeeStep, ScheduleAddEmployeeStep>;
+    mode: import("vue").Ref<ScheduleAddEmployeeMode, ScheduleAddEmployeeMode>;
+    form: {
+        name: string;
+        mobile: string;
+        dial: string;
+        employment: "full" | "part";
+        locations: string[];
+        payBasis: "hourly" | "monthly";
+        payAmount: string;
+        maxHours: string;
+        otAfterDaily: string;
+        maxOtHours: string;
+        availDays: boolean[];
+        availHours: {
+            from: string;
+            to: string;
+        }[];
+        preferences: string;
+        primaryPosition: string;
+        secondaryPositions: string[];
+        seniority: "" | "senior" | "junior";
+        passcode: string[];
+        masterUser: boolean;
+    };
+    sectionId: import("vue").Ref<string, string>;
+    isEditing: import("vue").ComputedRef<boolean>;
+    locOpen: import("vue").Ref<boolean, boolean>;
+    secOpen: import("vue").Ref<boolean, boolean>;
+    secondaryOptions: import("vue").ComputedRef<string[]>;
+    isPart: import("vue").ComputedRef<boolean>;
+    dayLit: (i: number) => boolean;
+    avLabel: import("vue").ComputedRef<"Weekly availability" | "Time off days">;
+    avAllLabel: import("vue").ComputedRef<"Clear all" | "Select all" | "No days off" | "Every day off">;
+    maxHoursPlaceholder: import("vue").ComputedRef<"Hours per week" | "No cap">;
+    otAfterDailyPlaceholder: import("vue").ComputedRef<string>;
+    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
+    effectiveRate: import("vue").ComputedRef<number>;
+    passcodeValue: import("vue").ComputedRef<string>;
+    passcodeOk: import("vue").ComputedRef<boolean>;
+    footerHint: import("vue").ComputedRef<"Pick who — this outlet's own pay, position and hours are still set here." | "One short form. Rest days are set on their profile afterwards.">;
+    primaryRoleLabel: import("vue").ComputedRef<string>;
+    locationsSummary: import("vue").ComputedRef<string>;
+    payLine: import("vue").ComputedRef<string>;
+    nameError: import("vue").ComputedRef<boolean>;
+    passError: import("vue").ComputedRef<boolean>;
+    availabilityError: import("vue").ComputedRef<boolean>;
+    saving: import("vue").Ref<boolean, boolean>;
+    saveError: import("vue").Ref<string | null, string | null>;
+    candidatesLoading: import("vue").Ref<boolean, boolean>;
+    candidatesError: import("vue").Ref<string | null, string | null>;
+    openWizard: (section: string) => void;
+    openEditFor: (emp: Employee) => void;
+    close: () => void;
+    setMode: (m: ScheduleAddEmployeeMode) => void;
+    openSelectExisting: () => void;
+    closeSelectExisting: () => void;
+    pickExisting: (employeeId: string) => void;
+    next: () => void;
+    back: () => void;
+    toggleMulti: (which: "loc" | "sec") => void;
+    toggleLocation: (loc: string) => void;
+    removeLocation: (loc: string) => void;
+    toggleSecondary: (pos: string) => void;
+    removeSecondary: (pos: string) => void;
+    setPrimaryPosition: (pos: string) => void;
+    setPayBasis: (basis: "hourly" | "monthly") => void;
+    toggleAvailDay: (i: number) => void;
+    availAll: () => void;
+    setAvailHour: (i: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (i: number) => void;
+    setPasscodeDigit: (i: number, value: string) => void;
+    generatePasscode: () => void;
+    create: () => Promise<boolean>;
+};
+export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

package/dist/src/views/scheduling/composables/useScheduleAddPick.d.ts

@@ -0,0 +1,66 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export interface ScheduleAddPickState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    left: number;
+    /** Only one of `top`/`bottom` is live at a time, picked by `openAbove` — anchoring from the
+     * bottom when flipped up lets the box grow with its own content (the query input plus
+     * however many pick-list rows there are) instead of a height guessed in JS. */
+    top: number;
+    bottom: number;
+    openAbove: boolean;
+}
+export interface ScheduleAddPickLeaveOption {
+    reason: string;
+    swatch: string;
+}
+export interface ScheduleAddPickSuggestion {
+    start: string;
+    end: string;
+    short: number;
+    label: string;
+    title: string;
+}
+/** The "+ Add" quick-pick popover on an employee's empty cell — ported from the mockup's
+ * openAddShiftPicker()/renderAddPickList(), scoped to what this board actually has: our one
+ * active shift pattern, a fixed leave-reason list, and a demand-gap suggestion, all committed
+ * directly (no clash confirmation dialogs — this board has no such infrastructure yet, and none
+ * of its existing write paths gate on one either). Leave picks write a full-day approved leave
+ * immediately rather than opening a creation form — there's no "book a leave" authoring flow
+ * anywhere in this port yet, only the existing pending-request review modal, which assumes the
+ * leave already exists. The mockup's "On this day" (join an existing open-shift group) section is
+ * left out — it needs split-shift/group-joining machinery this board doesn't model. */
+export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: ScheduleDemandApi, handlers: {
+    onCommitted: (message: string) => void;
+    onOpenFullEditor: (empId: number, dayIdx: number) => void;
+}): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        left: number;
+        top: number;
+        bottom: number;
+        openAbove: boolean;
+    };
+    query: import("vue").Ref<string, string>;
+    parsedRange: import("vue").ComputedRef<{
+        start: string;
+        end: string;
+    } | null>;
+    suggested: import("vue").ComputedRef<ScheduleAddPickSuggestion | null>;
+    filteredPatterns: import("vue").ComputedRef<import("../types").ShiftTemplate[]>;
+    filteredLeaves: import("vue").ComputedRef<ScheduleAddPickLeaveOption[]>;
+    hasResults: import("vue").ComputedRef<boolean>;
+    openFor: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
+    close: () => void;
+    pickSuggested: () => void;
+    pickPattern: (key: string) => void;
+    pickTypedRange: (start: string, end: string) => void;
+    pickLeave: (reason: string) => void;
+    submitQuery: () => void;
+    openBlank: () => void;
+};
+export type ScheduleAddPickApi = ReturnType<typeof useScheduleAddPick>;

package/dist/src/views/scheduling/composables/useScheduleAllShiftsRow.d.ts

@@ -0,0 +1,77 @@
+import type { Employee, OpenShift } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleShiftPart {
+    start: string;
+    end: string;
+}
+/** One shift on the All-shifts row, whichever way it was authored. A split shift is ONE
+ * entry carrying both of its periods — two periods one person works is one shift, and
+ * counting it twice made a day of three split shifts report as six. */
+export interface ScheduleRowEntry {
+    /** Stable across redraws, so the row can be keyed on it. */
+    key: string;
+    kind: 'open' | 'emp';
+    /** The demand record this came from, when it came from one. */
+    open?: OpenShift;
+    /** Whoever holds it, or null while it is still asking for somebody. */
+    who: Employee | null;
+    parts: ScheduleShiftPart[];
+    position: string;
+    /** A shift with a name of its own ("Weekend cover"), distinct from its position. */
+    label?: string;
+    filled: boolean;
+    hours: number;
+}
+export interface ScheduleStackState {
+    open: boolean;
+    dayIdx: number | null;
+    left: number;
+    top: number;
+}
+/** The "Open shifts" row: a pseudo-row above the people holding the shifts nobody is on yet.
+ *
+ * It used to be the "All shifts" row and it used to LEAD this view, carrying every shift on
+ * the day whichever way it was authored. The coverage band has both of those now — and the
+ * band measures something this row could not, because a shift with nobody on it contributes
+ * zero to coverage, so counting untaken records was never an answer to "is this week staffed".
+ *
+ * What is left is the job only this row can do. An unassigned shift has no person, so the
+ * employee rows have nowhere to draw it; the old row would have shown it alongside every
+ * other shift, which is the same cards twice — once here and once on the row of whoever is on
+ * them. So the subject narrows to the shifts still waiting for somebody, and the row renders
+ * only while at least one exists. That makes it a to-do list rather than furniture: it appears
+ * when you author open demand and disappears the moment the last of it is staffed, which is
+ * the completion signal the old row had to paint itself green to fake. */
+export declare function useScheduleAllShiftsRow(board: ScheduleBoardApi): {
+    dayEntries: (dayIdx: number) => ScheduleRowEntry[];
+    dayStack: (dayIdx: number) => {
+        entries: ScheduleRowEntry[];
+        done: number;
+        total: number;
+        hours: number;
+        allOpen: boolean;
+        mixShown: {
+            name: string;
+            n: number;
+        }[];
+        mixRest: number;
+        title: string;
+    };
+    summary: import("vue").ComputedRef<{
+        count: number;
+        meta: string;
+        tip: string;
+    }>;
+    hasPending: import("vue").ComputedRef<boolean>;
+    stack: {
+        open: boolean;
+        dayIdx: number | null;
+        left: number;
+        top: number;
+    };
+    stackEntries: import("vue").ComputedRef<ScheduleRowEntry[]>;
+    openStack: (dayIdx: number, anchor: HTMLElement) => void;
+    closeStack: () => void;
+    whenOf: (e: ScheduleRowEntry) => string;
+};
+export type ScheduleAllShiftsRowApi = ReturnType<typeof useScheduleAllShiftsRow>;

package/dist/src/views/scheduling/composables/useScheduleAreaBoard.d.ts

@@ -0,0 +1,50 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { Employee, WorkSlot } from '../types';
+export interface ScheduleAssignedSlot {
+    emp: Employee;
+    slot: WorkSlot;
+}
+export interface SchedulePositionCellMeta {
+    required: number;
+    filled: number;
+    open: number;
+    short: number;
+}
+/** Shared by the week and day area views, so a position's colour never disagrees between them. */
+export declare function positionSwatchClass(position: string): string;
+/** Whether this employee can be put on `position` — ported from the mockup's qualifiedFor().
+ * Nobody having a named position yet reads as "any station", the same way an unspecialised
+ * new-account roster does in the reference: rostering shouldn't be blocked on the Positions
+ * page being filled in first. */
+export declare function qualifiedFor(emp: Employee, position: string): boolean;
+/** Week-by-area grouping: rows are positions (a RULES.coverage.full key), not employees.
+ * Ported from the mockup's positionRows()/renderPositionBlock() — scoped to this board's single
+ * "Unassigned" section and its existing WorkSlot/OpenShift model, so no split shifts and
+ * no locked/closed-day states (neither exists anywhere in this port yet). */
+export declare function useScheduleAreaBoard(board: ScheduleBoardApi): {
+    positionRows: import("vue").ComputedRef<string[]>;
+    assignedOn: (dayIdx: number, position: string) => ScheduleAssignedSlot[];
+    unfilledOpenShiftsOn: (dayIdx: number, position: string) => {
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    }[];
+    poolFor: (position: string) => Employee[];
+    cellMeta: (dayIdx: number, position: string) => SchedulePositionCellMeta;
+    positionWeekMeta: (position: string) => {
+        required: number;
+        filled: number;
+        open: number;
+        short: number;
+        pool: number;
+    };
+};
+export type ScheduleAreaBoardApi = ReturnType<typeof useScheduleAreaBoard>;

package/dist/src/views/scheduling/composables/useScheduleAreaDragDrop.d.ts

@@ -0,0 +1,18 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+/** Dragging a person from the staff rail onto a position/day cell — ported from the mockup's
+ * dropStaffOnCell(), scoped to this board's model (no "unspecialised, so ask what they can
+ * do" grant flow, no split shifts): dropping fills an existing open shift for that position/day
+ * if there is one, otherwise opens the shift editor pre-filled with this person, day and
+ * position so the manager sets the hours. */
+export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, handlers: {
+    onFillOpenShift: (openId: number, empId: number) => void;
+    onCreateShift: (empId: number, dayIdx: number, position: string) => void;
+    onNotQualified: (empName: string, position: string) => void;
+}): {
+    draggingEmpId: import("vue").Ref<number | null, number | null>;
+    startRailDrag: (empId: number) => void;
+    endRailDrag: () => void;
+    dropOnCell: (dayIdx: number, position: string) => void;
+};
+export type ScheduleAreaDragDropApi = ReturnType<typeof useScheduleAreaDragDrop>;

package/dist/src/views/scheduling/composables/useScheduleAssign.d.ts

@@ -0,0 +1,113 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleClashDetectionApi } from './useScheduleClashDetection';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+/** What this sitting is trying to fill — an on-screen open-shift row (never backed by a
+ * persisted Shift doc; `openShiftId` only ever identifies it within this session) or a raw
+ * demand gap. Either way the assignment created is a plain one-off, same shape as the +Add
+ * popover's — nothing here carries a shift/assignment linkage back to the server. */
+export interface ScheduleAssignTarget {
+    dayIdx: number;
+    position: string;
+    start: string;
+    end: string;
+    breakMins?: number;
+    openShiftId?: number;
+}
+export interface ScheduleAssignState {
+    open: boolean;
+    target: ScheduleAssignTarget | null;
+    /** How many heads this sitting is answering, and how many it has landed so far — the
+     * footer's "N still needed" note. Tracked locally rather than re-derived from
+     * `demand.coverageSegments` on every assign: a fresh assign can reshape segment boundaries
+     * entirely (met/short is a function of ALL current coverage, not just this one target), so a
+     * simple running count is the honest thing to show without re-deriving segment math here. */
+    required: number;
+    scheduled: number;
+}
+/** `free` — no shift that day, the ordinary case. `busy` — has a shift, but this is the
+ * manager's call to override (soft clash, asks first). `leave` — approved leave, a hard block:
+ * inert, not something a second tap should be able to push past. `mine` — already the one
+ * filling THIS open shift; only meaningful when the target has an `openShiftId` (a demand gap
+ * has no single "holder"), and the tile becomes the unassign control instead. */
+export type ScheduleAssignTileState = 'free' | 'busy' | 'leave' | 'mine';
+export interface ScheduleAssignTile {
+    id: number;
+    name: string;
+    initials: string;
+    weekHours: number;
+    cap: number;
+    over: boolean;
+    state: ScheduleAssignTileState;
+    title: string;
+}
+export interface ScheduleAssignGroup {
+    label: string;
+    tiles: ScheduleAssignTile[];
+}
+/** One entry in the day's shift rail — either the thing this sitting was opened to answer (the
+ * ORIGIN, always first), or another shift already on the same day, so a manager can jump to
+ * reassigning it without leaving the panel. Every entry is a `target` the tile grid can be
+ * pointed at via `switchTo`. */
+export interface ScheduleAssignSlot {
+    key: string;
+    position: string;
+    start: string;
+    end: string;
+    chip: string;
+    full: boolean;
+    sub: string;
+    who: string;
+    whoNone: boolean;
+    on: boolean;
+    target: ScheduleAssignTarget;
+    required: number;
+    scheduled: number;
+}
+/** Assign panel — the one modal both the open-shifts row and a demand gap's "Assign employee"
+ * button open, per the reference's own note that they are "the same assign panel". Every pick
+ * lands immediately (through the canonical `commitShift` mutator, so it persists exactly like
+ * any other assignment); a soft clash — the person already has a shift that day — asks first via
+ * the shared clash-confirmation dialog, and approved leave is a hard block the tile itself
+ * refuses rather than asking about. */
+export declare function useScheduleAssign(board: ScheduleBoardApi, demand: ScheduleDemandApi, clash: ScheduleClashDetectionApi): {
+    state: {
+        open: boolean;
+        target: {
+            dayIdx: number;
+            position: string;
+            start: string;
+            end: string;
+            breakMins?: number | undefined;
+            openShiftId?: number | undefined;
+        } | null;
+        required: number;
+        scheduled: number;
+    };
+    search: import("vue").Ref<string, string>;
+    activeOpenShift: import("vue").ComputedRef<{
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    } | null>;
+    title: import("vue").ComputedRef<string>;
+    sub: import("vue").ComputedRef<string>;
+    footLead: import("vue").ComputedRef<string>;
+    footRest: import("vue").ComputedRef<string>;
+    groups: import("vue").ComputedRef<ScheduleAssignGroup[]>;
+    shiftSlots: import("vue").ComputedRef<ScheduleAssignSlot[]>;
+    switchTo: (slot: ScheduleAssignSlot) => void;
+    openFor: (openShiftId: number) => void;
+    openForGap: (dayIdx: number, position: string, start: string, end: string, required: number, scheduled: number, gapFrom: number, gapTo: number) => void;
+    close: () => void;
+    fillOpenShift: (openShiftId: number, empId: number) => void;
+    armAssign: (empId: number) => void;
+};
+export type ScheduleAssignApi = ReturnType<typeof useScheduleAssign>;

package/dist/src/views/scheduling/composables/useScheduleAutoSchedule.d.ts

@@ -0,0 +1,136 @@
+import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleAutoScheduleStep = 'options' | 'summary';
+export interface ScheduleAutoScheduleOptions {
+    fillGaps: boolean;
+    objective: FdtoScheduleAutoScheduleObjective;
+    allowOvertime: boolean;
+}
+/** Backend-powered draft generation and local proposal review. Generation never writes;
+ * accepted proposals use the board's existing assignment persistence path. */
+export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    wizardOpen: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleAutoScheduleStep, ScheduleAutoScheduleStep>;
+    options: {
+        fillGaps: boolean;
+        objective: FdtoScheduleAutoScheduleObjective;
+        allowOvertime: boolean;
+    };
+    generating: import("vue").Ref<boolean, boolean>;
+    generateError: import("vue").Ref<string | null, string | null>;
+    result: import("vue").Ref<{
+        proposals: {
+            employeeId: string;
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string;
+        }[];
+        unfilledCount: number;
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+                message: string;
+            }[];
+            coverage: {
+                position: number;
+                availability: number;
+                wage: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+    } | null, FdtoScheduleAutoScheduleResult | {
+        proposals: {
+            employeeId: string;
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string;
+        }[];
+        unfilledCount: number;
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+                message: string;
+            }[];
+            coverage: {
+                position: number;
+                availability: number;
+                wage: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+    } | null>;
+    gapCount: import("vue").ComputedRef<number>;
+    openWizard: () => void;
+    closeWizard: () => void;
+    next: () => void;
+    back: () => void;
+    generate: () => Promise<void>;
+    reviewMode: import("vue").Ref<boolean, boolean>;
+    proposals: import("vue").Ref<{
+        id: number;
+        empId: number;
+        dayIdx: number;
+        start: string;
+        end: string;
+        role: string;
+        openId?: number | undefined;
+        status: "pending" | "rejected";
+    }[], Proposal[] | {
+        id: number;
+        empId: number;
+        dayIdx: number;
+        start: string;
+        end: string;
+        role: string;
+        openId?: number | undefined;
+        status: "pending" | "rejected";
+    }[]>;
+    unmetCount: import("vue").Ref<number, number>;
+    acceptedCount: import("vue").ComputedRef<number>;
+    rejectedCount: import("vue").ComputedRef<number>;
+    removedCount: import("vue").ComputedRef<number>;
+    changedCount: import("vue").ComputedRef<number>;
+    unqualifiedCount: import("vue").ComputedRef<number>;
+    conflictCount: import("vue").ComputedRef<number>;
+    projectedCost: import("vue").ComputedRef<number | null>;
+    proposalAt: (empId: number, dayIdx: number) => Proposal | undefined;
+    toggleReject: (id: number) => void;
+    rejectAll: () => void;
+    exitReview: () => void;
+    apply: () => number;
+};
+export type ScheduleAutoScheduleApi = ReturnType<typeof useScheduleAutoSchedule>;