@feedmepos/mf-hrm-portal 2.3.0-dev.3 → 2.3.0-dev.31

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

@@ -22,7 +22,6 @@ type __VLS_Props = {
     filterBar: ScheduleFilterBarApi;
     outlet: ScheduleOutletApi;
     roster: ScheduleRosterApi;
-    loading: boolean;
     error: string | null;
     onSchedStatusClick: () => void;
     onComingSoon: () => void;

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

@@ -4,7 +4,7 @@ import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSche
 import type { ScheduleExportApi } from '../composables/useScheduleExport';
 import type { SchedulePublishApi } from '../composables/useSchedulePublish';
 type __VLS_Props = {
-    kind: 'onboarding' | 'tour' | 'export' | 'publish-share';
+    kind: 'onboarding' | 'tour' | 'auto-schedule' | 'export' | 'publish-share';
     wizard?: ScheduleOnboardingWizardApi;
     tour?: ScheduleTourApi;
     autoSchedule?: ScheduleAutoScheduleApi;

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

@@ -2,6 +2,7 @@ type __VLS_Props = {
     open: boolean;
     title: string;
     message: string;
+    affectedDates?: string[];
     /** `clash-q` gives the message an orange warning-callout background instead of plain text —
      * used by the "might conflict" dialog, kept as an opt-in rather than the default look. */
     messageClass?: string;
@@ -10,6 +11,7 @@ type __VLS_Props = {
      * consequence of pressing the button. Omitted entirely when there's nothing to point to. */
     note?: string;
     confirmLabel?: string;
+    loading?: boolean;
     cancelLabel?: string;
     tone?: 'primary' | 'danger';
     /** The "!" mark is for dialogs guarding something irreversible — a reversible action
@@ -24,9 +26,10 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     onConfirm?: (() => any) | undefined;
 }>, {
     icon: boolean;
+    loading: boolean;
     confirmLabel: string;
-    tone: "primary" | "danger";
     messageClass: string;
     cancelLabel: string;
+    tone: "primary" | "danger";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,21 +1,17 @@
 import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
 import type { ScheduleShiftActionsApi } from '../composables/useScheduleShiftActions';
-import type { ScheduleOpenShiftCardApi } from '../composables/useScheduleOpenShiftCard';
 import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
 import type { ScheduleEmployeeMenuApi } from '../composables/useScheduleEmployeeMenu';
 type __VLS_Props = {
-    kind: 'shift' | 'open-shift' | 'employee';
+    kind: 'shift' | 'employee';
     board?: ScheduleBoardApi;
     actions?: ScheduleShiftActionsApi;
-    openShiftMenu?: ScheduleOpenShiftCardApi;
     popover?: ScheduleShiftPopoverApi;
     employeeMenu?: ScheduleEmployeeMenuApi;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     editShift: (empId: number, dayIdx: number, slotIndex: number) => any;
-    assign: (openId: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onEditShift?: ((empId: number, dayIdx: number, slotIndex: number) => any) | undefined;
-    onAssign?: ((openId: number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -2,11 +2,16 @@ import type { ScheduleDayTimelineApi } from '../composables/useScheduleDayTimeli
 import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
 import type { ScheduleViewMode } from '../composables/useScheduleFilterBar';
 import type { ScheduleAreaDragDropApi } from '../composables/useScheduleAreaDragDrop';
+import type { ScheduleDragDropApi } from '../composables/useScheduleDragDrop';
 type __VLS_Props = {
     timeline: ScheduleDayTimelineApi;
     roster: ScheduleRosterApi;
     mode: ScheduleViewMode;
     dragDrop?: ScheduleAreaDragDropApi;
+    shiftDragDrop?: ScheduleDragDropApi;
+    onDropEmployee?: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPosition?: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPositionCell?: (position: string, event: DragEvent) => void;
 };
 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/ScheduleLoadState.vue.d.ts

@@ -1,5 +1,4 @@
 type __VLS_Props = {
-    loading: boolean;
     error: string | null;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

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

@@ -0,0 +1,6 @@
+import type { ScheduleOnboardingWizardApi } from '../composables/useScheduleOnboardingWizard';
+type __VLS_Props = {
+    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/ScheduleOnboardingSettings.vue.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleOnboardingWizardApi } from '../composables/useScheduleOnboardingWizard';
+type __VLS_Props = {
+    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/SchedulePublishShareArt.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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

@@ -0,0 +1,33 @@
+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). */
+export declare function dateOfProposal(weekKey: string, dayIdx: number): string;
+/** Server proposals → board proposals for the week whose Monday is `weekKey`. A proposal whose
+ * date is not one of `dateKeyOf(0..RANGE_LEN-1)` or whose employee the board does not hold is
+ * 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, status?: FdtoScheduleAutoScheduleApplyReq['status']): FdtoScheduleAutoScheduleApplyReq;
+export interface ClassifiedExplanation {
+    kind: 'reject' | 'ai' | 'plain';
+    text: string;
+}
+/** Sorts one `result.explanations` line into what the Details panel renders it as. The matched
+ * prefix is stripped from `text` in every case — the panel re-adds its own label/marker for
+ * `reject` and `ai`, so the raw wire prefix never doubles up with it. */
+export declare function classifyExplanation(line: string): ClassifiedExplanation;
+/** Whether `error` is a server refusal whose own message is meant for the user: a client error
+ * (0 < status < 500). A network failure (0) or a server error (5xx) is not. */
+export declare function isClientRefusal(error: unknown): error is ApiError;
+/** A client-error refusal shows its own message; a network failure or 5xx shows the generic one. */
+export declare function generateErrorMessage(error: unknown): string;
+/** The result shown when "fill gaps" is off: nothing proposed, one explanation. */
+export declare function fillGapsOffResult(week: {
+    from: string;
+    to: string;
+}, objective: FdtoScheduleAutoScheduleObjective, allowOvertime: boolean): FdtoScheduleAutoScheduleResult;
+/** 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, 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

@@ -0,0 +1,15 @@
+export type RemyDemandScope = {
+    mode: 'day';
+    isoDate: string;
+    label: string;
+} | {
+    mode: 'weekday';
+    weekday: string;
+} | {
+    mode: 'weekdays';
+};
+/** 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-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/useRemyAppStore.d.ts

@@ -0,0 +1,16 @@
+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
+ * instance the host already created. The host portal owns initialisation (with env-specific
+ * backend/license URLs) before any HRM view mounts. HRM must never call `initializeRemyChat`:
+ * it re-initialises the shared panel instance and, without arguments, points it at production. */
+export interface RemyAppStoreApi {
+    store: ReturnType<typeof useAppStore>;
+    activate: (options: RemyActivateOptions) => Promise<void>;
+}
+export declare function useRemyAppStore(): RemyAppStoreApi;

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;