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

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

@@ -0,0 +1,415 @@
+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, };
+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;
+    clearDayNote: (dayIdx: number) => void;
+    toggleClosed: (dayIdx: number) => {
+        closed: boolean;
+        rostered: number;
+    };
+    isManuallyClosed: (dayIdx: number) => boolean;
+    isStandingClosedWeekday: (dayIdx: number) => boolean;
+    holidayName: (dayIdx: number) => string | null;
+    holidayIsAuto: (dayIdx: number) => boolean;
+    isPublicHoliday: (dayIdx: number) => boolean;
+    holidayRateApplies: (dayIdx: number) => boolean;
+    setHolidayNormal: (dayIdx: number, toNormal: boolean) => void;
+    setPublicHoliday: (dayIdx: number, on: boolean) => void;
+    otRateOn: (dayIdx: number) => number;
+    regularRateOn: (dayIdx: number) => number;
+    isHoliday: (dayIdx: number) => boolean;
+    employees: import("vue").Ref<{
+        id: number;
+        name: string;
+        role: string;
+        initials: string;
+        color: string;
+        weekHours: number;
+        pct: number;
+        contractHours?: number | undefined;
+        rate: number;
+        positions: string[];
+        shifts: ({
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            assignmentId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | {
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            assignmentId?: string | undefined;
+        }[] | null)[];
+        remarks: {
+            author: string;
+            date: string;
+            type: "note" | "warning" | "praise";
+            text: string;
+        }[];
+        section: string;
+        compGroup?: string | undefined;
+        mobile?: string | undefined;
+        dial?: string | undefined;
+        locations?: string[] | undefined;
+        payBasis?: "hourly" | "monthly" | undefined;
+        payAmount?: number | undefined;
+        maxHours?: number | undefined;
+        maxOtHours?: number | undefined;
+        otAfterDaily?: number | undefined;
+        preferences?: string[] | undefined;
+        seniority?: "senior" | "junior" | "" | undefined;
+        availDays?: boolean[] | undefined;
+        availHours?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+        passcode?: string | undefined;
+        masterUser?: boolean | undefined;
+    }[], Employee[] | {
+        id: number;
+        name: string;
+        role: string;
+        initials: string;
+        color: string;
+        weekHours: number;
+        pct: number;
+        contractHours?: number | undefined;
+        rate: number;
+        positions: string[];
+        shifts: ({
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            assignmentId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | {
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            assignmentId?: string | undefined;
+        }[] | null)[];
+        remarks: {
+            author: string;
+            date: string;
+            type: "note" | "warning" | "praise";
+            text: string;
+        }[];
+        section: string;
+        compGroup?: string | undefined;
+        mobile?: string | undefined;
+        dial?: string | undefined;
+        locations?: string[] | undefined;
+        payBasis?: "hourly" | "monthly" | undefined;
+        payAmount?: number | undefined;
+        maxHours?: number | undefined;
+        maxOtHours?: number | undefined;
+        otAfterDaily?: number | undefined;
+        preferences?: string[] | undefined;
+        seniority?: "senior" | "junior" | "" | undefined;
+        availDays?: boolean[] | undefined;
+        availHours?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+        passcode?: string | undefined;
+        masterUser?: boolean | undefined;
+    }[]>;
+    sections: import("vue").Ref<{
+        id: string;
+        label: string;
+        roles: string[];
+        system?: boolean | undefined;
+    }[], Section[] | {
+        id: string;
+        label: string;
+        roles: string[];
+        system?: boolean | undefined;
+    }[]>;
+    openShifts: import("vue").Ref<{
+        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;
+    }[], OpenShift[] | {
+        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;
+    }[]>;
+    rangeStart: import("vue").Ref<Date, Date>;
+    weekOffset: import("vue").ComputedRef<number>;
+    peekWeek: (offset: number) => import("./schedule-week-cache").WeekBucket;
+    isRecentlySaved: (empId: number, dayIdx: number) => boolean;
+    isWeekLocked: (offset?: number) => boolean;
+    dayLocked: (dayIdx: number) => boolean;
+    pendingChanges: import("vue").Ref<{
+        empId: number;
+        dayIdx: number;
+        kind: "add" | "change" | "remove";
+        label: string;
+    }[], PendingChange[] | {
+        empId: number;
+        dayIdx: number;
+        kind: "add" | "change" | "remove";
+        label: string;
+    }[]>;
+    unpublishedChanges: import("vue").ComputedRef<PendingChange[]>;
+    persistPublish: (items: Array<{
+        empId: number;
+        dayIdx: number;
+        slot: WorkSlot;
+    }>) => Promise<void>;
+    recordChange: (empId: number, dayIdx: number, kind: PendingChange["kind"], label: string) => void;
+    scheduleVersions: import("vue").Ref<{
+        v: number;
+        at: Date;
+        by: string;
+        note: string;
+        changeCount: number;
+        staffAffected: number;
+        snapshot: {
+            id: number;
+            name: string;
+            weekHours: number;
+            shifts: ({
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                assignmentId?: string | undefined;
+            } | {
+                timeOff: "approved" | "pending";
+                reason: string;
+                half?: boolean | undefined;
+                halfPart?: "AM" | "PM" | undefined;
+                appliedOn?: string | undefined;
+                note?: string | undefined;
+                cert?: {
+                    name: string;
+                    size: string;
+                } | null | undefined;
+                bal?: {
+                    type: string;
+                    entitled: number;
+                    used: number;
+                } | undefined;
+            } | {
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                assignmentId?: string | undefined;
+            }[] | null)[];
+        }[];
+    }[], ScheduleVersion[] | {
+        v: number;
+        at: Date;
+        by: string;
+        note: string;
+        changeCount: number;
+        staffAffected: number;
+        snapshot: {
+            id: number;
+            name: string;
+            weekHours: number;
+            shifts: ({
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                assignmentId?: string | undefined;
+            } | {
+                timeOff: "approved" | "pending";
+                reason: string;
+                half?: boolean | undefined;
+                halfPart?: "AM" | "PM" | undefined;
+                appliedOn?: string | undefined;
+                note?: string | undefined;
+                cert?: {
+                    name: string;
+                    size: string;
+                } | null | undefined;
+                bal?: {
+                    type: string;
+                    entitled: number;
+                    used: number;
+                } | undefined;
+            } | {
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                assignmentId?: string | undefined;
+            }[] | null)[];
+        }[];
+    }[]>;
+    lastUpdatedAt: import("vue").Ref<Date | null, Date | null>;
+    lastPublishedAt: import("vue").Ref<Date | null, Date | null>;
+    pushVersion: (note: string, opts?: Partial<ScheduleVersion>) => ScheduleVersion;
+    snapshotSchedule: () => ScheduleVersionSnapshot[];
+    scheduleStatus: import("vue").ComputedRef<ScheduleStatusInfo>;
+    conflictCount: () => number;
+    granularity: import("vue").Ref<ScheduleGranularity, ScheduleGranularity>;
+    focusDayIdx: import("vue").Ref<number, number>;
+    setGranularity: (value: ScheduleGranularity) => void;
+    dayDates: import("vue").ComputedRef<Date[]>;
+    dayLabels: import("vue").ComputedRef<string[]>;
+    visibleDayIndices: import("vue").ComputedRef<number[]>;
+    visibleDays: import("vue").ComputedRef<{
+        dayIdx: number;
+        date: Date;
+    }[]>;
+    rangeLabel: import("vue").ComputedRef<string>;
+    isToday: (dayIdx: number) => boolean;
+    dateKey: (dayIdx: number) => string | null;
+    navigate: (delta: number) => void;
+    goToday: () => void;
+    membersOf: (sectionId: string) => Employee[];
+    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;
+    clearShiftsInRange: () => {
+        shifts: number;
+        open: number;
+        leave: number;
+    };
+    requiredFor: (dayIdx: number, position: string) => number;
+    scheduledFor: (dayIdx: number, position: string) => number;
+    compGroupRate: (name: string | undefined) => number | undefined;
+    UNASSIGNED: string;
+};
+export type ScheduleBoardApi = ReturnType<typeof useScheduleBoard>;

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

@@ -0,0 +1,27 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** Column facts shared by the day header and every `.shift-cell` under it.
+ *
+ * The mockup builds these inline in its cell loop (`cell.className = 'shift-cell' + …`) and
+ * again in its header loop, which is exactly how the two drifted: closing a day painted the
+ * header and left the cells beneath it clean. One helper, both consumers.
+ *
+ * Two of the mockup's cell states are deliberately absent here:
+ *   - `wk-off` — this board has no standing weekly-off pattern to read (same reason
+ *     `otRateOn()` drops the mockup's rest-day case).
+ *   - `peek` / `week-start` — the mockup renders a multi-week horizon, so it has columns
+ *     outside the selected range and interior week boundaries. This board's visible range
+ *     is exactly one week, so neither can ever fire.
+ */
+export declare function isPastDate(date: Date): boolean;
+export declare function isWeekendDate(date: Date): boolean;
+/** Month-edge compares neighbours in the VISIBLE column order, not raw weekday
+ * index — a lone Daily-view column has no on-screen neighbour to differ from. */
+export declare function isMonthEdgeAt(board: ScheduleBoardApi, colIndex: number): boolean;
+export interface ScheduleCellState {
+    locked: boolean;
+    'closed-day': boolean;
+    'month-edge': boolean;
+    past: boolean;
+}
+/** The class object for one grid cell in column `colIndex` (its weekday is `dayIdx`). */
+export declare function cellStateClasses(board: ScheduleBoardApi, dayIdx: number, colIndex: number): ScheduleCellState;

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

@@ -0,0 +1,18 @@
+export interface ScheduleClashState {
+    open: boolean;
+    message: string;
+    onConfirm: (() => void) | null;
+}
+/** Generic Yes/No conflict-confirmation primitive — the mockup's `askClash`/clashModal,
+ * reused across several flows (leave clashes, overlapping shifts, etc). */
+export declare function useScheduleClashDetection(): {
+    state: {
+        open: boolean;
+        message: string;
+        onConfirm: (() => void) | null;
+    };
+    ask: (message: string, onConfirm: () => void) => void;
+    confirm: () => void;
+    close: () => void;
+};
+export type ScheduleClashDetectionApi = ReturnType<typeof useScheduleClashDetection>;

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

@@ -0,0 +1,17 @@
+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. */
+export declare function useScheduleCopyWeek(board: ScheduleBoardApi): {
+    copyLastWeek: (mode: "staffed" | "open") => void;
+    copyThisWeekForward: (mode: "staffed" | "open") => void;
+};
+export type ScheduleCopyWeekApi = ReturnType<typeof useScheduleCopyWeek>;

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

@@ -0,0 +1,43 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export declare function slotHours(start: string, end: string): number;
+export interface ScheduleDayCost {
+    hours: number;
+    otHours: number;
+    base: number;
+    ot: number;
+    total: number;
+}
+export interface SchedulePositionCost {
+    position: string;
+    base: number;
+    ot: number;
+    total: number;
+}
+export interface ScheduleSectionCost {
+    id: string;
+    label: string;
+    base: number;
+    ot: number;
+    total: number;
+    rows: SchedulePositionCost[];
+}
+export interface ScheduleOtRisk {
+    empId: number;
+    name: string;
+    hours: number;
+    contract: number;
+}
+/** Weekly labour cost + monthly OT gauge for the collapsible cost rail, built off one
+ * per-day breakdown so the rail's totals and the stats row's per-day figures can never
+ * disagree about what a day cost. */
+export declare function useScheduleCostRail(board: ScheduleBoardApi): {
+    collapsed: import("vue").Ref<boolean, boolean>;
+    byDay: import("vue").ComputedRef<ScheduleDayCost[]>;
+    weeklyCost: import("vue").ComputedRef<number>;
+    otHours: import("vue").ComputedRef<number>;
+    monthlyOtUsed: import("vue").ComputedRef<number>;
+    monthlyOtCapHours: number;
+    bySection: import("vue").ComputedRef<ScheduleSectionCost[]>;
+    otRisk: import("vue").ComputedRef<ScheduleOtRisk[]>;
+};
+export type ScheduleCostRailApi = ReturnType<typeof useScheduleCostRail>;

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

@@ -0,0 +1,48 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleDayNoteState {
+    open: boolean;
+    dayIdx: number | null;
+    left: number;
+    top: number;
+}
+export interface ScheduleDayNoteOptions {
+    /** Toasts for the writes that happen on the spot — closing a day, repricing it, saving. */
+    onToast?: (message: string) => void;
+}
+/** One decimal, always: "2×" reads as a count, and 1.5 beside a bare 2 in one sentence looks
+ * like two different kinds of number. Ported from the mockup's fmtRate(). */
+export declare function fmtRate(rate: number): string;
+/** The date card editor — opened by clicking a day card or its pencil. Everything on it is a
+ * fact about the DATE, applying to the whole column: a titled note, whether the venue opens,
+ * and whether the day bills at the holiday rate. Ported from the mockup's openDayNote() /
+ * saveDayNote() / dnToggleClosed() / dnToggleHoliday().
+ *
+ * The mockup re-renders the grid on the two toggles and rebuilds the popover from a stashed
+ * draft so half-typed text survives; Vue re-renders in place, so the draft just stays in the
+ * refs and there is nothing to stash. */
+export declare function useScheduleDayNote(board: ScheduleBoardApi, opts?: ScheduleDayNoteOptions): {
+    state: {
+        open: boolean;
+        dayIdx: number | null;
+        left: number;
+        top: number;
+    };
+    dayIdx: import("vue").ComputedRef<number | null>;
+    title: import("vue").Ref<string, string>;
+    desc: import("vue").Ref<string, string>;
+    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;
+};
+export type ScheduleDayNoteApi = ReturnType<typeof useScheduleDayNote>;

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

@@ -0,0 +1,82 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleRosterApi } from './useScheduleRoster';
+import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+declare function minToHHMM(m: number): string;
+export interface ScheduleTimelineBar {
+    key: string;
+    left: number;
+    width: number;
+    cls: string;
+    label: string;
+    sub?: string;
+    title: string;
+    brk?: {
+        left: number;
+        width: number;
+    };
+    laneTop?: number;
+    laneHeight?: number;
+    onClick?: () => void;
+}
+export interface ScheduleTimelineRow {
+    key: string;
+    kind: 'open' | 'employee' | 'position';
+    swatchColor?: string;
+    swatchClass?: string;
+    avatarInitials?: string;
+    avatarColor?: string;
+    name: string;
+    sub: string;
+    bars: ScheduleTimelineBar[];
+    minHeight?: number;
+    emptyText?: string;
+    onTrackClick?: () => void;
+}
+export interface ScheduleHourCell {
+    m: number;
+    clock: string;
+    open: boolean;
+    state: '' | 'short' | 'met' | 'over';
+    barHeightPct: number;
+    title: string;
+    n: number;
+}
+/** The day's hourly timeline (rows with shift bars placed by time), replacing the multi-day
+ * grid for the one day Daily view is looking at. Ported from the mockup's
+ * renderDayTimeline() + renderHourFooter() — the `else` (area) branch groups rows by position
+ * instead of by employee, reusing the same axis/bar/lane geometry. Auto-Schedule proposal
+ * review isn't carried over here; it stays week-view-only for now. */
+export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, 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;
+}): {
+    dayIdx: import("vue").ComputedRef<number>;
+    axis: import("vue").ComputedRef<{
+        from: number;
+        to: number;
+        span: number;
+    }>;
+    hours: import("vue").ComputedRef<{
+        m: number;
+        clock: string;
+    }[]>;
+    isOpenHour: (m: number) => boolean;
+    openShiftsRow: import("vue").ComputedRef<ScheduleTimelineRow | null>;
+    employeeRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
+    positionTimelineRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
+    footer: import("vue").ComputedRef<{
+        cells: ScheduleHourCell[];
+        staffCount: number;
+        totalHours: number;
+        totalWages: number;
+        peakN: number;
+        lowN: number;
+        peakAt: number | undefined;
+    }>;
+    minToHHMM: typeof minToHHMM;
+};
+export type ScheduleDayTimelineApi = ReturnType<typeof useScheduleDayTimeline>;
+export {};