@feedmepos/mf-hrm-portal 2.3.2-dev → 2.3.2-dev.10

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/useScheduleCopyWeek.d.ts

@@ -0,0 +1,12 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** 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. */
+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

@@ -0,0 +1,60 @@
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
+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;
+    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
+ * 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, proposalAt?: () => ((empId: number, dayIdx: number) => Proposal | undefined) | undefined): {
+    rows: import("vue").ComputedRef<ScheduleEmployeeLoad[]>;
+    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>;
+    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[]>;
+};
+export type ScheduleCostRailApi = ReturnType<typeof useScheduleCostRail>;

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

@@ -0,0 +1,44 @@
+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, type?: 'info' | 'success' | 'error') => 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>;
+    rateApplies: import("vue").ComputedRef<boolean>;
+    holidayHint: import("vue").ComputedRef<string>;
+    openFor: (dayIdx: number, anchor: HTMLElement) => void;
+    close: () => 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,111 @@
+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;
+        width: number;
+    };
+    laneTop?: number;
+    laneHeight?: number;
+    employeeId?: number;
+    slotIndex?: number;
+    onClick?: () => void;
+}
+export interface ScheduleTimelineRow {
+    key: string;
+    kind: 'open' | 'employee' | 'position';
+    swatchColor?: string;
+    swatchClass?: string;
+    avatarInitials?: string;
+    avatarColor?: string;
+    employeeId?: number;
+    employeeLoad?: ScheduleEmployeeLoad;
+    roleLabel?: string;
+    hoursLabel?: string;
+    hoursPct?: number;
+    onMenu?: (anchor: HTMLElement) => void;
+    name: string;
+    sub: string;
+    bars: ScheduleTimelineBar[];
+    pastDay?: boolean;
+    lockedDay?: boolean;
+    closedDay?: boolean;
+    availabilityDay?: boolean;
+    availabilityLabel?: string;
+    minHeight?: number;
+    emptyText?: string;
+    onTrackClick?: (anchor: HTMLElement) => void;
+}
+export interface ScheduleHourCell {
+    m: number;
+    clock: string;
+    open: boolean;
+    state: '' | 'short' | 'met' | 'over';
+    barHeightPct: number;
+    title: string;
+    n: number;
+}
+export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, demand: ScheduleDemandApi, handlers: {
+    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;
+    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<{
+        from: number;
+        to: number;
+        span: number;
+    }>;
+    hours: import("vue").ComputedRef<{
+        m: number;
+        clock: string;
+    }[]>;
+    isOpenHour: (m: number) => boolean;
+    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;
+        totalHours: number;
+        totalWages: number;
+        peakN: number;
+        lowN: number;
+        peakAt: number | undefined;
+    }>;
+    minToHHMM: typeof minToHHMM;
+};
+export type ScheduleDayTimelineApi = ReturnType<typeof useScheduleDayTimeline>;
+export {};

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

