@feedmepos/mf-hrm-portal 2.3.0-dev.8 → 2.3.0

package/dist/src/views/scheduling/components/{ScheduleAssignEmployeePopover.vue.d.ts → ScheduleOnboardingSettings.vue.d.ts}

@@ -1,6 +1,6 @@
-import type { useScheduleAssign } from '../composables/useScheduleAssign';
+import type { ScheduleOnboardingWizardApi } from '../composables/useScheduleOnboardingWizard';
 type __VLS_Props = {
-    assign: ReturnType<typeof useScheduleAssign>;
+    wizard: ScheduleOnboardingWizardApi;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/views/scheduling/components/ScheduleSelect.vue.d.ts

@@ -5,6 +5,8 @@
 export interface ScheduleSelectOption {
     value: string;
     label: string;
+    /** Stable identity used when two options can share the same display value. */
+    id?: string;
     disabled?: boolean;
     group?: string;
     /** Second line under the label. Any option carrying one switches the menu to the rich
@@ -22,8 +24,12 @@ declare const _default: import("vue").DefineComponent<{
      * close the menu and emit `update:modelValue`. */
     multiple?: boolean;
     selected?: string[];
+    /** Stable selected identity for single-select menus whose labels may be duplicated. */
+    selectedId?: string;
     /** Closed-control text while a multi-select has nothing picked. */
     placeholder?: string;
+    /** Optional closed-control text for a selected value that is not available in the menu. */
+    selectedLabel?: string;
     disabled?: boolean;
     /** Heading over the menu. Also switches to the rich layout. */
     menuTitle?: string;
@@ -42,8 +48,12 @@ declare const _default: import("vue").DefineComponent<{
      * close the menu and emit `update:modelValue`. */
     multiple?: boolean;
     selected?: string[];
+    /** Stable selected identity for single-select menus whose labels may be duplicated. */
+    selectedId?: string;
     /** Closed-control text while a multi-select has nothing picked. */
     placeholder?: string;
+    /** Optional closed-control text for a selected value that is not available in the menu. */
+    selectedLabel?: string;
     disabled?: boolean;
     /** Heading over the menu. Also switches to the rich layout. */
     menuTitle?: string;

package/dist/src/views/scheduling/components/ScheduleShiftPopover.vue.d.ts

@@ -1,6 +1,6 @@
 import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
 import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
-import type { ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
+import { type ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
 type __VLS_Props = {
     board: ScheduleBoardApi;
     popover: ScheduleShiftPopoverApi;

package/dist/src/views/scheduling/components/ScheduleStaffRows.vue.d.ts

@@ -2,15 +2,11 @@ import type { Proposal } from '../types';
 import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
 import type { ScheduleDragDropApi } from '../composables/useScheduleDragDrop';
 import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
-import type { ScheduleOpenShiftCardApi } from '../composables/useScheduleOpenShiftCard';
-import type { ScheduleAllShiftsRowApi } from '../composables/useScheduleAllShiftsRow';
 import type { ScheduleDemandRowApi } from '../composables/useScheduleDemandRow';
 type __VLS_Props = {
     board: ScheduleBoardApi;
     dragDrop: ScheduleDragDropApi;
     roster: ScheduleRosterApi;
-    openShiftCard: ScheduleOpenShiftCardApi;
-    allShiftsRow: ScheduleAllShiftsRowApi;
     demandRow: ScheduleDemandRowApi;
     proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined;
 };
@@ -23,9 +19,6 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     toggleProposal: (id: number) => any;
     proposalDragStart: (id: number, ev: DragEvent) => any;
     proposalDragEnd: () => any;
-    openAssign: (openId: number) => any;
-    openOpenShiftMenu: (openId: number, anchor: HTMLElement) => any;
-    addOpenShift: (dayIdx: number) => any;
     segEnter: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => any;
     segLeave: () => any;
     segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => any;
@@ -44,9 +37,6 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     onToggleProposal?: ((id: number) => any) | undefined;
     onProposalDragStart?: ((id: number, ev: DragEvent) => any) | undefined;
     onProposalDragEnd?: (() => any) | undefined;
-    onOpenAssign?: ((openId: number) => any) | undefined;
-    onOpenOpenShiftMenu?: ((openId: number, anchor: HTMLElement) => any) | undefined;
-    onAddOpenShift?: ((dayIdx: number) => any) | undefined;
     onSegEnter?: ((dayIdx: number, from: number, to: number, anchor: HTMLElement) => any) | undefined;
     onSegLeave?: (() => any) | undefined;
     onSegClick?: ((dayIdx: number, from: number, to: number, anchor: HTMLElement) => any) | undefined;

package/dist/src/views/scheduling/composables/auto-schedule-mapping.d.ts

@@ -1,4 +1,4 @@
-import type { FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoSchedulePlanner, FdtoScheduleAutoScheduleProposal, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+import type { FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoScheduleProposal, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
 import { ApiError } from '@/api';
 import type { Proposal } from '../types';
 /** ISO date of `dayIdx` in the week starting `weekKey` (YYYY-MM-DD, local arithmetic). */
@@ -8,7 +8,7 @@ export declare function dateOfProposal(weekKey: string, dayIdx: number): string;
  * dropped. Ids come from `nextId` so they stay unique across weeks. */
 export declare function proposalsFromResult(proposals: FdtoScheduleAutoScheduleProposal[], weekKey: string, dateKeyOf: (dayIdx: number) => string | null, nextId: () => number, holds: (empId: number) => boolean): Proposal[];
 /** The apply body for the accepted proposals, each re-dated from its own week and day. */
-export declare function applyRequestOf(proposals: Proposal[], allowOvertime: boolean): FdtoScheduleAutoScheduleApplyReq;
+export declare function applyRequestOf(proposals: Proposal[], allowOvertime: boolean, status?: FdtoScheduleAutoScheduleApplyReq['status']): FdtoScheduleAutoScheduleApplyReq;
 export interface ClassifiedExplanation {
     kind: 'reject' | 'ai' | 'plain';
     text: string;
@@ -30,4 +30,4 @@ export declare function fillGapsOffResult(week: {
 /** The snackbar shown once a run finishes, whether it went to the server or (fill gaps off) was
  * answered locally. `wallMs` is measured client-side around the request — it is what the manager
  * actually waited, not just the server's own `timing.totalMs`. */
-export declare function generateDoneMessage(result: FdtoScheduleAutoScheduleResult, requested: FdtoScheduleAutoSchedulePlanner, wallMs: number): string;
+export declare function generateDoneMessage(result: FdtoScheduleAutoScheduleResult, wallMs: number): string;

package/dist/src/views/scheduling/composables/onboarding-types.d.ts

@@ -23,7 +23,8 @@ export interface TeamRow {
     picked: boolean;
     /** '' means "Any position" — a person with none. */
     position: string;
-    second: string;
+    /** Additional positions this employee also covers. */
+    second: string[];
     employment: TeamEmployment;
     maxHours: string;
     rate: string;

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

@@ -8,6 +8,8 @@ export type RemyDemandScope = {
 } | {
     mode: 'weekdays';
 };
-/** The sentence prefilled into the host Remy panel. Names the outlet the way a manager knows it;
- * Remy resolves it to an id itself (hrm_find_outlet), so no identifier appears in the text. */
+/** The text prefilled into the host Remy panel: one line naming the outlet and day, which the
+ * user continues with their demand. The "attach a roster image or describe it in words" guidance
+ * lives on the sheet's Ask Remy tooltip, not here. Names the outlet the way a manager knows it;
+ * Remy resolves it to an id itself (hrm_find_outlet), so no outlet id appears in the text. */
 export declare function remyDemandPrompt(outletName: string, scope: RemyDemandScope): string;

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

@@ -11,12 +11,12 @@ export interface ScheduleAddEmployeeForm {
     payBasis: 'hourly' | 'monthly';
     payAmount: string;
     maxHours: string;
+    maxHoursPerDay: string;
     minHours: string;
-    /** Overtime is opt-in: off is "no rule", not "zero overtime" — a 0 sitting in the fields
-     * below by default would read as "every hour is overtime", the opposite of unset. */
-    otEnabled: boolean;
-    otAfterDaily: string;
-    maxOtHours: string;
+    workingHoursEnabled: boolean;
+    overtimeEnabled: boolean;
+    /** Blank means no employee override; the outlet overtime setting is inherited. */
+    maxHoursPerMonth: string;
     /** For a part-timer: days they CAN work. For a full-timer: days they're OFF — the
      * mockup inverts the same array's meaning by employment type. */
     availDays: boolean[];
@@ -31,9 +31,13 @@ export interface ScheduleAddEmployeeForm {
     masterCode: string;
     /** Gates the fields below it — someone can be fully scheduled with this off. */
     posAccessEnabled: boolean;
-    /** WHAT the passcode opens the till as, at this outlet — the one this person is being added
-     * to. The outlet itself isn't a choice here: this wizard is already scoped to it. */
-    posRoleId: string;
+    /** WHAT the passcode opens the till as, and WHERE — a row per outlet. Not restricted to the
+     * outlets picked in Work locations above: a floating manager can be rostered at one outlet
+     * and hold POS admin at several others. */
+    posRoles: {
+        outlet: string;
+        roleId: string;
+    }[];
 }
 /** A salaried month, for converting a monthly figure into the hourly one the cost rail
  * actually reads. Ported verbatim from the mockup's MONTH_HOURS. */

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

@@ -6,6 +6,10 @@ export { isoDateKey } from './schedule-calendar';
 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[];
+/** Whether two periods occupy any of the same working time. Endpoints that touch are
+ * back-to-back, not a conflict. Overnight ranges use the shared clock rules. */
+export declare function shiftsOverlap(a: Pick<WorkSlot, 'start' | 'end'>, b: Pick<WorkSlot, 'start' | 'end'>): boolean;
+export declare function overlapsAnotherSlot(slots: WorkSlot[], target: WorkSlot): boolean;
 /** The inverse of `workSlotsOf` — bare slot for one, the array for two or more, so a day
  * that's back down to its last period reads as a normal single shift again rather than a
  * one-element array everything else has to unwrap. */

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

@@ -8,14 +8,12 @@ export declare function useScheduleDayMeta(dateKey: (dayIdx: number) => string |
     onPersistError?: (message: string) => void;
 }): {
     dayNote: (dayIdx: number) => ScheduleDayNote | null;
-    setDayNote: (dayIdx: number, title: string, desc: string) => void;
+    setDayNote: (dayIdx: number, title: string, desc: string, isPublicHoliday?: boolean) => void;
     clearDayNote: (dayIdx: number) => void;
     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;

package/dist/src/views/scheduling/composables/schedule-demand-domain.d.ts

@@ -1,4 +1,4 @@
-import type { DemandPeriod } from '../types';
+import type { DemandPeriod, Employee } from '../types';
 import { format12h as t12, formatShortMinutes as minToShort, fromMinutes as minToHHMM, spanMinutes as spanOf, toMinutes as toMin } from './schedule-time';
 export { minToHHMM, minToShort, spanOf, t12, toMin };
 export declare function rangeText(from: number, to: number): string;
@@ -9,3 +9,15 @@ export interface ScheduleCoverageAxis {
     from: number;
     to: number;
 }
+/** Fills named position rows from the people on, as a maximum matching (Kuhn's augmenting
+ * paths) so a flexible person is moved off one row when another row has nobody else. Rows are
+ * tried in the order given (scarcest first); within a row, main-position holders are offered
+ * first, then secondary holders, then people with no positions. Returns heads filled per row
+ * (same order as `rows`) and the ids spent. */
+export declare function matchSlots(rows: Array<{
+    position: string;
+    required: number;
+}>, on: Employee[], qualified: (e: Employee, position: string) => boolean): {
+    got: number[];
+    spent: Set<number>;
+};

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

@@ -0,0 +1 @@
+export declare function errorMessage(error: unknown, fallback: string): string;

package/dist/src/views/scheduling/composables/schedule-leave-split.d.ts

@@ -0,0 +1,5 @@
+import type { FdtoScheduleCreateTimeOffReq, FdtoScheduleTimeOff } from '@/types/schedule';
+/** The create requests that keep the rest of a multi-day record alive once `date` is carved out
+ * of it. Single-day records leave nothing behind. The contract requires a same-day request to
+ * have matching parts, so a one-day remainder takes the part from its outer edge. */
+export declare function remainderRequests(record: FdtoScheduleTimeOff, date: string): FdtoScheduleCreateTimeOffReq[];

package/dist/src/views/scheduling/composables/schedule-quick-pick.d.ts

@@ -0,0 +1,22 @@
+import type { CoverageSegment, Employee } from '../types';
+import type { ScheduleCoverageAxis } from './schedule-demand-domain';
+export interface QuickPickRules {
+    minHoursPerDay: number | null;
+    maxHoursPerDay: number | null;
+}
+export interface QuickPickCandidate {
+    start: string;
+    end: string;
+    /** Position name, or '' for any position. */
+    role: string;
+    /** Max short among the runs this shift covers. */
+    short: number;
+    label: string;
+    covers: string;
+    title: string;
+}
+/** Up to 3 shifts for one employee on one day, built the way the auto-schedule planner builds
+ * them: one per (short run, position the person can fill), padded to their daily minimum,
+ * capped at their maximum, kept inside their availability window and clear of their existing
+ * shifts. Rest-gap and weekly-cap checks are left to the shift editor's own warnings. */
+export declare function buildQuickPicks(emp: Employee, dayIdx: number, segments: CoverageSegment[], axis: ScheduleCoverageAxis, rules: QuickPickRules, qualifiedFor: (emp: Employee, position: string) => boolean): QuickPickCandidate[];

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

@@ -12,6 +12,9 @@ export declare function timeRangeBreakOf(sl: WorkSlot): {
     startTime: string;
     endTime: string;
 } | null;
+/** The two visible paid periods around a custom clock-window break. Shared by Weekly cards and
+ * Daily timeline bars so the split wording cannot drift between views. */
+export declare function splitTimeLabels(sl: WorkSlot): [string, string] | null;
 /** Same face as `t12`, but never drops the minutes — two ranges stacked on a split card need
  * to line up at a glance, and "10am" next to "10:30am" reads as two different units. */
 export declare function t12Full(hhmm: string): string;

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

@@ -4,4 +4,6 @@ export interface WeekBucket {
     employees: Employee[];
     openShifts: OpenShift[];
 }
-export declare function weekData(offset: number): WeekBucket;
+/** `from` is the date the offset is relative to (the board passes the Monday it anchored on, so a
+ * tab left open past midnight keeps building the week it is showing). */
+export declare function weekData(offset: number, from?: Date): WeekBucket;

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

@@ -2,6 +2,7 @@ import { useAppStore } from '@feedmepos/mf-remy-panel';
 export interface RemyActivateOptions {
     prompt?: string;
     forceNewConversation?: boolean;
+    fullscreen?: boolean;
 }
 /** HRM never bundles or mounts a Remy panel of its own — `@feedmepos/mf-remy-panel` is externalised
  * by the shared vite preset, so inside the host portal this import resolves to the ONE panel

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

@@ -21,10 +21,11 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
         payBasis: "hourly" | "monthly";
         payAmount: string;
         maxHours: string;
+        maxHoursPerDay: string;
         minHours: string;
-        otEnabled: boolean;
-        otAfterDaily: string;
-        maxOtHours: string;
+        workingHoursEnabled: boolean;
+        overtimeEnabled: boolean;
+        maxHoursPerMonth: string;
         availDays: boolean[];
         availHours: {
             from: string;
@@ -38,7 +39,10 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
         masterUser: boolean;
         masterCode: string;
         posAccessEnabled: boolean;
-        posRoleId: string;
+        posRoles: {
+            outlet: string;
+            roleId: string;
+        }[];
     };
     sectionId: import("vue").Ref<string, string>;
     isEditing: import("vue").ComputedRef<boolean>;
@@ -50,16 +54,17 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     dayLit: (index: 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>;
-    toggleOt: () => void;
+    maxHoursPlaceholder: import("vue").ComputedRef<string>;
+    minHoursPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerDayPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerMonthPlaceholder: import("vue").ComputedRef<string>;
+    toggleOvertime: () => void;
     payUnit: import("vue").ComputedRef<"/month" | "/hour">;
     effectiveRate: import("vue").ComputedRef<number>;
     passcodeValue: import("vue").ComputedRef<string>;
     passcodeOk: import("vue").ComputedRef<boolean>;
     currentLocationLabel: import("vue").ComputedRef<string>;
     locationOptions: import("vue").Reactive<string[]>;
-    masterCodeError: import("vue").ComputedRef<boolean>;
     isNewUser: 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>;
@@ -67,13 +72,34 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     payLine: import("vue").ComputedRef<string>;
     nameError: import("vue").ComputedRef<boolean>;
     passError: import("vue").ComputedRef<boolean>;
+    posRolesError: import("vue").ComputedRef<boolean>;
     availabilityError: import("vue").ComputedRef<boolean>;
     saving: import("vue").Ref<boolean, boolean>;
     saveError: import("vue").Ref<string | null, string | null>;
+    deferScheduleWrites: import("vue").Ref<boolean, boolean>;
     candidatesLoading: import("vue").Ref<boolean, boolean>;
     candidatesError: import("vue").Ref<string | null, string | null>;
+    selectingExisting: import("vue").Ref<boolean, boolean>;
+    candidates: import("vue").Ref<{
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[], import("../types").ExistingStaffCandidate[] | {
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[]>;
+    candidatesTotal: import("vue").Ref<number, number>;
+    candidatesPage: import("vue").Ref<number, number>;
+    candidatesPageItemCount: import("vue").Ref<number, number>;
+    candidatesPageSize: number;
+    searchExisting: (search: string) => void;
+    goToExistingPage: (page: number, search: string) => void;
     openWizard: (section: string) => void;
     openEditFor: (emp: Employee) => void;
+    confirmClose: () => void;
     close: () => void;
     setMode: (m: ScheduleAddEmployeeMode) => void;
     openSelectExisting: () => void;
@@ -93,10 +119,19 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     setAvailHour: (index: number, field: "from" | "to", value: string) => void;
     copyAvailHourDown: (index: number) => void;
     setPasscodeDigit: (index: number, value: string) => void;
-    generatePasscode: () => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
     togglePosAccess: () => void;
-    setPosRole: (roleId: string) => void;
-    posRoleOptions: import("vue").ComputedRef<import("../../../types/role").Role[]>;
+    addPosRoleRow: () => void;
+    removePosRoleRow: (index: number) => void;
+    isCurrentOutletRow: (index: number) => boolean;
+    setPosRoleOutlet: (index: number, outlet: string) => void;
+    setPosRoleId: (index: number, roleId: string) => void;
+    posRoleOptionsFor: (outlet: string) => import("../../../types/role").Role[];
+    isPosRoleUsable: (role: import("../../../types/role").Role) => boolean;
+    setMasterUserRoleAccess: (roleIds: string[] | null | undefined) => void;
+    isPosOutletUsable: (outlet: string) => boolean;
+    posRolesHint: import("vue").ComputedRef<"" | "No outlet assigned, so their passcode will not open a till yet." | "The same outlet is listed twice — only the last role on it will apply.">;
     create: () => Promise<boolean>;
 };
 export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -1,5 +1,6 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type QuickPickCandidate } from './schedule-quick-pick';
 import { type ScheduleAnchorRect } from './schedule-popover-position';
 export interface ScheduleAddPickState {
     open: boolean;
@@ -15,15 +16,6 @@ export interface ScheduleAddPickLeaveOption {
     reason: string;
     swatch: string;
 }
-export interface ScheduleAddPickSuggestion {
-    start: string;
-    end: string;
-    short: number;
-    label: string;
-    /** "Covers 16:00–22:00 demand" — the demand this offer answers, shown under the label. */
-    covers: 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
@@ -57,7 +49,7 @@ export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: Sche
         start: string;
         end: string;
     } | null>;
-    suggested: import("vue").ComputedRef<ScheduleAddPickSuggestion | null>;
+    suggestions: import("vue").ComputedRef<QuickPickCandidate[]>;
     filteredPatterns: import("vue").ComputedRef<{
         key: string;
         label: string;
@@ -71,7 +63,7 @@ export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: Sche
     hasResults: import("vue").ComputedRef<boolean>;
     openFor: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
     close: () => void;
-    pickSuggested: () => void;
+    pickSuggested: (index: number) => void;
     pickPattern: (key: string) => void;
     pickTypedRange: (start: string, end: string) => void;
     pickLeave: (reason: string) => void;

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

@@ -37,19 +37,6 @@ export declare function qualifiedFor(emp: Employee, position: string): boolean;
 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) => {

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

@@ -1,14 +1,7 @@
 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;
+/** Dragging a person from the staff rail onto a position/day cell opens a normal assigned shift. */
+export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, handlers: {
     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;

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

@@ -1,4 +1,4 @@
-import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoSchedulePlanner } from '@/types/schedule';
+import type { FdtoScheduleAutoScheduleObjective } from '@/types/schedule';
 import type { Proposal } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
@@ -6,7 +6,6 @@ export type ScheduleAutoScheduleStep = 'options' | 'summary';
 export interface ScheduleAutoScheduleOptions {
     fillGaps: boolean;
     objective: FdtoScheduleAutoScheduleObjective;
-    planner: FdtoScheduleAutoSchedulePlanner;
     allowOvertime: boolean;
     /** Shown as preferences in the dialog but not sent: the generator takes no input for them yet
      * (availability and time off are always respected; patterns and cost ride on the objective). */
@@ -23,25 +22,24 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     options: {
         fillGaps: boolean;
         objective: FdtoScheduleAutoScheduleObjective;
-        planner: FdtoScheduleAutoSchedulePlanner;
         allowOvertime: boolean;
         respectAvailability: boolean;
         followPatterns: boolean;
         costEfficient: boolean;
     };
-    planners: import("vue").Ref<("GREEDY" | "LLM")[], ("GREEDY" | "LLM")[]>;
-    plannerChoice: import("vue").ComputedRef<boolean>;
     generating: import("vue").Ref<boolean, boolean>;
     generateError: import("vue").Ref<string | null, string | null>;
     result: import("vue").Ref<{
         objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
         allowOvertime: boolean;
+        model: string | null;
         proposals: {
+            rejectReason?: string | null | undefined | undefined;
             date: string;
             startTime: string;
             endTime: string;
-            positionId: string | null;
             employeeId: string;
+            positionId: string | null;
             employeeName: string;
             position: string;
             reason: string;
@@ -57,9 +55,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -100,12 +98,14 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     } | null, {
         objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
         allowOvertime: boolean;
+        model: string | null;
         proposals: {
+            rejectReason?: string | null | undefined;
             date: string;
             startTime: string;
             endTime: string;
-            positionId: string | null;
             employeeId: string;
+            positionId: string | null;
             employeeName: string;
             position: string;
             reason: string;
@@ -121,9 +121,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -164,12 +164,14 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     } | {
         objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
         allowOvertime: boolean;
+        model: string | null;
         proposals: {
+            rejectReason?: string | null | undefined | undefined;
             date: string;
             startTime: string;
             endTime: string;
-            positionId: string | null;
             employeeId: string;
+            positionId: string | null;
             employeeName: string;
             position: string;
             reason: string;
@@ -185,9 +187,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -230,12 +232,13 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     hasDemand: import("vue").ComputedRef<boolean>;
     noDemandOpen: import("vue").Ref<boolean, boolean>;
     rangeLabel: import("vue").ComputedRef<string>;
-    openWizard: () => void;
+    openWizard: (fromSetup?: boolean) => void;
     closeWizard: () => void;
     next: () => void;
     back: () => void;
     generate: () => Promise<void>;
     reviewMode: import("vue").ComputedRef<boolean>;
+    hasPendingChanges: import("vue").ComputedRef<boolean>;
     proposals: import("vue").ComputedRef<{
         id: number;
         empId: number;
@@ -248,6 +251,7 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
         status: "pending" | "rejected";
         weekKey?: string | undefined;
         reason?: string | undefined;
+        rejectReason?: string | undefined;
     }[]>;
     weekHasProposals: import("vue").ComputedRef<boolean>;
     unmetCount: import("vue").Ref<number, number>;
@@ -264,7 +268,15 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     toggleReject: (id: number) => void;
     rejectAll: () => void;
     exitReview: () => void;
-    apply: () => Promise<number | null>;
+    completionOpen: import("vue").Ref<boolean, boolean>;
+    completionCount: import("vue").Ref<number, number>;
+    completionPublished: import("vue").Ref<boolean, boolean>;
+    completionFromSetup: import("vue").Ref<boolean, boolean>;
+    closeCompletion: () => void;
+    leaveReviewOpen: import("vue").Ref<boolean, boolean>;
+    confirmLeaveReview: () => void;
+    cancelLeaveReview: () => void;
+    apply: (showCompletion?: boolean, status?: "DRAFT" | "PUBLISHED") => Promise<number | null>;
     applying: import("vue").Ref<boolean, boolean>;
     applyRejections: import("vue").Ref<{
         employeeName: string;