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

package/dist/src/views/scheduling/components/ScheduleSwapShiftsModal.vue.d.ts

@@ -1,8 +0,0 @@
-import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
-import type { ScheduleShiftActionsApi } from '../composables/useScheduleShiftActions';
-type __VLS_Props = {
-    board: ScheduleBoardApi;
-    actions: ScheduleShiftActionsApi;
-};
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/src/views/scheduling/components/ScheduleTimePickerPopover.vue.d.ts

@@ -1,6 +0,0 @@
-import type { ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
-type __VLS_Props = {
-    timePicker: ScheduleTimePickerApi;
-};
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/src/views/scheduling/components/ScheduleTopbar.vue.d.ts

@@ -1,22 +0,0 @@
-import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
-import type { ScheduleTopbarApi } from '../composables/useScheduleTopbar';
-import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSchedule';
-import type { ScheduleCopyWeekApi } from '../composables/useScheduleCopyWeek';
-import type { ScheduleExportApi } from '../composables/useScheduleExport';
-type __VLS_Props = {
-    board: ScheduleBoardApi;
-    topbar: ScheduleTopbarApi;
-    autoSchedule: ScheduleAutoScheduleApi;
-    copyWeek: ScheduleCopyWeekApi;
-    exportApi: ScheduleExportApi;
-};
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "dev-reset": () => any;
-    "sched-status-click": () => any;
-    "clear-shifts": () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onDev-reset"?: (() => any) | undefined;
-    "onSched-status-click"?: (() => any) | undefined;
-    "onClear-shifts"?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/src/views/scheduling/composables/schedule-add-employee-form.d.ts

@@ -1,67 +0,0 @@
-import type { EmployeeAvailHours } from '../types';
-import type { FdtoScheduleUpdateEmployeeProfileReq } from '@/types/schedule';
-export type ScheduleAddEmployeeStep = 'mode' | 'details';
-export type ScheduleAddEmployeeMode = 'new' | 'existing';
-export interface ScheduleAddEmployeeForm {
-    name: string;
-    mobile: string;
-    dial: string;
-    employment: 'full' | 'part';
-    locations: string[];
-    payBasis: 'hourly' | 'monthly';
-    payAmount: string;
-    maxHours: string;
-    otAfterDaily: string;
-    maxOtHours: string;
-    /** For a part-timer: days they CAN work. For a full-timer: days they're OFF — the
-     * mockup inverts the same array's meaning by employment type. */
-    availDays: boolean[];
-    availHours: EmployeeAvailHours[];
-    preferences: string;
-    primaryPosition: string;
-    secondaryPositions: string[];
-    seniority: '' | 'senior' | 'junior';
-    passcode: string[];
-    masterUser: boolean;
-}
-/** A salaried month, for converting a monthly figure into the hourly one the cost rail
- * actually reads. Ported verbatim from the mockup's MONTH_HOURS. */
-export declare const MONTH_HOURS = 173;
-/** A freshly-ticked worked day defaults to the whole day rather than the outlet's current
- * trading hours — trading hours can change, and narrowing a person's stated availability to
- * whatever the outlet happens to trade today isn't something this form should assume for them.
- * `23:59`, not `24:00`: a part-timer's per-day fields are native `<input type="time">`s, which
- * only accept `00:00`–`23:59` — `24:00` would render as blank there despite being a valid
- * `FdtoScheduleTime` on the wire. */
-export declare function defaultAvailHours(): EmployeeAvailHours;
-export declare function blankForm(): ScheduleAddEmployeeForm;
-/** Coverage and Auto-Schedule are still authored per role, so a role is derived from the
- * primary position rather than asked for twice. Unlike position, Employee.role is one of a
- * fixed small set the grid groups by, so an unrecognised (or unset) position falls back to
- * the first known role instead of leaving the record without one. */
-export declare function roleFromPosition(position: string): string;
-export declare function generateCode(): string;
-/** `raw` is typed `string` because that's the form field's declared type, but Vue 3 casts
- * `v-model` on an `<input type="number">` to an actual `number` regardless — the DOM does this
- * itself, independent of the `.number` modifier, so the runtime value disagrees with the type
- * the moment someone types a digit. `String()` first is what makes `.trim()` safe either way. */
-export declare function parsePositiveInt(raw: string, min: number, max: number): number | undefined;
-export declare function parseNonNegativeInt(raw: string, max: number): number | undefined;
-export declare function initials(name: string): string;
-export declare function isPartTimeForm(form: ScheduleAddEmployeeForm): boolean;
-/** `availDays[i]` always means "is this a working day" — the same convention the board model
- * and `ScheduleEmployeeDetailPanel` read (a day off is one marked NOT worked), regardless of
- * employment type. Only the full-time TOGGLE BUTTON is framed as "mark a day off" rather than
- * "mark a work day" — see `useScheduleAddEmployee`'s `dayLit`, which flips this value for
- * that button's pressed state without touching what's actually stored. */
-export declare function dayIsWorkedInForm(form: ScheduleAddEmployeeForm, i: number): boolean;
-/** Days this form currently marks as worked, converted to Mongo's weekday convention. */
-export declare function availabilityPayload(form: ScheduleAddEmployeeForm): Array<{
-    dayOfWeek: number;
-    start: string;
-    end: string;
-}>;
-/** The EmployeeProfile fields `createExisting` and `updateExisting` both send — everything but
- * `employeeId`, which only the create path has (an update targets one already known from the
- * URL). Shared here so the two payloads cannot silently drift apart. */
-export declare function toEmployeeProfileFields(form: ScheduleAddEmployeeForm, name: string, payAmountNumber: number): FdtoScheduleUpdateEmployeeProfileReq;

package/dist/src/views/scheduling/composables/schedule-board-helpers.d.ts

@@ -1,38 +0,0 @@
-import type { DaySlot, Employee, LeaveSlot, WorkSlot } from '../types';
-import type { FdtoScheduleSaveAssignmentReq } from '@/types/schedule';
-/** dayjs-free local-date key — matches on the browser's local Y/M/D, not UTC, so this stays
- * correct regardless of timezone. */
-export declare function isoDateKey(d: Date): string;
-export declare function isWorkSlot(slot: DaySlot): slot is WorkSlot;
-export declare function isLeaveSlot(slot: DaySlot): slot is LeaveSlot;
-export declare function workSlotsOf(day: DaySlot): WorkSlot[];
-/** A WorkSlot, in the shape ShiftAssignments actually stores. `pending` is the only status
- * this board's own writers ever set on a fresh slot (see commitShift's callers) — `ot` is
- * derived at cost-rail time, never authored, so it has nowhere sensible to map but PUBLISHED. */
-export declare function toAssignmentReq(employeeId: string, date: string, slot: WorkSlot): FdtoScheduleSaveAssignmentReq;
-/** Which coverage-position (a RULES.coverage.full key, e.g. 'grill', 'customer service') a
- * work slot's `role` counts toward for area-view grouping and cost-by-position breakdowns.
- * The shift popover's "Position needed" field writes a coverage-position key directly into
- * `role` for anything authored through it — so a role that's already a coverage key is
- * used as-is. Seed data instead recorded a station label ('FOH', 'Kitchen', ...), which
- * ROLE_POSITIONS translates to that station's first/primary position. This can't tell a
- * Kitchen employee's grill shifts apart from their prep shifts when the seed data only
- * ever recorded the station — that distinction only exists once a shift is authored (or
- * re-saved) through the popover, which does record the specific position. */
-export declare function positionKeyOf(role: string): string;
-/** The hours this employee is contracted to in a week — what "18h / 44h" measures against.
- * Stated per person on their own profile now that ScheduleSettings carries pay rates alone, so
- * there is no venue-wide full/part pair to fall back to: somebody nobody has agreed hours with
- * reads 0, which is the truth rather than a default they never signed. */
-export declare function contractCapFor(emp: Employee): number;
-/** Whether `hours` runs past what this person is contracted to.
- *
- * A cap of 0 means no hours were ever agreed, which is NOT a contract of zero hours: read
- * naively, `hours > 0` makes every rostered minute overtime, flags everybody on the cost rail's
- * over-contract list and makes copy-week refuse every shift. An unknown limit cannot be
- * exceeded, so it is treated as no limit and the question is answered false. */
-export declare function overContract(emp: Employee, hours: number): boolean;
-export declare function isPartTime(emp: Employee): boolean;
-/** Which weekday (0 = Mon) is today, relative to no particular week — used to seed
- * focusDayIdx whenever "today" needs a weekday index rather than a date. */
-export declare function todayWeekdayIdx(): number;

package/dist/src/views/scheduling/composables/schedule-day-meta.d.ts

@@ -1,29 +0,0 @@
-import { type Ref } from 'vue';
-import type { Employee, ScheduleDayNote } from '../types';
-/** Everything a manager authors about a DATE rather than about a shift — the note on its
- * card, whether the venue opens, whether it bills at the holiday rate. Keyed by ISO date
- * (via the board's `dateKey`), not by weekday index: the mockup's flat single-week horizon
- * could use the weekday index directly, but the board pages through weeks, and a note put on
- * this Monday must not reappear on every other Monday. */
-export declare function useScheduleDayMeta(employees: Ref<Employee[]>, dateKey: (dayIdx: number) => string | null, handlers?: {
-    onPersistError?: (message: string) => void;
-}): {
-    dayNote: (dayIdx: number) => 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;
-};

package/dist/src/views/scheduling/composables/schedule-employee-profile.d.ts

@@ -1,7 +0,0 @@
-import type { Employee } from '../types';
-/** Adds `positionName` to the employee's own profile — the backend write path a real
- * "existing employee" record has (see `useScheduleAddEmployee.ts`'s `toEmployeeProfileFields`
- * for the same shape, built from the add-employee form instead of a live `Employee`).
- * Fire-and-forget: the local roster already shows the grant, and a failed profile write isn't
- * worth a second error dialog on top of whatever caller-side save this followed. */
-export declare function grantSkillToEmployee(emp: Employee, positionName: string): void;

package/dist/src/views/scheduling/composables/schedule-shift-time.d.ts

@@ -1,14 +0,0 @@
-export type ScheduleBreakChoice = 0 | 30 | 60 | 90 | 120 | 'custom';
-export interface ScheduleShiftSegment {
-    start: string;
-    end: string;
-}
-/** A break length that doesn't match one of the presets becomes 'custom', carrying its own
- * minutes/unit back out for the caller to seed its custom-break fields from. */
-export declare function normalizeBreak(mins: number | undefined): {
-    choice: ScheduleBreakChoice;
-    customMins?: number;
-    customUnit?: 'mins' | 'hrs';
-};
-export declare function resolvedBreakMins(choice: ScheduleBreakChoice, customMins: number, customUnit: 'mins' | 'hrs'): number | undefined;
-export declare function segmentHours(seg: ScheduleShiftSegment, breakMins: number): number;

package/dist/src/views/scheduling/composables/schedule-week-cache.d.ts

@@ -1,10 +0,0 @@
-import type { Employee, OpenShift } from '../types';
-export declare const RANGE_LEN = 7;
-export declare function mostRecentMonday(from: Date): Date;
-export declare function weekDates(offset: number): Date[];
-export declare function weeksBetween(a: Date, b: Date): number;
-export interface WeekBucket {
-    employees: Employee[];
-    openShifts: OpenShift[];
-}
-export declare function weekData(offset: number): WeekBucket;

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

@@ -1,86 +0,0 @@
-import type { Employee } from '../types';
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import { type ScheduleAddEmployeeMode, type ScheduleAddEmployeeStep } from './schedule-add-employee-form';
-export type { ScheduleAddEmployeeForm, ScheduleAddEmployeeMode, ScheduleAddEmployeeStep, } from './schedule-add-employee-form';
-/** Add-employee wizard: a "how do you want to add them" step, then one detail form covering
- * identity, locations, pay, scheduling caps, availability, positions and POS access — plus
- * the "select existing POS staff" side dialog the first step can hand off to. */
-export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
-    open: import("vue").Ref<boolean, boolean>;
-    selectExistingOpen: import("vue").Ref<boolean, boolean>;
-    step: import("vue").Ref<ScheduleAddEmployeeStep, ScheduleAddEmployeeStep>;
-    mode: import("vue").Ref<ScheduleAddEmployeeMode, ScheduleAddEmployeeMode>;
-    form: {
-        name: string;
-        mobile: string;
-        dial: string;
-        employment: "full" | "part";
-        locations: string[];
-        payBasis: "hourly" | "monthly";
-        payAmount: string;
-        maxHours: string;
-        otAfterDaily: string;
-        maxOtHours: string;
-        availDays: boolean[];
-        availHours: {
-            from: string;
-            to: string;
-        }[];
-        preferences: string;
-        primaryPosition: string;
-        secondaryPositions: string[];
-        seniority: "" | "senior" | "junior";
-        passcode: string[];
-        masterUser: boolean;
-    };
-    sectionId: import("vue").Ref<string, string>;
-    isEditing: import("vue").ComputedRef<boolean>;
-    locOpen: import("vue").Ref<boolean, boolean>;
-    secOpen: import("vue").Ref<boolean, boolean>;
-    secondaryOptions: import("vue").ComputedRef<string[]>;
-    isPart: import("vue").ComputedRef<boolean>;
-    dayLit: (i: number) => boolean;
-    avLabel: import("vue").ComputedRef<"Weekly availability" | "Time off days">;
-    avAllLabel: import("vue").ComputedRef<"Clear all" | "Select all" | "No days off" | "Every day off">;
-    maxHoursPlaceholder: import("vue").ComputedRef<"Hours per week" | "No cap">;
-    otAfterDailyPlaceholder: import("vue").ComputedRef<string>;
-    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
-    effectiveRate: import("vue").ComputedRef<number>;
-    passcodeValue: import("vue").ComputedRef<string>;
-    passcodeOk: import("vue").ComputedRef<boolean>;
-    footerHint: import("vue").ComputedRef<"Pick who — this outlet's own pay, position and hours are still set here." | "One short form. Rest days are set on their profile afterwards.">;
-    primaryRoleLabel: import("vue").ComputedRef<string>;
-    locationsSummary: import("vue").ComputedRef<string>;
-    payLine: import("vue").ComputedRef<string>;
-    nameError: import("vue").ComputedRef<boolean>;
-    passError: import("vue").ComputedRef<boolean>;
-    availabilityError: import("vue").ComputedRef<boolean>;
-    saving: import("vue").Ref<boolean, boolean>;
-    saveError: import("vue").Ref<string | null, string | null>;
-    candidatesLoading: import("vue").Ref<boolean, boolean>;
-    candidatesError: import("vue").Ref<string | null, string | null>;
-    openWizard: (section: string) => void;
-    openEditFor: (emp: Employee) => void;
-    close: () => void;
-    setMode: (m: ScheduleAddEmployeeMode) => void;
-    openSelectExisting: () => void;
-    closeSelectExisting: () => void;
-    pickExisting: (employeeId: string) => void;
-    next: () => void;
-    back: () => void;
-    toggleMulti: (which: "loc" | "sec") => void;
-    toggleLocation: (loc: string) => void;
-    removeLocation: (loc: string) => void;
-    toggleSecondary: (pos: string) => void;
-    removeSecondary: (pos: string) => void;
-    setPrimaryPosition: (pos: string) => void;
-    setPayBasis: (basis: "hourly" | "monthly") => void;
-    toggleAvailDay: (i: number) => void;
-    availAll: () => void;
-    setAvailHour: (i: number, field: "from" | "to", value: string) => void;
-    copyAvailHourDown: (i: number) => void;
-    setPasscodeDigit: (i: number, value: string) => void;
-    generatePasscode: () => void;
-    create: () => Promise<boolean>;
-};
-export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -1,66 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { ScheduleDemandApi } from './useScheduleDemand';
-export interface ScheduleAddPickState {
-    open: boolean;
-    empId: number | null;
-    dayIdx: number | null;
-    left: number;
-    /** Only one of `top`/`bottom` is live at a time, picked by `openAbove` — anchoring from the
-     * bottom when flipped up lets the box grow with its own content (the query input plus
-     * however many pick-list rows there are) instead of a height guessed in JS. */
-    top: number;
-    bottom: number;
-    openAbove: boolean;
-}
-export interface ScheduleAddPickLeaveOption {
-    reason: string;
-    swatch: string;
-}
-export interface ScheduleAddPickSuggestion {
-    start: string;
-    end: string;
-    short: number;
-    label: string;
-    title: string;
-}
-/** The "+ Add" quick-pick popover on an employee's empty cell — ported from the mockup's
- * openAddShiftPicker()/renderAddPickList(), scoped to what this board actually has: our one
- * active shift pattern, a fixed leave-reason list, and a demand-gap suggestion, all committed
- * directly (no clash confirmation dialogs — this board has no such infrastructure yet, and none
- * of its existing write paths gate on one either). Leave picks write a full-day approved leave
- * immediately rather than opening a creation form — there's no "book a leave" authoring flow
- * anywhere in this port yet, only the existing pending-request review modal, which assumes the
- * leave already exists. The mockup's "On this day" (join an existing open-shift group) section is
- * left out — it needs split-shift/group-joining machinery this board doesn't model. */
-export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: ScheduleDemandApi, handlers: {
-    onCommitted: (message: string) => void;
-    onOpenFullEditor: (empId: number, dayIdx: number) => void;
-}): {
-    state: {
-        open: boolean;
-        empId: number | null;
-        dayIdx: number | null;
-        left: number;
-        top: number;
-        bottom: number;
-        openAbove: boolean;
-    };
-    query: import("vue").Ref<string, string>;
-    parsedRange: import("vue").ComputedRef<{
-        start: string;
-        end: string;
-    } | null>;
-    suggested: import("vue").ComputedRef<ScheduleAddPickSuggestion | null>;
-    filteredPatterns: import("vue").ComputedRef<import("../types").ShiftTemplate[]>;
-    filteredLeaves: import("vue").ComputedRef<ScheduleAddPickLeaveOption[]>;
-    hasResults: import("vue").ComputedRef<boolean>;
-    openFor: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
-    close: () => void;
-    pickSuggested: () => void;
-    pickPattern: (key: string) => void;
-    pickTypedRange: (start: string, end: string) => void;
-    pickLeave: (reason: string) => void;
-    submitQuery: () => void;
-    openBlank: () => void;
-};
-export type ScheduleAddPickApi = ReturnType<typeof useScheduleAddPick>;

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

