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

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

@@ -0,0 +1,78 @@
+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;
+    minHours: string;
+    /** Overtime is opt-in: off is "no rule", not "zero overtime" — a 0 sitting in the fields
+     * below by default would read as "every hour is overtime", the opposite of unset. */
+    otEnabled: boolean;
+    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;
+    /** Required by the POS for a master user. */
+    masterCode: string;
+    /** Gates the fields below it — someone can be fully scheduled with this off. */
+    posAccessEnabled: boolean;
+    /** WHAT the passcode opens the till as, at this outlet — the one this person is being added
+     * to. The outlet itself isn't a choice here: this wizard is already scoped to it. */
+    posRoleId: string;
+}
+/** 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

@@ -0,0 +1,59 @@
+import type { DaySlot, Employee, LeaveSlot, WorkSlot } from '../types';
+import type { FdtoScheduleSaveAssignmentReq } from '@/types/schedule';
+export { isoDateKey } from './schedule-calendar';
+/** 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 isWorkSlot(slot: DaySlot): slot is WorkSlot;
+export declare function isLeaveSlot(slot: DaySlot): slot is LeaveSlot;
+export declare function workSlotsOf(day: DaySlot): WorkSlot[];
+/** The inverse of `workSlotsOf` — bare slot for one, the array for two or more, so a day
+ * that's back down to its last period reads as a normal single shift again rather than a
+ * one-element array everything else has to unwrap. */
+export declare function collapseSlots(slots: WorkSlot[]): WorkSlot | WorkSlot[] | null;
+/** Whether a day's periods are genuinely one shift split across a gap — same `splitGroupId`,
+ * set only by the popover's "+ Split" — versus two or more independent shifts that happen to
+ * land on the same day (a swap override, say). The card/popover both branch on this: a
+ * genuine split draws and edits as one shift; anything else stays separate, card per shift. */
+export declare function isGenuineSplitGroup(slots: WorkSlot[]): boolean;
+/** A WorkSlot, in the shape ScheduleShiftAssignments 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;
+/** Colour keys off the POSITION's rank in the alphabetical position list, looped every six —
+ * position 7 repeats position 1's colour, which is expected once a page holds more than six.
+ * Unset ("Any position") isn't a real position at all, so it skips the rotation entirely and is
+ * always stone, the one of the seven neutral enough to read as "no position". A role no longer in
+ * the list (e.g. since deleted) falls back to the first band rather than erroring.
+ *
+ * Rotation by name, not a keyword lookup — a position is whatever the outlet typed into the
+ * Positions page, so there's no fixed vocabulary ("cashier", "kitchen", ...) to match against.
+ *
+ * Shared by the employee view's own card and the area view's position-row header + card, so the
+ * same position never disagrees on its colour anywhere on the board. */
+export declare function positionColorClass(role: string): string;
+/** 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-breaks.d.ts

@@ -0,0 +1,9 @@
+import type { FdtoScheduleBreak } from '@/types/schedule';
+import type { WorkSlot } from '../types';
+type BreakSource = FdtoScheduleBreak[] | Pick<WorkSlot, 'breaks' | 'breakMins'> | undefined;
+export declare function breakMinutesOf(source: BreakSource): number;
+/** Net paid minutes. Legacy board slots only have `breakMins`; persisted slots use the richer
+ * break array, so both representations pass through this function. */
+export declare function paidMinutesOf(slot: Pick<WorkSlot, 'start' | 'end' | 'breaks' | 'breakMins'>, gross?: number): number;
+export declare function durationBreaksOf(minutes: number | undefined): FdtoScheduleBreak[];
+export {};

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

@@ -0,0 +1,7 @@
+export declare const RANGE_LEN = 7;
+export declare function isoDateKey(date: Date): string;
+export declare function addDays(date: Date, days: number): Date;
+export declare function mostRecentMonday(from: Date): Date;
+export declare function weekDates(offset: number, from?: Date): Date[];
+export declare function weeksBetween(a: Date, b: Date): number;
+export declare function todayWeekdayIdx(): number;

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

