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

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

@@ -1,48 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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 {};

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

@@ -1,68 +0,0 @@
-import type { CoverageSegment, DaySlot, DemandPeriod } from '../types';
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export declare function toMin(t: string): number;
-export declare function minToHHMM(m: number): string;
-/** Minutes from midnight for a start/end pair, with the end pushed past 1440 when it wraps —
- * so an overnight stretch stays one interval rather than two that cross zero. */
-export declare function spanOf(start: string, end: string): [number, number];
-/** 12-hour clock for prose — the sheet and the popovers read as sentences, and "16:00" in the
- * middle of one does not. */
-export declare function t12(hhmm: string): string;
-/** The terse form the timeline's two end labels use — "8a", "10:30p". At 8.5px there is room
- * for the hour and not for the meridiem spelled out. */
-export declare function minToShort(m: number): string;
-export declare function rangeText(from: number, to: number): string;
-export declare function roleTotalOf(p: DemandPeriod): number;
-/** The unnamed part of a period's headcount. Derived, never typed — so it cannot disagree with
- * the total above it. Negative means the breakdown has overrun that total. */
-export declare function anyLeftOf(p: DemandPeriod): number;
-export interface ScheduleCoverageAxis {
-    from: number;
-    to: number;
-}
-/** 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. So a date's
- * own demand is keyed by ISO date, and a standing weekday rule is keyed by weekday index.
- *
- * A date's own demand wins over the weekday rule it would otherwise inherit — "every Tuesday
- * needs eight" is a standing statement, and "this Tuesday is different" has to be able to
- * override it without rewriting the rule. */
-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[];
-    coverageImpact: (dayIdx: number, empId: number, slot: DaySlot) => {
-        when: string;
-        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

@@ -1,45 +0,0 @@
-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;
-    closed: boolean;
-    /** No demand stated on this day — the cell carries its own "+ Set demand" instead. */
-    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

@@ -1,139 +0,0 @@
-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) => void;
-    /** Positions the breakdown can name — the same list the shift editor offers. */
-    positionOptions: () => string[];
-}
-/** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
- * real cancel. The sheet also carries the recurrence choice, because "every Tuesday" is a
- * property of the statement being made rather than a second screen. */
-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;
-            n: number;
-        }[] | undefined;
-    }[], DemandPeriod[] | {
-        from: string;
-        to: string;
-        n: number;
-        roles?: {
-            position: string;
-            n: number;
-        }[] | undefined;
-    }[]>;
-    apply: import("vue").Ref<DemandApplyMode, DemandApplyMode>;
-    applyOptions: import("vue").ComputedRef<({
-        on: boolean;
-        key: "day";
-        label: string;
-        sub: string;
-    } | {
-        on: boolean;
-        key: "weekday";
-        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>;
-    overlapWarning: import("vue").ComputedRef<string>;
-    whenLabel: import("vue").ComputedRef<string>;
-    openFor: (idx: number) => void;
-    close: () => void;
-    addPeriod: () => void;
-    removePeriod: (i: number) => void;
-    setHeads: (i: number, value: number | string) => void;
-    addRole: (i: 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;
-        pct: number;
-        tone: "short" | "part" | "met" | "over";
-        note: string;
-    }[]>;
-    coverageTotal: import("vue").ComputedRef<{
-        required: number;
-        scheduled: number;
-        pct: number;
-        tone: "short" | "part" | "met" | "over";
-        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;
-                n: number;
-            }[] | undefined;
-        }[];
-    } | null, ScheduleDemandSuggestion | {
-        why: string;
-        periods: {
-            from: string;
-            to: string;
-            n: number;
-            roles?: {
-                position: string;
-                n: number;
-            }[] | undefined;
-        }[];
-    } | null>;
-    suggestionRows: import("vue").ComputedRef<{
-        when: string;
-        n: number;
-        word: string;
-    }[]>;
-    suggest: () => 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: (k: DemandApplyMode) => DemandApplyMode;
-};
-export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

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