@@ -1,77 +0,0 @@
-import type { Employee, OpenShift } from '../types';
-import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ScheduleShiftPart {
-    start: string;
-    end: string;
-}
-/** One shift on the All-shifts row, whichever way it was authored. A split shift is ONE
- * entry carrying both of its periods — two periods one person works is one shift, and
- * counting it twice made a day of three split shifts report as six. */
-export interface ScheduleRowEntry {
-    /** Stable across redraws, so the row can be keyed on it. */
-    key: string;
-    kind: 'open' | 'emp';
-    /** The demand record this came from, when it came from one. */
-    open?: OpenShift;
-    /** Whoever holds it, or null while it is still asking for somebody. */
-    who: Employee | null;
-    parts: ScheduleShiftPart[];
-    position: string;
-    /** A shift with a name of its own ("Weekend cover"), distinct from its position. */
-    label?: string;
-    filled: boolean;
-    hours: number;
-}
-export interface ScheduleStackState {
-    open: boolean;
-    dayIdx: number | null;
-    left: number;
-    top: number;
-}
-/** The "Open shifts" row: a pseudo-row above the people holding the shifts nobody is on yet.
- *
- * It used to be the "All shifts" row and it used to LEAD this view, carrying every shift on
- * the day whichever way it was authored. The coverage band has both of those now — and the
- * band measures something this row could not, because a shift with nobody on it contributes
- * zero to coverage, so counting untaken records was never an answer to "is this week staffed".
- *
- * What is left is the job only this row can do. An unassigned shift has no person, so the
- * employee rows have nowhere to draw it; the old row would have shown it alongside every
- * other shift, which is the same cards twice — once here and once on the row of whoever is on
- * them. So the subject narrows to the shifts still waiting for somebody, and the row renders
- * only while at least one exists. That makes it a to-do list rather than furniture: it appears
- * when you author open demand and disappears the moment the last of it is staffed, which is
- * the completion signal the old row had to paint itself green to fake. */
-export declare function useScheduleAllShiftsRow(board: ScheduleBoardApi): {
-    dayEntries: (dayIdx: number) => ScheduleRowEntry[];
-    dayStack: (dayIdx: number) => {
-        entries: ScheduleRowEntry[];
-        done: number;
-        total: number;
-        hours: number;
-        allOpen: boolean;
-        mixShown: {
-            name: string;
-            n: number;
-        }[];
-        mixRest: number;
-        title: string;
-    };
-    summary: import("vue").ComputedRef<{
-        count: number;
-        meta: string;
-        tip: string;
-    }>;
-    hasPending: import("vue").ComputedRef<boolean>;
-    stack: {
-        open: boolean;
-        dayIdx: number | null;
-        left: number;
-        top: number;
-    };
-    stackEntries: import("vue").ComputedRef<ScheduleRowEntry[]>;
-    openStack: (dayIdx: number, anchor: HTMLElement) => void;
-    closeStack: () => void;
-    whenOf: (e: ScheduleRowEntry) => string;
-};
-export type ScheduleAllShiftsRowApi = ReturnType<typeof useScheduleAllShiftsRow>;

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

