@feedmepos/mf-hrm-portal 2.3.0-dev.9 → 2.3.1-dev.1

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;
@@ -60,7 +58,6 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -101,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;
@@ -125,7 +124,6 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -166,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;
@@ -190,7 +190,6 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -233,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;
@@ -251,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>;
@@ -267,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;

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

@@ -1,21 +1,19 @@
 import type { Employee, OpenShift, PendingChange, ScheduleStatusInfo, ScheduleVersion, ScheduleVersionSnapshot, Section, WorkSlot } from '../types';
 import { RANGE_LEN } from './schedule-week-cache';
-import { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
-export { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf, };
+import { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, overlapsAnotherSlot, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
+export { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, overlapsAnotherSlot, positionKeyOf, workSlotsOf, };
 export { RANGE_LEN };
 export type ScheduleGranularity = 'day' | 'week';
 export declare function useScheduleBoard(handlers?: {
     onPersistError?: (message: string) => void;
 }): {
     dayNote: (dayIdx: number) => import("../types").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;
@@ -112,6 +110,28 @@ export declare function useScheduleBoard(handlers?: {
             updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         }[] | null)[];
+        timeOff?: ({
+            timeOff: "approved" | "pending";
+            requestId?: string | undefined;
+            type?: "OFF_DAY" | "LEAVE" | undefined;
+            leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | null)[] | undefined;
         remarks: {
             author: string;
             date: string;
@@ -144,6 +164,7 @@ export declare function useScheduleBoard(handlers?: {
             to: string;
         }[] | undefined;
         passcode?: string | undefined;
+        code?: string | undefined;
         masterUser?: boolean | undefined;
     }[], Employee[] | {
         id: number;
@@ -237,6 +258,28 @@ export declare function useScheduleBoard(handlers?: {
             updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         }[] | null)[];
+        timeOff?: ({
+            timeOff: "approved" | "pending";
+            requestId?: string | undefined;
+            type?: "OFF_DAY" | "LEAVE" | undefined;
+            leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | null)[] | undefined;
         remarks: {
             author: string;
             date: string;
@@ -269,6 +312,7 @@ export declare function useScheduleBoard(handlers?: {
             to: string;
         }[] | undefined;
         passcode?: string | undefined;
+        code?: string | undefined;
         masterUser?: boolean | undefined;
     }[]>;
     sections: import("vue").Ref<{
@@ -319,12 +363,14 @@ export declare function useScheduleBoard(handlers?: {
         dayIdx: number;
         kind: "add" | "change" | "remove";
         label: string;
+        conflict?: boolean | undefined;
     }[], PendingChange[] | {
         empId: number;
         employeeKey: string;
         dayIdx: number;
         kind: "add" | "change" | "remove";
         label: string;
+        conflict?: boolean | undefined;
     }[]>;
     unpublishedChanges: import("vue").ComputedRef<PendingChange[]>;
     persistPublish: (items: Array<{
@@ -549,12 +595,17 @@ export declare function useScheduleBoard(handlers?: {
     clearEmployeeShifts: (empId: number) => {
         shifts: number;
     };
-    moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number, fromSlotIndex?: number, fromSlotCount?: number) => boolean;
+    moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number, fromSlotIndex?: number, fromSlotCount?: number, targetPosition?: string, allowLocked?: boolean) => boolean;
     swapShifts: (empIdA: number, empIdB: number, dayA: number, dayB?: number, slotIndexA?: number, slotIndexB?: number, slotCountA?: number) => boolean;
-    clearShiftsInRange: () => {
+    swapPositions: (empIdA: number, empIdB: number, dayA: number, dayB?: number, slotIndexA?: number, slotIndexB?: number, slotCountA?: number) => boolean;
+    clearShiftsInRange: (options?: {
+        persist?: boolean;
+        mutate?: boolean;
+    }) => {
         shifts: number;
         open: number;
         leave: number;
+        assignmentIds: string[];
     };
     requiredFor: (dayIdx: number, position: string) => number;
     scheduledFor: (dayIdx: number, position: string) => number;

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

@@ -1,19 +1,12 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleCopySkipReport {
-    leave: number;
-    already: number;
-    hours: number;
-    full: number;
-    closed: number;
-}
 /** The mockup's Copy schedule feature (copyLastWeek/copyThisWeekForward), ported against this
- * board's per-week-offset bucket cache instead of the mockup's absolute 91-day horizon. Split
- * shifts (copyUnitsOf in the mockup) aren't ported — WorkSlot has no splitId concept in this
- * data model, so each slot is copied as its own unit. */
+ * board's per-week-offset bucket cache instead of the mockup's absolute 91-day horizon. */
 export declare function useScheduleCopyWeek(board: ScheduleBoardApi, handlers?: {
     onDemandChanged?: () => void;
+    onConfirmOverwrite?: (message: string, onConfirm: () => void) => void;
 }): {
     copyLastWeek: (mode: "staffed" | "open") => Promise<void>;
     copyThisWeekForward: (mode: "staffed" | "open") => Promise<void>;
+    isCopying: import("vue").Ref<boolean, boolean>;
 };
 export type ScheduleCopyWeekApi = ReturnType<typeof useScheduleCopyWeek>;

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

@@ -27,8 +27,17 @@ export interface ScheduleOtRisk {
     empId: number;
     name: string;
     hours: number;
+    otHours: number;
     contract: number;
 }
+export interface ScheduleMonthlyOtSummary {
+    key: string;
+    label: string;
+    used: number;
+    cap: number | null;
+    progress: number;
+    high: boolean;
+}
 /** The staff rail consumes the same employee identity/load derivation as the area view. */
 export type ScheduleRailRow = ScheduleEmployeeLoad;
 /** Weekly labour cost + monthly OT gauge for the collapsible cost rail, built off one
@@ -41,7 +50,10 @@ export declare function useScheduleCostRail(board: ScheduleBoardApi, proposalAt?
     weeklyCost: import("vue").ComputedRef<number>;
     otHours: import("vue").ComputedRef<number>;
     monthlyOtUsed: import("vue").ComputedRef<number>;
-    monthlyOtCapHours: number;
+    monthlyOtSummaries: import("vue").ComputedRef<ScheduleMonthlyOtSummary[]>;
+    monthlyOtCapHours: import("vue").ComputedRef<number | null>;
+    monthlyOtProgress: import("vue").ComputedRef<number>;
+    monthlyOtHigh: import("vue").ComputedRef<boolean>;
     bySection: import("vue").ComputedRef<ScheduleSectionCost[]>;
     otRisk: import("vue").ComputedRef<ScheduleOtRisk[]>;
 };

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

@@ -33,7 +33,6 @@ export declare function useScheduleDayNote(board: ScheduleBoardApi, opts?: Sched
     savedNote: import("vue").ComputedRef<import("../types").ScheduleDayNote | null>;
     hasSaved: import("vue").ComputedRef<boolean>;
     whenLabel: import("vue").ComputedRef<string>;
-    isAuto: import("vue").ComputedRef<boolean>;
     rateApplies: import("vue").ComputedRef<boolean>;
     holidayHint: import("vue").ComputedRef<string>;
     openFor: (dayIdx: number, anchor: HTMLElement) => void;

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

@@ -2,14 +2,19 @@ import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleRosterApi } from './useScheduleRoster';
 import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
 declare function minToHHMM(m: number): string;
 export interface ScheduleTimelineBar {
     key: string;
+    start: number;
+    end: number;
     left: number;
     width: number;
     cls: string;
     label: string;
+    labels?: string[];
     sub?: string;
+    conflict?: boolean;
     title: string;
     brk?: {
         left: number;
@@ -17,6 +22,8 @@ export interface ScheduleTimelineBar {
     };
     laneTop?: number;
     laneHeight?: number;
+    employeeId?: number;
+    slotIndex?: number;
     onClick?: () => void;
 }
 export interface ScheduleTimelineRow {
@@ -27,6 +34,7 @@ export interface ScheduleTimelineRow {
     avatarInitials?: string;
     avatarColor?: string;
     employeeId?: number;
+    employeeLoad?: ScheduleEmployeeLoad;
     roleLabel?: string;
     hoursLabel?: string;
     hoursPct?: number;
@@ -34,9 +42,14 @@ export interface ScheduleTimelineRow {
     name: string;
     sub: string;
     bars: ScheduleTimelineBar[];
+    pastDay?: boolean;
+    lockedDay?: boolean;
+    closedDay?: boolean;
+    availabilityDay?: boolean;
+    availabilityLabel?: string;
     minHeight?: number;
     emptyText?: string;
-    onTrackClick?: () => void;
+    onTrackClick?: (anchor: HTMLElement) => void;
 }
 export interface ScheduleHourCell {
     m: number;
@@ -48,7 +61,8 @@ export interface ScheduleHourCell {
     n: number;
 }
 export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, demand: ScheduleDemandApi, handlers: {
-    onAddShift: (empId: number, dayIdx: number) => void;
+    onAddShift: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
+    onAddPositionShift: (dayIdx: number, position: string, anchor: HTMLElement) => void;
     onEditShift: (empId: number, dayIdx: number) => void;
     onEditLeave: (empId: number, dayIdx: number) => void;
     onOpenDemand: (dayIdx: number) => void;

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

@@ -66,6 +66,13 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     }[]>;
     toggleCustomDay: (i: number) => void;
     applyNote: import("vue").ComputedRef<string>;
+    replaceConfirmOpen: import("vue").ComputedRef<boolean>;
+    replaceConfirmTitle: import("vue").ComputedRef<string>;
+    replaceConfirmActionLabel: import("vue").ComputedRef<string>;
+    replaceConfirmMessage: import("vue").ComputedRef<string>;
+    replaceConfirmDates: import("vue").ComputedRef<string[]>;
+    confirmReplace: () => Promise<void>;
+    cancelReplace: () => void;
     overlapWarning: import("vue").ComputedRef<string>;
     whenLabel: import("vue").ComputedRef<string>;
     openFor: (idx: number) => void;
@@ -96,14 +103,14 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         scheduled: number;
         varies: boolean;
         pct: number;
-        tone: "short" | "part" | "met" | "over";
+        tone: "short" | "part" | "over" | "met";
         note: string;
     }[]>;
     coverageTotal: import("vue").ComputedRef<{
         required: number;
         scheduled: number;
         pct: number;
-        tone: "short" | "part" | "met" | "over";
+        tone: "short" | "part" | "over" | "met";
         note: string;
     }>;
     saving: import("vue").Ref<boolean, boolean>;

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

@@ -50,5 +50,6 @@ export declare function useScheduleDragDrop(board: ScheduleBoardApi): {
     setDragHover: (empId: number, dayIdx: number, onCard: boolean, slotIndex: number | null) => void;
     clearDragHover: (empId: number, dayIdx: number) => void;
     dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
+    dropOnPosition: (targetDayIdx: number, targetPosition: string, allowLocked?: boolean) => void;
 };
 export type ScheduleDragDropApi = ReturnType<typeof useScheduleDragDrop>;

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

@@ -1,10 +1,14 @@
+import { type ComputedRef } from 'vue';
 import type { Role } from '@/types/role';
-import { type ScheduleAddEmployeeForm } from './schedule-add-employee-form';
-export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm): {
-    passcodeValue: import("vue").ComputedRef<string>;
-    passcodeOk: import("vue").ComputedRef<boolean>;
+import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm, options?: {
+    excludePosUserId?: ComputedRef<string | undefined>;
+}): {
+    passcodeValue: ComputedRef<string>;
+    passcodeOk: ComputedRef<boolean>;
     setPasscodeDigit: (index: number, value: string) => void;
-    generatePasscode: () => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
     togglePosAccess: () => void;
     addPosRoleRow: () => void;
     removePosRoleRow: (index: number) => void;
@@ -12,5 +16,9 @@ export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm)
     setPosRoleOutlet: (index: number, outlet: string) => void;
     setPosRoleId: (index: number, roleId: string) => void;
     posRoleOptionsFor: (outlet: string) => Role[];
-    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.">;
+    isPosRoleUsable: (role: Role) => boolean;
+    setMasterUserRoleAccess: (roleIds: string[] | null | undefined) => void;
+    isPosOutletUsable: (outlet: string) => boolean;
+    setMasterUserRestaurantAccess: (restaurantIds: string[] | null | undefined) => void;
+    posRolesHint: ComputedRef<string>;
 };

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

@@ -2,8 +2,8 @@ import { type ComputedRef } from 'vue';
 import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
 export declare function useScheduleEmployeeAvailability(form: ScheduleAddEmployeeForm, isPart: ComputedRef<boolean>): {
     dayLit: (index: number) => boolean;
-    avLabel: ComputedRef<"Weekly availability" | "Time off days">;
-    avAllLabel: ComputedRef<"Clear all" | "Select all" | "No days off" | "Every day off">;
+    avLabel: ComputedRef<string>;
+    avAllLabel: ComputedRef<string>;
     maxHoursPlaceholder: ComputedRef<string>;
     ensureAvailHours: (index: number) => void;
     toggleAvailDay: (index: number) => void;

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

@@ -1,5 +1,7 @@
 import { type ComputedRef } from 'vue';
+import type { IFdtoPosUserSummary } from '@/types/employee';
 import type { ScheduleAddEmployeeForm, ScheduleAddEmployeeStep } from './schedule-add-employee-form';
+import type { ExistingStaffCandidate } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 interface UseScheduleEmployeeCandidatesOptions {
     board: ScheduleBoardApi;
@@ -11,16 +13,36 @@ interface UseScheduleEmployeeCandidatesOptions {
     open: {
         value: boolean;
     };
-    onPicked: (employeeId: string) => void;
-    onPrefillPasscode: (employeeId: string) => void;
-    onPrefillPosRoles: (employeeId: string) => void;
+    onPicked: (employeeId: string, employee?: IFdtoPosUserSummary) => void;
+    onPrefillPasscode: (employeeId: string, employee?: IFdtoPosUserSummary) => void | Promise<void>;
+    onPrefillPosRoles: (employeeId: string, employee?: IFdtoPosUserSummary) => void | Promise<void>;
+    onPrefillPosRoleAccess: (roleIds: string[] | null | undefined) => void;
+    onPrefillPosRestaurantAccess: (restaurantIds: string[] | null | undefined) => void;
 }
 /** Directory lookup and profile prefill for the existing-employee path of the add wizard. */
 export declare function useScheduleEmployeeCandidates(options: UseScheduleEmployeeCandidatesOptions): {
     selectExistingOpen: import("vue").Ref<boolean, boolean>;
+    candidates: import("vue").Ref<{
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[], 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;
     candidatesLoading: import("vue").Ref<boolean, boolean>;
     candidatesError: import("vue").Ref<string | null, string | null>;
-    openSelectExisting: () => void;
+    selectingExisting: import("vue").Ref<boolean, boolean>;
+    openSelectExisting: (search?: string) => void;
+    searchExisting: (search: string) => void;
+    goToExistingPage: (page: number, search: string) => void;
     closeSelectExisting: () => void;
     pickExisting: (employeeId: string) => Promise<void>;
 };

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

@@ -1,7 +1,7 @@
 import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
 export declare function useScheduleEmployeeCompensation(form: ScheduleAddEmployeeForm): {
     setPayBasis: (basis: "hourly" | "monthly") => void;
-    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
+    payUnit: import("vue").ComputedRef<string>;
     payAmountNumber: import("vue").ComputedRef<number>;
     effectiveRate: import("vue").ComputedRef<number>;
 };

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

@@ -1,9 +1,11 @@
 import type { ComputedRef, Ref } from 'vue';
+import type { IFdtoPosUserSummary } from '@/types/employee';
 import { type ScheduleAddEmployeeForm } from './schedule-add-employee-form';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 interface UseScheduleEmployeePersistenceOptions {
     form: ScheduleAddEmployeeForm;
     pickedEmployeeId: Ref<string | null>;
+    selectedBusinessEmployee: Ref<IFdtoPosUserSummary | null>;
     payAmountNumber: ComputedRef<number>;
     saving: Ref<boolean>;
     saveError: Ref<string | null>;
@@ -18,6 +20,7 @@ interface UseScheduleEmployeePersistenceOptions {
     }[]>;
     effectiveRate: ComputedRef<number>;
     passcodeValue: ComputedRef<string>;
+    deferScheduleWrites: Ref<boolean>;
     notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
 }
 /** Persistence for an existing business employee being added to this schedule. */

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

@@ -4,7 +4,6 @@ interface UseScheduleEmployeeValidationOptions {
     form: ScheduleAddEmployeeForm;
     submitAttempted: Ref<boolean>;
     passcodeOk: ComputedRef<boolean>;
-    isNewUser: ComputedRef<boolean>;
 }
 /** Validation guards for the add/edit employee form. Keeping them together makes create and
  * the field-level error indicators consume the same rules. */
@@ -15,6 +14,5 @@ export declare function useScheduleEmployeeValidation(options: UseScheduleEmploy
     posRolesError: ComputedRef<boolean>;
     availabilityOk: ComputedRef<boolean>;
     availabilityError: ComputedRef<boolean>;
-    masterCodeError: ComputedRef<boolean>;
 };
 export {};

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

@@ -26,6 +26,7 @@ export declare function useScheduleExport(board: ScheduleBoardApi): {
     printNow: () => void;
     jpgPreviewOpen: import("vue").Ref<boolean, boolean>;
     jpgPreviewUrl: import("vue").Ref<string | null, string | null>;
+    jpgPreviewError: import("vue").Ref<string | null, string | null>;
     jpgPreviewWidth: import("vue").Ref<number, number>;
     jpgPreviewHeight: import("vue").Ref<number, number>;
     jpgFilename: import("vue").Ref<string, string>;

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

@@ -1,10 +1,14 @@
 import type { LeaveSlot } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 export type TimeOffSelection = 'OFF_DAY' | 'ANNUAL' | 'MEDICAL' | 'EMERGENCY' | 'UNPAID';
+/** `label` is the English record label (kept on `LeaveSlot.reason`, which other code matches on);
+ * `labelKey` is what the UI shows. */
 export declare const TIME_OFF_OPTIONS: Array<{
     value: TimeOffSelection;
     label: string;
+    labelKey: string;
 }>;
+export { timeOffLabelKey } from './schedule-leave-split';
 export type ScheduleLeaveMode = 'all' | 'am' | 'pm';
 export interface ScheduleLeaveState {
     open: boolean;
@@ -15,10 +19,13 @@ export interface ScheduleLeaveState {
     selection: TimeOffSelection;
     mode: ScheduleLeaveMode;
 }
+interface ScheduleLeaveOptions {
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}
 /** The leave editor — V6.2's "Book leave" dialog: a reason, how much of the day it covers, and
  * what that does to the person's availability. Opened from the add popup's Off day / Leave rows
  * (booking) and from an existing leave card (editing, or approving a pending request). */
-export declare function useScheduleLeave(board: ScheduleBoardApi): {
+export declare function useScheduleLeave(board: ScheduleBoardApi, leaveOptions?: ScheduleLeaveOptions): {
     state: {
         open: boolean;
         empId: number | null;
@@ -29,16 +36,10 @@ export declare function useScheduleLeave(board: ScheduleBoardApi): {
     };
     employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
     activeSlot: import("vue").ComputedRef<LeaveSlot | null>;
-    options: import("vue").ComputedRef<({
-        readonly mode: "all";
-        readonly name: "Full day";
-    } | {
-        readonly mode: "am";
-        readonly name: "Half day AM";
-    } | {
-        readonly mode: "pm";
-        readonly name: "Half day PM";
-    })[]>;
+    options: import("vue").ComputedRef<{
+        mode: "all" | "am" | "pm";
+        name: string;
+    }[]>;
     span: import("vue").ComputedRef<{
         from: string;
         to: string;
@@ -48,7 +49,7 @@ export declare function useScheduleLeave(board: ScheduleBoardApi): {
     selectionLabel: import("vue").ComputedRef<string>;
     dayLabel: import("vue").ComputedRef<string>;
     hoursText: import("vue").ComputedRef<string>;
-    coverText: import("vue").ComputedRef<"Full day" | "Half day AM" | "Half day PM">;
+    coverText: import("vue").ComputedRef<string>;
     openFor: (empId: number, dayIdx: number, reason?: string | null) => void;
     close: () => void;
     save: () => Promise<void>;

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

@@ -1,7 +1,7 @@
 import { type Ref } from 'vue';
 import type { ScheduleOnboardingDayHours, ScheduleOnboardingRange } from './onboarding-types';
 import type { SchedulePositionsApi } from './useSchedulePositions';
-export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>): {
+export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>, isPastDay?: (dayIdx: number) => boolean): {
     demand: import("vue").Reactive<ScheduleOnboardingRange[][]>;
     dmDay: Ref<number, number>;
     staffingSaving: Ref<boolean, boolean>;