@@ -1,22 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleDragPayload {
-    empId: number;
-    dayIdx: number;
-}
-/** 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;
-    } | null, ScheduleDragPayload | {
-        empId: number;
-        dayIdx: number;
-    } | null>;
-    startShiftDrag: (empId: number, dayIdx: number, ev: DragEvent) => void;
-    endDrag: () => void;
-    dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
-};

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

@@ -1,32 +0,0 @@
-import type { Employee } from '../types';
-/** The one form every SMALL avatar wears — `.sc-av`, `.ch-av`, `.ap-av`, `.tl-av`, and the
- * shift editor's `.sp2-who-av`. A tint of the person's colour behind their own colour, never a
- * solid fill with white text: at 17–30px the initials are the only identifier, and knocking
- * them out to white on a saturated disc costs the contrast that makes them legible.
- *
- * None of those classes declare a background of their own, so they REQUIRE this — a bare
- * `<span class="sc-av">` renders as an invisible disc.
- *
- * The big identity avatars are the opposite case and take no inline style at all: `.emp-avatar`,
- * `.dp-emp-av` and `.pub-change-av` are neutral in CSS, because a name sits right beside them
- * and a filled disc would out-shout it. */
-export declare function avatarTint(color?: string | null): Record<string, string>;
-export interface ScheduleEmployeeLoad {
-    emp: Employee;
-    hours: number;
-    cost: number;
-    contract: number;
-    partTime: boolean;
-    /** Hours as a fraction of contract, capped at 1 — the load bar's width. */
-    pct: number;
-    barColor: string;
-    otHours: number;
-}
-/** One person's load against their contract, derived from the shifts actually on the board
- * rather than from the stored `weekHours` field, so the bar can never disagree with the row
- * of cards beside it.
- *
- * The staff rail (area view) and the grid's name column (employee view) are the same list of
- * the same people; they used to be two pieces of markup reading two different numbers. This
- * is the single one — the mockup's own note on empIdentityHTML(). */
-export declare function employeeLoadOf(emp: Employee): ScheduleEmployeeLoad;

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

@@ -1,16 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleEmployeeProfileState {
-    open: boolean;
-    empId: number | null;
-}
-/** Employee profile side sheet — opened from the staff-rail row menu or by clicking
- * an employee's identity block. */
-export declare function useScheduleEmployeeProfile(board: ScheduleBoardApi): {
-    state: {
-        open: boolean;
-        empId: number | null;
-    };
-    employee: import("vue").ComputedRef<import("../types").Employee | null>;
-    openFor: (empId: number) => void;
-    close: () => void;
-};

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

@@ -1,26 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ExportShiftCell {
-    note: string;
-    shifts: {
-        when: string;
-        pos: string;
-    }[];
-}
-export interface ExportMatrix {
-    head: string[];
-    body: (string | ExportShiftCell)[][];
-    foot: string[];
-}
-/** 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(),
- * JPG is a hand-drawn Canvas 2D table converted with toBlob. */
-export declare function useScheduleExport(board: ScheduleBoardApi): {
-    buildExportMatrix: () => ExportMatrix;
-    pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
-    pdfHtml: import("vue").ComputedRef<string>;
-    openPdfPreview: () => void;
-    closePdfPreview: () => void;
-    printNow: () => void;
-    exportJpg: () => void;
-};
-export type ScheduleExportApi = ReturnType<typeof useScheduleExport>;

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

@@ -1,14 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export type ScheduleViewMode = 'area' | 'employee';
-export type ScheduleGranularity = 'day' | 'week';
-/** State for the filter-bar's mode/granularity selects. Granularity delegates straight to
- * the board, which owns the day/week grid state — both area and employee grouping combine
- * with either granularity. Outlet switching isn't modeled at all yet, so that control has
- * no state here; it's a static label in the component. */
-export declare function useScheduleFilterBar(board: ScheduleBoardApi): {
-    mode: import("vue").Ref<ScheduleViewMode, ScheduleViewMode>;
-    granularity: import("vue").Ref<import("./useScheduleBoard").ScheduleGranularity, import("./useScheduleBoard").ScheduleGranularity>;
-    setMode: (value: ScheduleViewMode) => boolean;
-    setGranularity: (value: ScheduleGranularity) => boolean;
-};
-export type ScheduleFilterBarApi = ReturnType<typeof useScheduleFilterBar>;

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