@@ -1,50 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { Employee, WorkSlot } from '../types';
-export interface ScheduleAssignedSlot {
-    emp: Employee;
-    slot: WorkSlot;
-}
-export interface SchedulePositionCellMeta {
-    required: number;
-    filled: number;
-    open: number;
-    short: number;
-}
-/** Shared by the week and day area views, so a position's colour never disagrees between them. */
-export declare function positionSwatchClass(position: string): string;
-/** Whether this employee can be put on `position` — ported from the mockup's qualifiedFor().
- * Nobody having a named position yet reads as "any station", the same way an unspecialised
- * new-account roster does in the reference: rostering shouldn't be blocked on the Positions
- * page being filled in first. */
-export declare function qualifiedFor(emp: Employee, position: string): boolean;
-/** Week-by-area grouping: rows are positions (a RULES.coverage.full key), not employees.
- * Ported from the mockup's positionRows()/renderPositionBlock() — scoped to this board's single
- * "Unassigned" section and its existing WorkSlot/OpenShift model, so no split shifts and
- * no locked/closed-day states (neither exists anywhere in this port yet). */
-export declare function useScheduleAreaBoard(board: ScheduleBoardApi): {
-    positionRows: import("vue").ComputedRef<string[]>;
-    assignedOn: (dayIdx: number, position: string) => ScheduleAssignedSlot[];
-    unfilledOpenShiftsOn: (dayIdx: number, position: string) => {
-        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;
-    }[];
-    poolFor: (position: string) => Employee[];
-    cellMeta: (dayIdx: number, position: string) => SchedulePositionCellMeta;
-    positionWeekMeta: (position: string) => {
-        required: number;
-        filled: number;
-        open: number;
-        short: number;
-        pool: number;
-    };
-};
-export type ScheduleAreaBoardApi = ReturnType<typeof useScheduleAreaBoard>;

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