@@ -0,0 +1,19 @@
+import type { Employee, WorkSlot } from '../types';
+export interface ScheduleCostBreakdown {
+    hours: number;
+    overtimeHours: number;
+    baseCost: number;
+    overtimeCost: number;
+    totalCost: number;
+}
+export declare function costOfSlot(slot: WorkSlot, rate: number, multiplier: number): {
+    hours: number;
+    cost: number;
+};
+/** Splits a sequence of paid shift minutes at the employee's contract line. This is the single
+ * overtime/cost calculation used by rails and exports; callers provide the applicable pay rate
+ * multiplier for each slot. */
+export declare function costOfSlots(employee: Employee, slots: Array<{
+    slot: WorkSlot;
+    multiplier: number;
+}>): ScheduleCostBreakdown;

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

@@ -0,0 +1,23 @@
+import type { 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(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;
+    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-demand-domain.d.ts

@@ -0,0 +1,11 @@
+import type { DemandPeriod } from '../types';
+import { format12h as t12, formatShortMinutes as minToShort, fromMinutes as minToHHMM, spanMinutes as spanOf, toMinutes as toMin } from './schedule-time';
+export { minToHHMM, minToShort, spanOf, t12, toMin };
+export declare function rangeText(from: number, to: number): string;
+export declare function roleTotalOf(period: DemandPeriod): number;
+/** The unnamed part of a period's headcount. Derived so it cannot disagree with the total. */
+export declare function anyLeftOf(period: DemandPeriod): number;
+export interface ScheduleCoverageAxis {
+    from: number;
+    to: number;
+}

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

@@ -0,0 +1,7 @@
+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-export-matrix.d.ts

@@ -0,0 +1,14 @@
+export interface ExportShiftCell {
+    note: string;
+    shifts: {
+        when: string;
+        pos: string;
+    }[];
+}
+export declare function esc(value: string | number): string;
+export declare function cellText(value: string | ExportShiftCell): string;
+export declare function dayCellLines(value: ExportShiftCell): {
+    text: string;
+    kind: 'note' | 'when' | 'pos';
+}[];
+export declare function dayHeaderLabel(date: Date): string;

package/dist/src/views/scheduling/composables/schedule-popover-position.d.ts

@@ -0,0 +1,16 @@
+export interface ScheduleAnchorRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** Measures the element a popover was opened from. Takes the rect while the anchor is still on
+ * screen; a hidden or detached element measures 0×0 and counts as "no anchor". */
+export declare function anchorRectOf(el: Element | null | undefined): ScheduleAnchorRect | null;
+/** Port of HRM V6.2 placePopover(): below the anchor by preference (6px gap), flipped above when
+ * there is no room, clamped to the viewport on both edges. Uses the popover's rendered size, so
+ * call it once the element is in the DOM. */
+export declare function placePopover(el: HTMLElement, anchor: ScheduleAnchorRect | null): {
+    left: number;
+    top: number;
+};

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

@@ -0,0 +1,26 @@
+import type { WorkSlot } from '../types';
+export type ScheduleBreakChoice = 0 | 30 | 60 | 90 | 120 | 'custom';
+export interface ScheduleShiftSegment {
+    start: string;
+    end: string;
+}
+/** The one break shape that names a clock window rather than just a duration — when present,
+ * the card reads as two periods around it, each on its own line, instead of one span that
+ * quietly got shorter. Shared by the employee view's own card and the area view's position-row
+ * card, so a TIME_RANGE break draws the same split face wherever a shift is shown. */
+export declare function timeRangeBreakOf(sl: WorkSlot): {
+    startTime: string;
+    endTime: string;
+} | null;
+/** Same face as `t12`, but never drops the minutes — two ranges stacked on a split card need
+ * to line up at a glance, and "10am" next to "10:30am" reads as two different units. */
+export declare function t12Full(hhmm: string): 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-time.d.ts

@@ -0,0 +1,8 @@
+/** Shared clock arithmetic for the scheduling board. All spans are minutes from midnight;
+ * an end at or before the start is treated as an overnight end on the following day. */
+export declare function toMinutes(value: string): number;
+export declare function fromMinutes(value: number): string;
+export declare function spanMinutes(start: string, end: string): [number, number];
+export declare function durationMinutes(start: string, end: string): number;
+export declare function format12h(value: string): string;
+export declare function formatShortMinutes(value: number): string;

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

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

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

@@ -0,0 +1,9 @@
+/** A long list shown as its first few entries plus "+N more", expandable in place. For chip rows
+ * that can run to a hundred items (a person rostered at every outlet), which would otherwise
+ * push the rest of the form off screen. */
+export declare function useCollapsedList<T>(items: () => T[], limit?: number): {
+    expanded: import("vue").Ref<boolean, boolean>;
+    shown: import("vue").ComputedRef<T[]>;
+    hiddenCount: import("vue").ComputedRef<number>;
+    toggle: () => void;
+};

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

@@ -0,0 +1,10 @@
+import { useAppStore } from '@feedmepos/mf-remy-panel';
+export interface RemyActivateOptions {
+    prompt?: string;
+    forceNewConversation?: boolean;
+}
+export interface RemyAppStoreApi {
+    store: ReturnType<typeof useAppStore>;
+    activate: (options: RemyActivateOptions) => Promise<void>;
+}
+export declare function useRemyAppStore(): RemyAppStoreApi;

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

@@ -0,0 +1,102 @@
+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, options?: {
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
+    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;
+        minHours: string;
+        otEnabled: boolean;
+        otAfterDaily: string;
+        maxOtHours: string;
+        availDays: boolean[];
+        availHours: {
+            from: string;
+            to: string;
+        }[];
+        preferences: string;
+        primaryPosition: string;
+        secondaryPositions: string[];
+        seniority: "" | "senior" | "junior";
+        passcode: string[];
+        masterUser: boolean;
+        masterCode: string;
+        posAccessEnabled: boolean;
+        posRoleId: string;
+    };
+    sectionId: import("vue").Ref<string, string>;
+    isEditing: import("vue").ComputedRef<boolean>;
+    editingEmployeeId: import("vue").Ref<number | null, number | null>;
+    locOpen: import("vue").Ref<boolean, boolean>;
+    secOpen: import("vue").Ref<boolean, boolean>;
+    secondaryOptions: import("vue").ComputedRef<string[]>;
+    isPart: import("vue").ComputedRef<boolean>;
+    dayLit: (index: 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>;
+    toggleOt: () => void;
+    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
+    effectiveRate: import("vue").ComputedRef<number>;
+    passcodeValue: import("vue").ComputedRef<string>;
+    passcodeOk: import("vue").ComputedRef<boolean>;
+    currentLocationLabel: import("vue").ComputedRef<string>;
+    locationOptions: import("vue").Reactive<string[]>;
+    masterCodeError: import("vue").ComputedRef<boolean>;
+    isNewUser: 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) => Promise<void>;
+    next: () => void;
+    back: () => void;
+    toggleMulti: (which: "loc" | "sec") => void;
+    toggleLocation: (location: string) => void;
+    removeLocation: (location: string) => void;
+    toggleSecondary: (position: string) => void;
+    removeSecondary: (position: string) => void;
+    setPrimaryPosition: (position: string) => void;
+    setPayBasis: (basis: "hourly" | "monthly") => void;
+    toggleAvailDay: (index: number) => void;
+    availAll: () => void;
+    setAvailHour: (index: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (index: number) => void;
+    setPasscodeDigit: (index: number, value: string) => void;
+    generatePasscode: () => void;
+    togglePosAccess: () => void;
+    setPosRole: (roleId: string) => void;
+    posRoleOptions: import("vue").ComputedRef<import("../../../types/role").Role[]>;
+    create: () => Promise<boolean>;
+};
+export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -0,0 +1,81 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleAnchorRect } from './schedule-popover-position';
+export interface ScheduleAddPickState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    /** Measured rect of the cell the popup opened from; the popup component places itself from it
+     * once rendered (V6.2 placePopover), writing the result to `left`/`top`. */
+    anchor: ScheduleAnchorRect | null;
+    left: number;
+    top: number;
+}
+export interface ScheduleAddPickLeaveOption {
+    reason: string;
+    swatch: string;
+}
+export interface ScheduleAddPickSuggestion {
+    start: string;
+    end: string;
+    short: number;
+    label: string;
+    /** "Covers 16:00–22:00 demand" — the demand this offer answers, shown under the label. */
+    covers: 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, slotIndex: number) => void;
+    /** The leave editor, on this cell. `reason` is the row's own type, or null for the plain "Leave" row. */
+    onOpenLeave: (empId: number, dayIdx: number, reason: string | null) => void;
+}): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        anchor: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        } | null;
+        left: number;
+        top: number;
+    };
+    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<{
+        key: string;
+        label: string;
+        start: string;
+        end: string;
+        color: string;
+        active: boolean;
+        breakMins: number;
+    }[]>;
+    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

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