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

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

@@ -1,7 +1,7 @@
 import type { Employee, OpenShift, PendingChange, ScheduleStatusInfo, ScheduleVersion, ScheduleVersionSnapshot, Section, WorkSlot } from '../types';
 import { RANGE_LEN } from './schedule-week-cache';
-import { contractCapFor, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
-export { contractCapFor, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf, };
+import { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
+export { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf, };
 export { RANGE_LEN };
 export type ScheduleGranularity = 'day' | 'week';
 export declare function useScheduleBoard(handlers?: {
@@ -10,11 +10,6 @@ export declare function useScheduleBoard(handlers?: {
     dayNote: (dayIdx: number) => import("../types").ScheduleDayNote | null;
     setDayNote: (dayIdx: number, title: string, desc: string) => void;
     clearDayNote: (dayIdx: number) => void;
-    toggleClosed: (dayIdx: number) => {
-        closed: boolean;
-        rostered: number;
-    };
-    isManuallyClosed: (dayIdx: number) => boolean;
     isStandingClosedWeekday: (dayIdx: number) => boolean;
     holidayName: (dayIdx: number) => string | null;
     holidayIsAuto: (dayIdx: number) => boolean;
@@ -28,6 +23,7 @@ export declare function useScheduleBoard(handlers?: {
     employees: import("vue").Ref<{
         id: number;
         name: string;
+        employmentType: "FULLTIME" | "PARTTIME";
         role: string;
         initials: string;
         color: string;
@@ -50,9 +46,23 @@ export declare function useScheduleBoard(handlers?: {
             conflictReason?: string | undefined;
             openId?: number | undefined;
             breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
             assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
         } | {
             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;
@@ -83,7 +93,18 @@ export declare function useScheduleBoard(handlers?: {
             conflictReason?: string | undefined;
             openId?: number | undefined;
             breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
             assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
         }[] | null)[];
         remarks: {
             author: string;
@@ -114,6 +135,7 @@ export declare function useScheduleBoard(handlers?: {
     }[], Employee[] | {
         id: number;
         name: string;
+        employmentType: "FULLTIME" | "PARTTIME";
         role: string;
         initials: string;
         color: string;
@@ -136,9 +158,23 @@ export declare function useScheduleBoard(handlers?: {
             conflictReason?: string | undefined;
             openId?: number | undefined;
             breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
             assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
         } | {
             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;
@@ -169,7 +205,18 @@ export declare function useScheduleBoard(handlers?: {
             conflictReason?: string | undefined;
             openId?: number | undefined;
             breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
             assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
         }[] | null)[];
         remarks: {
             author: string;
@@ -284,9 +331,23 @@ export declare function useScheduleBoard(handlers?: {
                 conflictReason?: string | undefined;
                 openId?: number | undefined;
                 breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
                 assignmentId?: string | undefined;
+                splitGroupId?: string | undefined;
             } | {
                 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;
@@ -317,7 +378,18 @@ export declare function useScheduleBoard(handlers?: {
                 conflictReason?: string | undefined;
                 openId?: number | undefined;
                 breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
                 assignmentId?: string | undefined;
+                splitGroupId?: string | undefined;
             }[] | null)[];
         }[];
     }[], ScheduleVersion[] | {
@@ -345,9 +417,23 @@ export declare function useScheduleBoard(handlers?: {
                 conflictReason?: string | undefined;
                 openId?: number | undefined;
                 breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
                 assignmentId?: string | undefined;
+                splitGroupId?: string | undefined;
             } | {
                 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;
@@ -378,7 +464,18 @@ export declare function useScheduleBoard(handlers?: {
                 conflictReason?: string | undefined;
                 openId?: number | undefined;
                 breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
                 assignmentId?: string | undefined;
+                splitGroupId?: string | undefined;
             }[] | null)[];
         }[];
     }[]>;
@@ -407,12 +504,12 @@ export declare function useScheduleBoard(handlers?: {
     sectionCost: (sectionId: string, members?: Employee[]) => number;
     totalWeeklyCost: import("vue").ComputedRef<number>;
     employeeById: (id: number) => Employee | undefined;
-    commitShift: (empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[]) => void;
-    commitShiftAt: (offset: number, empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[]) => void;
-    removeShift: (empId: number, dayIdx: number) => void;
-    removeShiftAt: (offset: number, empId: number, dayIdx: number) => void;
-    moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number) => boolean;
-    swapShifts: (empIdA: number, empIdB: number, dayIdx: number) => boolean;
+    commitShift: (empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[], replaceIndex?: number, replaceCount?: number) => void;
+    commitShiftAt: (offset: number, empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[], replaceIndex?: number, replaceCount?: number) => void;
+    removeShift: (empId: number, dayIdx: number, slotIndex?: number, count?: number) => void;
+    removeShiftAt: (offset: number, empId: number, dayIdx: number, slotIndex?: number, count?: number) => void;
+    moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number, fromSlotIndex?: number, fromSlotCount?: number) => boolean;
+    swapShifts: (empIdA: number, empIdB: number, dayA: number, dayB?: number, slotIndexA?: number, slotIndexB?: number, slotCountA?: number) => boolean;
     clearShiftsInRange: () => {
         shifts: number;
         open: number;

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

@@ -1,6 +1,11 @@
 export interface ScheduleClashState {
     open: boolean;
     message: string;
+    /** Per-call overrides, falling back to the "might conflict" wording every call used before
+     * these existed — only the closed-day confirmation (see SchedulePage's onAddShift/
+     * onOpenDemandSheet) needs its own title and button label so far. */
+    title: string | null;
+    confirmLabel: string | null;
     onConfirm: (() => void) | null;
 }
 /** Generic Yes/No conflict-confirmation primitive — the mockup's `askClash`/clashModal,
@@ -9,9 +14,14 @@ export declare function useScheduleClashDetection(): {
     state: {
         open: boolean;
         message: string;
+        title: string | null;
+        confirmLabel: string | null;
         onConfirm: (() => void) | null;
     };
-    ask: (message: string, onConfirm: () => void) => void;
+    ask: (message: string, onConfirm: () => void, opts?: {
+        title?: string;
+        confirmLabel?: string;
+    }) => void;
     confirm: () => void;
     close: () => void;
 };

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

@@ -0,0 +1,19 @@
+import type { ScheduleOutletApi } from './useScheduleOutlet';
+/** "Clone setup to…" on the General page. Copies this outlet's *saved* pay rates — `RULES`,
+ * not the page's draft — to one or more other outlets the manager ticks. Scoped to pay rates
+ * because that is the only outlet-scoped setting this page persists; the mockup's broader
+ * "rules, shifts, coverage and positions" clone lives on pages this one doesn't own. */
+export declare function useScheduleCloneOutletModal(outlet: ScheduleOutletApi): {
+    open: import("vue").Ref<boolean, boolean>;
+    query: import("vue").Ref<string, string>;
+    selected: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    saving: import("vue").Ref<boolean, boolean>;
+    done: import("vue").Ref<number | null, number | null>;
+    sourceLabel: import("vue").ComputedRef<string>;
+    targets: import("vue").ComputedRef<import("../components/ScheduleSelect.vue").ScheduleSelectOption[]>;
+    openModal: () => void;
+    close: () => void;
+    toggle: (id: string) => void;
+    confirm: () => Promise<void>;
+};
+export type ScheduleCloneOutletModalApi = ReturnType<typeof useScheduleCloneOutletModal>;

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

@@ -0,0 +1,80 @@
+export interface CoachTipData {
+    title: string;
+    body: string;
+    count?: string;
+    nextLabel?: string;
+    skipLabel?: string;
+    next?: () => void;
+    skip?: () => void;
+}
+type CoachArrowSide = 'top' | 'bottom' | 'left' | 'right';
+/** A spotlight-and-tooltip overlay that frames one live element at a time — the engine behind
+ * the guided tour. Ported from V6.2's `coach*` functions: same 4-panel mask, same below /
+ * above / left / right tip placement with viewport clamping, same arrow-follows-target-center
+ * math. Deliberately has no Back button and no "click to advance" wiring — every tour step
+ * here always supplies `next`, so the Next button is the one way on. */
+export declare function useScheduleCoach(): {
+    open: import("vue").Ref<boolean, boolean>;
+    placing: import("vue").Ref<boolean, boolean>;
+    tip: import("vue").Ref<{
+        title: string;
+        body: string;
+        count?: string | undefined;
+        nextLabel?: string | undefined;
+        skipLabel?: string | undefined;
+        next?: (() => void) | undefined;
+        skip?: (() => void) | undefined;
+    } | null, CoachTipData | {
+        title: string;
+        body: string;
+        count?: string | undefined;
+        nextLabel?: string | undefined;
+        skipLabel?: string | undefined;
+        next?: (() => void) | undefined;
+        skip?: (() => void) | undefined;
+    } | null>;
+    maskT: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    maskB: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    maskL: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    maskR: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    spot: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    tipPos: {
+        left: number;
+        top: number;
+    };
+    arrow: {
+        side: CoachArrowSide;
+        offset: number;
+    };
+    start: (el: HTMLElement, data: CoachTipData, onMiss?: () => void) => void;
+    end: () => void;
+    next: () => void;
+    skip: () => void;
+};
+export type ScheduleCoachApi = ReturnType<typeof useScheduleCoach>;
+export {};

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

@@ -33,14 +33,11 @@ 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>;
-    isClosed: import("vue").ComputedRef<boolean>;
     isAuto: import("vue").ComputedRef<boolean>;
     rateApplies: import("vue").ComputedRef<boolean>;
-    closedHint: import("vue").ComputedRef<"Nothing is required or rostered on this date." | "The venue does not open — this date only.">;
     holidayHint: import("vue").ComputedRef<string>;
     openFor: (dayIdx: number, anchor: HTMLElement) => void;
     close: () => void;
-    toggleClosed: () => void;
     toggleHoliday: () => void;
     save: () => void;
     remove: () => void;

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

@@ -1,6 +1,7 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleRosterApi } from './useScheduleRoster';
 import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
 declare function minToHHMM(m: number): string;
 export interface ScheduleTimelineBar {
     key: string;
@@ -25,6 +26,11 @@ export interface ScheduleTimelineRow {
     swatchClass?: string;
     avatarInitials?: string;
     avatarColor?: string;
+    employeeId?: number;
+    roleLabel?: string;
+    hoursLabel?: string;
+    hoursPct?: number;
+    onMenu?: (anchor: HTMLElement) => void;
     name: string;
     sub: string;
     bars: ScheduleTimelineBar[];
@@ -41,12 +47,15 @@ export interface ScheduleHourCell {
     title: string;
     n: number;
 }
-export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, handlers: {
+export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, demand: ScheduleDemandApi, handlers: {
     onAddShift: (empId: number, dayIdx: number) => void;
     onEditShift: (empId: number, dayIdx: number) => void;
     onEditLeave: (empId: number, dayIdx: number) => void;
     onOpenAssign: (openId: number) => void;
     onAddAreaShift: (dayIdx: number, position: string) => void;
+    onOpenDemand: (dayIdx: number) => void;
+    onOpenEmployeeMenu: (empId: number, anchor: HTMLElement) => void;
+    onDemandSegment: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
 }): {
     dayIdx: import("vue").ComputedRef<number>;
     axis: import("vue").ComputedRef<{
@@ -62,6 +71,20 @@ export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster:
     openShiftsRow: import("vue").ComputedRef<ScheduleTimelineRow | null>;
     employeeRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
     positionTimelineRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
+    demandRow: import("vue").ComputedRef<{
+        blank: boolean;
+        segments: {
+            key: string;
+            from: number;
+            to: number;
+            left: number;
+            width: number;
+            cls: string;
+        }[];
+        title: string;
+    }>;
+    openDemand: () => void;
+    openDemandSegment: (from: number, to: number, anchor: HTMLElement) => void;
     footer: import("vue").ComputedRef<{
         cells: ScheduleHourCell[];
         staffCount: number;

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

@@ -12,8 +12,10 @@ export interface ScheduleDemandSeg {
 }
 export interface ScheduleDemandCell {
     dayIdx: number;
-    closed: boolean;
-    /** No demand stated on this day — the cell carries its own "+ Set demand" instead. */
+    /** No demand stated on this day — the cell carries its own "+ Set demand" instead. Whether
+     * the day is closed is a separate, purely visual fact read off cellStateClasses by the
+     * template — closing a day is informational for staffing, not a lock, so it doesn't change
+     * what this cell has to show. */
     blank: boolean;
     pct: number;
     tone: '' | 'part' | 'short';

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

@@ -2,6 +2,20 @@ import type { ScheduleBoardApi } from './useScheduleBoard';
 export interface ScheduleDragPayload {
     empId: number;
     dayIdx: number;
+    /** Which period on that day this card is — 0 for an ordinary single shift. A genuine split
+     * shift's one merged card drags both periods together (`slotCount` > 1); any other card on
+     * a multi-shift day is its own independent slot and carries just itself. */
+    slotIndex: number;
+    slotCount: number;
+}
+/** Where a drag is currently hovering — read by ScheduleShiftCell to decide what to light up.
+ * `onCard`/`slotIndex` distinguish the two outcomes a drop here actually has: over an existing
+ * card it's a swap offer (that one card), over the rest of the cell it lands alongside it. */
+export interface ScheduleDragHoverTarget {
+    empId: number;
+    dayIdx: number;
+    onCard: boolean;
+    slotIndex: number | null;
 }
 /** Native HTML5 drag & drop for moving an existing shift card between employee/day cells.
  * The mockup's other drag source — a staff-rail row dragged onto an open shift — is an
@@ -12,11 +26,29 @@ export declare function useScheduleDragDrop(board: ScheduleBoardApi): {
     dragging: import("vue").Ref<{
         empId: number;
         dayIdx: number;
+        slotIndex: number;
+        slotCount: number;
     } | null, ScheduleDragPayload | {
         empId: number;
         dayIdx: number;
+        slotIndex: number;
+        slotCount: number;
+    } | null>;
+    hoverTarget: import("vue").Ref<{
+        empId: number;
+        dayIdx: number;
+        onCard: boolean;
+        slotIndex: number | null;
+    } | null, ScheduleDragHoverTarget | {
+        empId: number;
+        dayIdx: number;
+        onCard: boolean;
+        slotIndex: number | null;
     } | null>;
-    startShiftDrag: (empId: number, dayIdx: number, ev: DragEvent) => void;
+    startShiftDrag: (empId: number, dayIdx: number, ev: DragEvent, slotIndex?: number) => void;
     endDrag: () => void;
+    setDragHover: (empId: number, dayIdx: number, onCard: boolean, slotIndex: number | null) => void;
+    clearDragHover: (empId: number, dayIdx: number) => void;
     dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
 };
+export type ScheduleDragDropApi = ReturnType<typeof useScheduleDragDrop>;

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

@@ -10,6 +10,10 @@ export interface ExportMatrix {
     head: string[];
     body: (string | ExportShiftCell)[][];
     foot: string[];
+    /** Worked shifts across the whole matrix, split-shift pairs counted once — whether there is
+     * anything to print. Not read off the footer's own last column: that column is OT hours now,
+     * and a fully-staffed week with nobody over contract totals 0.0 there. */
+    shiftTotal: number;
 }
 /** The mockup's Share/export feature (buildExportMatrix/exportPDF/exportJPG) — no external
  * PDF/canvas library anywhere in the mockup; PDF is an HTML preview handed to window.print(),
@@ -18,9 +22,22 @@ export declare function useScheduleExport(board: ScheduleBoardApi): {
     buildExportMatrix: () => ExportMatrix;
     pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
     pdfHtml: import("vue").ComputedRef<string>;
+    pdfBarMeta: import("vue").ComputedRef<string>;
     openPdfPreview: () => void;
     closePdfPreview: () => void;
     printNow: () => void;
     exportJpg: () => void;
+    exportDoneOpen: import("vue").Ref<boolean, boolean>;
+    exportDoneRecap: import("vue").Ref<{
+        label: string;
+        value: string;
+    }[], {
+        label: string;
+        value: string;
+    }[] | {
+        label: string;
+        value: string;
+    }[]>;
+    closeExportDone: () => void;
 };
 export type ScheduleExportApi = ReturnType<typeof useScheduleExport>;

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

@@ -1,12 +1,11 @@
 import type { CoverageSegment } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
-import type { ScheduleAssignApi } from './useScheduleAssign';
 export interface ScheduleGapActions {
     /** Open the shift editor on a brand new shift for this day and these hours. */
     addShift: (dayIdx: number, position: string, start: string, end: string) => void;
 }
-export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi, assign: ScheduleAssignApi, actions: ScheduleGapActions): {
+export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi, actions: ScheduleGapActions): {
     state: {
         open: boolean;
         pinned: boolean;
@@ -76,7 +75,6 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
     segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
     segFocus: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
     addShift: () => void;
-    suggestStaffing: () => void;
     close: () => void;
 };
 export type ScheduleGapPopoverApi = ReturnType<typeof useScheduleGapPopover>;

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

@@ -1,25 +1,22 @@
 import type { LeaveSlot } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
-/** What a day off can be booked as. "Rest Day" leads: it is the most-used reason a day is not
- * worked. */
-export declare const LEAVE_REASONS: string[];
-/** The type the menu's plain "Leave" row books. */
-export declare const DEFAULT_LEAVE_REASON = "Annual Leave";
-export type ScheduleLeaveMode = 'all' | 'am' | 'pm' | 'custom';
+export type TimeOffSelection = 'OFF_DAY' | 'ANNUAL' | 'MEDICAL' | 'EMERGENCY' | 'UNPAID';
+export declare const TIME_OFF_OPTIONS: Array<{
+    value: TimeOffSelection;
+    label: string;
+}>;
+export type ScheduleLeaveMode = 'all' | 'am' | 'pm';
 export interface ScheduleLeaveState {
     open: boolean;
     empId: number | null;
     dayIdx: number | null;
     /** Booking a new record, rather than editing one that is already on the day. */
     isNew: boolean;
-    reason: string;
+    selection: TimeOffSelection;
     mode: ScheduleLeaveMode;
-    /** The hours when mode is 'custom'. */
-    from: string;
-    to: string;
 }
 /** 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 Rest Day / Leave rows
+ * 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): {
     state: {
@@ -27,29 +24,20 @@ export declare function useScheduleLeave(board: ScheduleBoardApi): {
         empId: number | null;
         dayIdx: number | null;
         isNew: boolean;
-        reason: string;
+        selection: TimeOffSelection;
         mode: ScheduleLeaveMode;
-        from: string;
-        to: string;
     };
     employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
     activeSlot: import("vue").ComputedRef<LeaveSlot | null>;
     options: import("vue").ComputedRef<({
-        hrs: string;
-        mode: "custom";
-        name: "Specific hours";
-    } | {
-        hrs: string;
-        mode: "all";
-        name: "All day";
+        readonly mode: "all";
+        readonly name: "Full day";
     } | {
-        hrs: string;
-        mode: "am";
-        name: "Morning";
+        readonly mode: "am";
+        readonly name: "Half day AM";
     } | {
-        hrs: string;
-        mode: "pm";
-        name: "Afternoon";
+        readonly mode: "pm";
+        readonly name: "Half day PM";
     })[]>;
     span: import("vue").ComputedRef<{
         from: string;
@@ -57,14 +45,15 @@ export declare function useScheduleLeave(board: ScheduleBoardApi): {
         hours: number;
     }>;
     valid: import("vue").ComputedRef<boolean>;
+    selectionLabel: import("vue").ComputedRef<string>;
     dayLabel: import("vue").ComputedRef<string>;
     hoursText: import("vue").ComputedRef<string>;
-    coverText: import("vue").ComputedRef<string>;
+    coverText: import("vue").ComputedRef<"Full day" | "Half day AM" | "Half day PM">;
     openFor: (empId: number, dayIdx: number, reason?: string | null) => void;
     close: () => void;
-    save: () => void;
-    approve: () => void;
+    save: () => Promise<void>;
+    approve: () => Promise<void>;
     reject: () => void;
-    remove: () => void;
+    remove: () => Promise<void>;
 };
 export type ScheduleLeaveApi = ReturnType<typeof useScheduleLeave>;

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

@@ -0,0 +1,9 @@
+import type { useScheduleOnboardingWizard } from './useScheduleOnboardingWizard';
+import type { useScheduleSetupBanner } from './useScheduleSetupBanner';
+type SetupBannerApi = ReturnType<typeof useScheduleSetupBanner>;
+type OnboardingWizardApi = ReturnType<typeof useScheduleOnboardingWizard>;
+/** Coordinates the welcome banner and wizard without making SchedulePage own onboarding flow. */
+export declare function useScheduleOnboardingFlow(setupBanner: SetupBannerApi, wizard: OnboardingWizardApi): {
+    onWelcomeSetUp: () => void;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import type { Employee } from '../types';
+import type { FdtoScheduleEmployee } from '@feedmepos/hrm-schedule-contract';
+import type { TeamRow } from './onboarding-types';
+export interface OnboardingProfileRow {
+    emp: Employee;
+    row: TeamRow;
+}
+/** Writes the queued team and availability drafts once per employee. */
+export declare function saveOnboardingProfiles(pendingTeam: Set<number>, pendingAvail: Map<number, Array<{
+    dayOfWeek: number;
+    start: string;
+    end: string;
+}>>, rows: OnboardingProfileRow[], rawEmployee: (id: number) => FdtoScheduleEmployee | undefined): Promise<void>;