@@ -1,18 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
-/** Dragging a person from the staff rail onto a position/day cell — ported from the mockup's
- * dropStaffOnCell(), scoped to this board's model (no "unspecialised, so ask what they can
- * do" grant flow, no split shifts): dropping fills an existing open shift for that position/day
- * if there is one, otherwise opens the shift editor pre-filled with this person, day and
- * position so the manager sets the hours. */
-export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, handlers: {
-    onFillOpenShift: (openId: number, empId: number) => void;
-    onCreateShift: (empId: number, dayIdx: number, position: string) => void;
-    onNotQualified: (empName: string, position: string) => void;
-}): {
-    draggingEmpId: import("vue").Ref<number | null, number | null>;
-    startRailDrag: (empId: number) => void;
-    endRailDrag: () => void;
-    dropOnCell: (dayIdx: number, position: string) => void;
-};
-export type ScheduleAreaDragDropApi = ReturnType<typeof useScheduleAreaDragDrop>;

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

@@ -1,113 +0,0 @@
-import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { ScheduleClashDetectionApi } from './useScheduleClashDetection';
-import type { ScheduleDemandApi } from './useScheduleDemand';
-/** What this sitting is trying to fill — an on-screen open-shift row (never backed by a
- * persisted Shift doc; `openShiftId` only ever identifies it within this session) or a raw
- * demand gap. Either way the assignment created is a plain one-off, same shape as the +Add
- * popover's — nothing here carries a shift/assignment linkage back to the server. */
-export interface ScheduleAssignTarget {
-    dayIdx: number;
-    position: string;
-    start: string;
-    end: string;
-    breakMins?: number;
-    openShiftId?: number;
-}
-export interface ScheduleAssignState {
-    open: boolean;
-    target: ScheduleAssignTarget | null;
-    /** How many heads this sitting is answering, and how many it has landed so far — the
-     * footer's "N still needed" note. Tracked locally rather than re-derived from
-     * `demand.coverageSegments` on every assign: a fresh assign can reshape segment boundaries
-     * entirely (met/short is a function of ALL current coverage, not just this one target), so a
-     * simple running count is the honest thing to show without re-deriving segment math here. */
-    required: number;
-    scheduled: number;
-}
-/** `free` — no shift that day, the ordinary case. `busy` — has a shift, but this is the
- * manager's call to override (soft clash, asks first). `leave` — approved leave, a hard block:
- * inert, not something a second tap should be able to push past. `mine` — already the one
- * filling THIS open shift; only meaningful when the target has an `openShiftId` (a demand gap
- * has no single "holder"), and the tile becomes the unassign control instead. */
-export type ScheduleAssignTileState = 'free' | 'busy' | 'leave' | 'mine';
-export interface ScheduleAssignTile {
-    id: number;
-    name: string;
-    initials: string;
-    weekHours: number;
-    cap: number;
-    over: boolean;
-    state: ScheduleAssignTileState;
-    title: string;
-}
-export interface ScheduleAssignGroup {
-    label: string;
-    tiles: ScheduleAssignTile[];
-}
-/** One entry in the day's shift rail — either the thing this sitting was opened to answer (the
- * ORIGIN, always first), or another shift already on the same day, so a manager can jump to
- * reassigning it without leaving the panel. Every entry is a `target` the tile grid can be
- * pointed at via `switchTo`. */
-export interface ScheduleAssignSlot {
-    key: string;
-    position: string;
-    start: string;
-    end: string;
-    chip: string;
-    full: boolean;
-    sub: string;
-    who: string;
-    whoNone: boolean;
-    on: boolean;
-    target: ScheduleAssignTarget;
-    required: number;
-    scheduled: number;
-}
-/** Assign panel — the one modal both the open-shifts row and a demand gap's "Assign employee"
- * button open, per the reference's own note that they are "the same assign panel". Every pick
- * lands immediately (through the canonical `commitShift` mutator, so it persists exactly like
- * any other assignment); a soft clash — the person already has a shift that day — asks first via
- * the shared clash-confirmation dialog, and approved leave is a hard block the tile itself
- * refuses rather than asking about. */
-export declare function useScheduleAssign(board: ScheduleBoardApi, demand: ScheduleDemandApi, clash: ScheduleClashDetectionApi): {
-    state: {
-        open: boolean;
-        target: {
-            dayIdx: number;
-            position: string;
-            start: string;
-            end: string;
-            breakMins?: number | undefined;
-            openShiftId?: number | undefined;
-        } | null;
-        required: number;
-        scheduled: number;
-    };
-    search: import("vue").Ref<string, string>;
-    activeOpenShift: import("vue").ComputedRef<{
-        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;
-    } | null>;
-    title: import("vue").ComputedRef<string>;
-    sub: import("vue").ComputedRef<string>;
-    footLead: import("vue").ComputedRef<string>;
-    footRest: import("vue").ComputedRef<string>;
-    groups: import("vue").ComputedRef<ScheduleAssignGroup[]>;
-    shiftSlots: import("vue").ComputedRef<ScheduleAssignSlot[]>;
-    switchTo: (slot: ScheduleAssignSlot) => void;
-    openFor: (openShiftId: number) => void;
-    openForGap: (dayIdx: number, position: string, start: string, end: string, required: number, scheduled: number, gapFrom: number, gapTo: number) => void;
-    close: () => void;
-    fillOpenShift: (openShiftId: number, empId: number) => void;
-    armAssign: (empId: number) => void;
-};
-export type ScheduleAssignApi = ReturnType<typeof useScheduleAssign>;