@@ -0,0 +1,59 @@
+import type { CoverageSegment, DaySlot, DemandPeriod, Employee, Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import { anyLeftOf, minToHHMM, minToShort, rangeText, roleTotalOf, spanOf, t12, toMin } from './schedule-demand-domain';
+import type { ScheduleCoverageAxis } from './schedule-demand-domain';
+export { anyLeftOf, minToHHMM, minToShort, rangeText, roleTotalOf, spanOf, t12, toMin };
+export type { ScheduleCoverageAxis } from './schedule-demand-domain';
+/** Staffing demand, and coverage read against it.
+ *
+ * Storage follows this board's dayNotes rather than the mockup's flat `di` index: the mockup
+ * renders one long horizon so a day index identifies a date, but this board pages through
+ * weeks, and demand put on this Monday must not reappear on every other Monday. Demand is
+ * therefore keyed by explicit ISO date.
+ *
+ * The weekday fallback remains only as a defensive read path until legacy records are removed. */
+export declare function useScheduleDemand(board: ScheduleBoardApi): {
+    byDate: Record<string, DemandPeriod[]>;
+    byWeekday: Record<number, DemandPeriod[]>;
+    demandFor: (dayIdx: number) => DemandPeriod[];
+    hasDemandOn: (dayIdx: number) => boolean;
+    demandIsOwn: (dayIdx: number) => boolean;
+    setDateDemand: (dayIdx: number, periods: DemandPeriod[]) => void;
+    clearDateDemand: (dayIdx: number) => void;
+    setWeekdayDemand: (weekday: number, periods: DemandPeriod[]) => void;
+    coverageAxis: (dayIdx: number) => ScheduleCoverageAxis;
+    coverageSegments: (dayIdx: number) => CoverageSegment[];
+    setPreview: (items: Proposal[]) => void;
+    segmentsWith: (dayIdx: number, employees: Employee[]) => CoverageSegment[];
+    dayHeadcount: (dayIdx: number) => {
+        crew: number;
+        peak: number;
+    };
+    coverageImpact: (dayIdx: number, empId: number | null, slot: DaySlot) => {
+        when: string;
+        pctBefore: number;
+        pctAfter: number;
+        stillShort: number;
+        before: {
+            required: number;
+            scheduled: number;
+        };
+        after: {
+            required: number;
+            scheduled: number;
+        };
+        beforeSegs: CoverageSegment[];
+        afterSegs: CoverageSegment[];
+        axis: ScheduleCoverageAxis;
+    } | null;
+    coveragePct: (dayIdx: number) => number | null;
+    shortSegs: (dayIdx: number) => CoverageSegment[];
+    shortInRange: (dayIdx: number, start: string, end: string) => number;
+    biggestGap: (dayIdx: number) => CoverageSegment | null;
+    rangeSummary: import("vue").ComputedRef<{
+        live: number;
+        set: number;
+        shortDays: number;
+    }>;
+};
+export type ScheduleDemandApi = ReturnType<typeof useScheduleDemand>;

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

@@ -0,0 +1,47 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleSegState = 'met' | 'short' | 'over' | 'nodem';
+export interface ScheduleDemandSeg {
+    key: string;
+    from: number;
+    to: number;
+    state: ScheduleSegState;
+    /** Percentage of the day's axis this segment occupies — width means duration. */
+    width: string;
+    label: string;
+}
+export interface ScheduleDemandCell {
+    dayIdx: number;
+    /** 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';
+    segs: ScheduleDemandSeg[];
+    hoursFrom: string;
+    hoursTo: string;
+    pctTitle: string;
+    title: string;
+}
+/** What the coverage band draws, one cell per visible day.
+ *
+ * The percentage is the headline and the strip is the reason — a day can be 81% covered with
+ * the missing fifth spread thinly or concentrated at six o'clock, and only one of those is a
+ * problem you act on tonight. */
+export declare function useScheduleDemandRow(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    cellFor: (dayIdx: number) => ScheduleDemandCell;
+    cells: import("vue").ComputedRef<{
+        dayIdx: number;
+        colIndex: number;
+        cell: ScheduleDemandCell;
+    }[]>;
+    lead: import("vue").ComputedRef<{
+        blank: boolean;
+        name: string;
+        meta: string;
+    }>;
+    dayTitle: (dayIdx: number) => string;
+};
+export type ScheduleDemandRowApi = ReturnType<typeof useScheduleDemandRow>;

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

@@ -0,0 +1,166 @@
+import type { DemandApplyMode, DemandPeriod } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export interface ScheduleDemandSuggestion {
+    why: string;
+    periods: DemandPeriod[];
+}
+export interface ScheduleDemandSheetOptions {
+    onToast?: (message: string, type?: 'info' | 'success' | 'error') => void;
+    /** Positions the breakdown can name — the same list the shift editor offers. */
+    positionOptions: () => string[];
+    /** Called instead of a toast when "+ Position breakdown" is pressed and there is no position
+     * to name yet — the page opens its Add Position popup for that period. */
+    onNeedPosition?: (periodIdx: number, roleIdx: number) => void;
+}
+/** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
+ * real cancel. Apply scopes are expanded into explicit dates in the visible week. */
+export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand: ScheduleDemandApi, opts: ScheduleDemandSheetOptions): {
+    open: import("vue").Ref<boolean, boolean>;
+    dayIdx: import("vue").Ref<number | null, number | null>;
+    periods: import("vue").Ref<{
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            positionId?: string | undefined;
+            n: number;
+        }[] | undefined;
+    }[], DemandPeriod[] | {
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            positionId?: string | undefined;
+            n: number;
+        }[] | undefined;
+    }[]>;
+    apply: import("vue").Ref<DemandApplyMode, DemandApplyMode>;
+    applyOptions: import("vue").ComputedRef<({
+        on: boolean;
+        key: "day";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "every";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "weekdays";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "custom";
+        label: string;
+        sub: string;
+    })[]>;
+    weekdayButtons: import("vue").ComputedRef<{
+        i: number;
+        label: string;
+        on: boolean;
+    }[]>;
+    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;
+    close: (preserveDraft?: boolean) => void;
+    hasUnsavedChanges: import("vue").ComputedRef<boolean>;
+    diffSummary: import("vue").ComputedRef<{
+        changed: number;
+        added: number;
+        removed: number;
+        modified: number;
+    }>;
+    isPeriodChanged: (index: number) => boolean;
+    isPeriodFieldChanged: (index: number, field: "from" | "to" | "n") => boolean;
+    revert: () => void;
+    addPeriod: () => void;
+    removePeriod: (i: number) => void;
+    setHeads: (i: number, value: number | string) => void;
+    addRole: (i: number) => void;
+    addRoleNamed: (i: number, position: string) => void;
+    requestNewPosition: (i: number, k: number) => void;
+    removeRole: (i: number, k: number) => void;
+    setRoleCount: (i: number, k: number, value: number | string) => void;
+    setRolePosition: (i: number, k: number, position: string) => void;
+    anyLeft: (p: DemandPeriod) => number;
+    coverageRows: import("vue").ComputedRef<{
+        when: string;
+        required: number;
+        scheduled: number;
+        varies: boolean;
+        pct: number;
+        tone: "short" | "part" | "over" | "met";
+        note: string;
+    }[]>;
+    coverageTotal: import("vue").ComputedRef<{
+        required: number;
+        scheduled: number;
+        pct: number;
+        tone: "short" | "part" | "over" | "met";
+        note: string;
+    }>;
+    saving: import("vue").Ref<boolean, boolean>;
+    save: () => Promise<void>;
+    suggestion: import("vue").Ref<{
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                positionId?: string | undefined;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null, ScheduleDemandSuggestion | {
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                positionId?: string | undefined;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null>;
+    suggestionRows: import("vue").ComputedRef<{
+        when: string;
+        n: number;
+        word: string;
+    }[]>;
+    suggest: () => void;
+    askRemy: () => Promise<void>;
+    acceptSuggestion: () => void;
+    dismissSuggestion: () => void;
+    canCopy: import("vue").ComputedRef<boolean>;
+    copyOpen: import("vue").Ref<boolean, boolean>;
+    copyPicks: Record<number, boolean>;
+    copyRows: import("vue").ComputedRef<{
+        dayIdx: number;
+        label: string;
+        sub: string;
+    }[]>;
+    copySub: import("vue").ComputedRef<string>;
+    openCopy: () => void;
+    closeCopy: () => void;
+    confirmCopy: () => Promise<void>;
+    setApply: (mode: DemandApplyMode) => void;
+};
+export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

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

@@ -0,0 +1,55 @@
+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
+ * area-view feature (`r.draggable = viewMode === 'area'` there); this board is employee-view
+ * only, so that gesture doesn't exist here — filling an open shift goes through the Assign
+ * popover (click) instead. */
+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, 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;
+    dropOnPosition: (targetDayIdx: number, targetPosition: string, allowLocked?: boolean) => void;
+};
+export type ScheduleDragDropApi = ReturnType<typeof useScheduleDragDrop>;

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

@@ -0,0 +1,24 @@
+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, options?: {
+    excludePosUserId?: ComputedRef<string | undefined>;
+}): {
+    passcodeValue: ComputedRef<string>;
+    passcodeOk: ComputedRef<boolean>;
+    setPasscodeDigit: (index: number, value: string) => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
+    togglePosAccess: () => void;
+    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) => Role[];
+    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

@@ -0,0 +1,13 @@
+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<string>;
+    avAllLabel: ComputedRef<string>;
+    maxHoursPlaceholder: ComputedRef<string>;
+    ensureAvailHours: (index: number) => void;
+    toggleAvailDay: (index: number) => void;
+    availAll: () => void;
+    setAvailHour: (index: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (index: number) => void;
+};