@@ -1,80 +0,0 @@
-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): {
-    state: {
-        open: boolean;
-        pinned: boolean;
-        peek: boolean;
-        wide: boolean;
-        left: number;
-        top: number;
-    };
-    ctx: import("vue").Ref<{
-        from: number;
-        to: number;
-        required: number;
-        scheduled: number;
-        short: number;
-        over: number;
-        roles: {
-            position: string;
-            n: number;
-            required: number;
-            got: number;
-            short: number;
-        }[];
-        anyReq: number;
-        anyGot: number;
-        none: boolean;
-        dayIdx: number;
-    } | null, (CoverageSegment & {
-        dayIdx: number;
-    }) | {
-        from: number;
-        to: number;
-        required: number;
-        scheduled: number;
-        short: number;
-        over: number;
-        roles: {
-            position: string;
-            n: number;
-            required: number;
-            got: number;
-            short: number;
-        }[];
-        anyReq: number;
-        anyGot: number;
-        none: boolean;
-        dayIdx: number;
-    } | null>;
-    view: import("vue").ComputedRef<{
-        when: string;
-        day: string;
-        none: boolean;
-        required: number;
-        scheduled: number;
-        short: number;
-        over: number;
-        missing: {
-            short: number;
-            position: string;
-        }[];
-        missingNote: string;
-    } | null>;
-    segEnter: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
-    segLeave: () => void;
-    hold: () => void;
-    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,20 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleLeaveState {
-    open: boolean;
-    empId: number | null;
-    dayIdx: number | null;
-}
-/** Approve / reject / remove a leave record on a day — the mockup's leave editor modal. */
-export declare function useScheduleLeave(board: ScheduleBoardApi): {
-    state: {
-        open: boolean;
-        empId: number | null;
-        dayIdx: number | null;
-    };
-    activeSlot: import("vue").ComputedRef<import("../types").LeaveSlot | null>;
-    openFor: (empId: number, dayIdx: number) => void;
-    close: () => void;
-    approve: () => void;
-    reject: () => void;
-    remove: () => void;
-};

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

@@ -1,15 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleCoverageBadge {
-    position: string;
-    required: number;
-    scheduled: number;
-    short: boolean;
-}
-/** Coverage badges for a day's header card — required vs. scheduled headcount per
- * position, from the single active shift template's coverage matrix. */
-export declare function useScheduleLegend(board: ScheduleBoardApi): {
-    coveragePositions: import("vue").ComputedRef<string[]>;
-    coverageForDay: (dayIdx: number) => ScheduleCoverageBadge[];
-    dayIsShort: (dayIdx: number) => boolean;
-    dayCardTitle: (dayIdx: number) => string;
-};

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

@@ -1,35 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
-export type ScheduleLegendKey = 'empty' | 'draft' | 'pub' | 'open' | 'warn' | 'ot' | 'leave';
-export interface ScheduleLegendItem {
-    key: ScheduleLegendKey;
-    count: number;
-    label: string;
-    /** The warnings figure is the one worth acting on, so it renders as a control that
-     * cycles the grid through each conflict — see jumpToConflict(). */
-    action: boolean;
-    title?: string;
-}
-interface ScheduleConflictRef {
-    empId: number;
-    dayIdx: number;
-    name: string;
-}
-export interface ScheduleLegendBarOptions {
-    /** Toast for the conflict cycle — "Conflict 2 of 5 · Nadia, Wed". */
-    onJump?: (message: string) => void;
-}
-/** The footer legend under the scheduler: every state a card can be in, counted off the
- * same records the grid renders. Ported from the mockup's renderLegend(). Every figure is
- * scoped to the days currently on screen, except warnings — which counts the whole week, so
- * the number stays stable while jumpToConflict() pages through days one at a time (the
- * mockup's conflictCount() is likewise whole-data rather than span-scoped).
- *
- * Distinct from useScheduleLegend, which is the day header's coverage badges. */
-export declare function useScheduleLegendBar(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, opts?: ScheduleLegendBarOptions): {
-    items: import("vue").ComputedRef<ScheduleLegendItem[]>;
-    conflicts: import("vue").ComputedRef<ScheduleConflictRef[]>;
-    jumpToConflict: () => void;
-};
-export type ScheduleLegendBarApi = ReturnType<typeof useScheduleLegendBar>;
-export {};