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

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

@@ -0,0 +1,202 @@
+import type { Employee } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleCardMenuState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    /** Which period on that day the menu was opened from — the card's own slot index. */
+    slotIndex: number;
+    left: number;
+    top: number;
+}
+export interface ScheduleChangeState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    slotIndex: number;
+}
+export interface ScheduleSwapState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    /** Which period of `dayIdx` is actually being traded — a sibling shift on that same day
+     * stays with its owner untouched. */
+    slotIndex: number;
+    /** How many periods starting at `slotIndex` go together — a genuine split's own period
+     * count, so dragging its one merged card trades the whole shift; 1 for anything else. */
+    slotCount: number;
+    /** Set when the swap came from dropping one shift on another: that shift is the only choice. */
+    preset: {
+        empId: number;
+        dayIdx: number;
+    } | null;
+}
+/** The shift card's "⋯" menu (Change employee / Swap shifts / Edit / Remove), plus the two
+ * dialogs it opens that the rest of Phase 1 didn't need: handing a shift to somebody else,
+ * and trading two people's shifts on the same day. Both skip the mockup's OT/pay-band cost
+ * preview and hard/soft override tiers — this board has no per-person pay bands to price
+ * against, so a candidate is either qualified-and-free or it isn't offered at all. */
+export declare function useScheduleShiftActions(board: ScheduleBoardApi): {
+    menu: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        slotIndex: number;
+        left: number;
+        top: number;
+    };
+    openMenu: (empId: number, dayIdx: number, anchor: HTMLElement, slotIndex?: number) => void;
+    closeMenu: () => void;
+    change: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        slotIndex: number;
+    };
+    changeSlot: import("vue").ComputedRef<import("../types").WorkSlot[]>;
+    changeCandidates: import("vue").ComputedRef<{
+        id: number;
+        name: string;
+        employmentType: "FULLTIME" | "PARTTIME";
+        role: string;
+        initials: string;
+        color: string;
+        weekHours: number;
+        pct: number;
+        contractHours?: number | undefined;
+        rate: number;
+        positions: string[];
+        shifts: ({
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
+            assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            requestId?: string | undefined;
+            type?: "OFF_DAY" | "LEAVE" | undefined;
+            leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | {
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
+            assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
+        }[] | null)[];
+        remarks: {
+            author: string;
+            date: string;
+            type: "note" | "warning" | "praise";
+            text: string;
+        }[];
+        section: string;
+        compGroup?: string | undefined;
+        mobile?: string | undefined;
+        dial?: string | undefined;
+        locations?: string[] | undefined;
+        payBasis?: "hourly" | "monthly" | undefined;
+        payAmount?: number | undefined;
+        maxHours?: number | undefined;
+        maxOtHours?: number | undefined;
+        minHours?: number | undefined;
+        otAfterDaily?: number | undefined;
+        preferences?: string[] | undefined;
+        seniority?: "senior" | "junior" | "" | undefined;
+        availDays?: boolean[] | undefined;
+        availHours?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+        passcode?: string | undefined;
+        masterUser?: boolean | undefined;
+    }[]>;
+    openChange: (empId: number, dayIdx: number, slotIndex?: number) => void;
+    closeChange: () => void;
+    confirmChange: (toId: number) => void;
+    swap: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        slotIndex: number;
+        slotCount: number;
+        preset: {
+            empId: number;
+            dayIdx: number;
+        } | null;
+    };
+    swapSlot: import("vue").ComputedRef<import("../types").WorkSlot[]>;
+    swapCandidates: import("vue").ComputedRef<{
+        emp: Employee;
+        dayIdx: number;
+        slot: import("../types").WorkSlot[];
+        soft: string | null;
+    }[]>;
+    swapPreset: import("vue").ComputedRef<{
+        emp: Employee;
+        dayIdx: number;
+        slot: import("../types").WorkSlot[];
+        soft: string | null;
+    } | null>;
+    openSwap: (empId: number, dayIdx: number, preset?: ScheduleSwapState["preset"], slotIndex?: number, slotCount?: number) => void;
+    closeSwap: () => void;
+    confirmSwap: (toEmpId: number, toDayIdx: number) => void;
+    removeShift: (empId: number, dayIdx: number, slotIndex?: number) => void;
+};
+export type ScheduleShiftActionsApi = ReturnType<typeof useScheduleShiftActions>;

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

@@ -0,0 +1,209 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleBreakChoice, type ScheduleShiftSegment } from './schedule-shift-time';
+export type { ScheduleBreakChoice, ScheduleShiftSegment } from './schedule-shift-time';
+export interface ScheduleHeadcountRole {
+    position: string;
+    count: number;
+    sen: '' | 'senior' | 'junior';
+}
+/** The unified shift popover — ported from the mockup's single `.shift-pop`, which answers
+ * both "who is on this shift" and "what does this shift need" from one form. Picking a real
+ * person in the `who` select turns it into an assignment; leaving it on "Empty shift" turns
+ * it into open demand. Opened three ways: for an employee's cell (assign/edit), for a brand
+ * new open shift (multi-position headcount authoring), or to edit one existing open-shift
+ * record (single position, like an assigned shift's "Position needed" row). */
+export declare function useScheduleShiftPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    open: import("vue").Ref<boolean, boolean>;
+    dayIdx: import("vue").Ref<number | null, number | null>;
+    empId: import("vue").Ref<number | null, number | null>;
+    originalEmpId: import("vue").Ref<number | null, number | null>;
+    editingOpenShiftId: import("vue").Ref<number | null, number | null>;
+    isNew: import("vue").Ref<boolean, boolean>;
+    name: import("vue").Ref<string, string>;
+    segments: import("vue").Ref<{
+        start: string;
+        end: string;
+    }[], ScheduleShiftSegment[] | {
+        start: string;
+        end: string;
+    }[]>;
+    role: import("vue").Ref<string, string>;
+    required: import("vue").Ref<number, number>;
+    sen: import("vue").Ref<"" | "senior" | "junior", "" | "senior" | "junior">;
+    empType: import("vue").Ref<"" | "full" | "part", "" | "full" | "part">;
+    roles: import("vue").Ref<{
+        position: string;
+        count: number;
+        sen: "" | "senior" | "junior";
+    }[], ScheduleHeadcountRole[] | {
+        position: string;
+        count: number;
+        sen: "" | "senior" | "junior";
+    }[]>;
+    impact: import("vue").ComputedRef<{
+        when: string;
+        pctBefore: number;
+        pctAfter: number;
+        stillShort: number;
+        before: {
+            required: number;
+            scheduled: number;
+        };
+        after: {
+            required: number;
+            scheduled: number;
+        };
+        beforeSegs: import("../types").CoverageSegment[];
+        afterSegs: import("../types").CoverageSegment[];
+        axis: import("./useScheduleDemand").ScheduleCoverageAxis;
+    } | null>;
+    requiresAssignment: import("vue").ComputedRef<boolean>;
+    saveDisabled: import("vue").ComputedRef<boolean>;
+    saveTitle: import("vue").ComputedRef<"" | "Choose who covers it — this shift is answering a staffing gap, and a shift with nobody on it leaves that gap exactly as it is">;
+    saveLabel: import("vue").ComputedRef<"Create & assign" | "Save">;
+    breakChoice: import("vue").Ref<ScheduleBreakChoice, ScheduleBreakChoice>;
+    breakCustomMins: import("vue").Ref<number, number>;
+    breakCustomUnit: import("vue").Ref<"mins" | "hrs", "mins" | "hrs">;
+    breakMode: import("vue").Ref<"time" | "duration", "time" | "duration">;
+    breakStartTime: import("vue").Ref<string, string>;
+    breakEndTime: import("vue").Ref<string, string>;
+    repeatDays: import("vue").Ref<boolean[], boolean[]>;
+    gapNote: import("vue").Ref<string | null, string | null>;
+    conflictNote: import("vue").Ref<string | null, string | null>;
+    grantSkill: import("vue").Ref<boolean, boolean>;
+    showGrantSkill: import("vue").ComputedRef<boolean>;
+    unassignMode: import("vue").Ref<boolean, boolean>;
+    positionOptions: import("vue").ComputedRef<string[]>;
+    whoOptions: import("vue").ComputedRef<{
+        id: number;
+        name: string;
+        employmentType: "FULLTIME" | "PARTTIME";
+        role: string;
+        initials: string;
+        color: string;
+        weekHours: number;
+        pct: number;
+        contractHours?: number | undefined;
+        rate: number;
+        positions: string[];
+        shifts: ({
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
+            assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            requestId?: string | undefined;
+            type?: "OFF_DAY" | "LEAVE" | undefined;
+            leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+            appliedOn?: string | undefined;
+            note?: string | undefined;
+            cert?: {
+                name: string;
+                size: string;
+            } | null | undefined;
+            bal?: {
+                type: string;
+                entitled: number;
+                used: number;
+            } | undefined;
+        } | {
+            start: string;
+            end: string;
+            role: string;
+            status: import("../types").ShiftStatus;
+            clock?: {
+                in: string | null;
+                out: string | null;
+                status: "on-time" | "late" | "early-out" | "absent";
+            } | undefined;
+            conflict?: boolean | undefined;
+            conflictReason?: string | undefined;
+            openId?: number | undefined;
+            breakMins?: number | undefined;
+            breaks?: ({
+                type: "DURATION";
+                minutes: number;
+                breakPayType: "PAID" | "UNPAID";
+            } | {
+                type: "TIME_RANGE";
+                startTime: string;
+                endTime: string;
+                breakPayType: "PAID" | "UNPAID";
+            })[] | undefined;
+            assignmentId?: string | undefined;
+            splitGroupId?: string | undefined;
+        }[] | null)[];
+        remarks: {
+            author: string;
+            date: string;
+            type: "note" | "warning" | "praise";
+            text: string;
+        }[];
+        section: string;
+        compGroup?: string | undefined;
+        mobile?: string | undefined;
+        dial?: string | undefined;
+        locations?: string[] | undefined;
+        payBasis?: "hourly" | "monthly" | undefined;
+        payAmount?: number | undefined;
+        maxHours?: number | undefined;
+        maxOtHours?: number | undefined;
+        minHours?: number | undefined;
+        otAfterDaily?: number | undefined;
+        preferences?: string[] | undefined;
+        seniority?: "senior" | "junior" | "" | undefined;
+        availDays?: boolean[] | undefined;
+        availHours?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+        passcode?: string | undefined;
+        masterUser?: boolean | undefined;
+    }[]>;
+    isAssigned: import("vue").ComputedRef<boolean>;
+    isReleasingToOpen: import("vue").ComputedRef<boolean>;
+    isEditingOpenShift: import("vue").ComputedRef<boolean>;
+    isNewOpenShift: import("vue").ComputedRef<boolean>;
+    isSingleOpenRecord: import("vue").ComputedRef<boolean>;
+    totalHours: import("vue").ComputedRef<number>;
+    totalLabel: import("vue").ComputedRef<string>;
+    warnings: import("vue").ComputedRef<string[]>;
+    openForEmployee: (forEmpId: number, day: number, roleHint?: string, hours?: ScheduleShiftSegment, slotIndex?: number) => void;
+    openForNewOpenShift: (day: number, roleHint?: string, hours?: ScheduleShiftSegment) => void;
+    openForEditOpenShift: (openShiftId: number) => void;
+    close: () => void;
+    removeSegment: (i: number) => void;
+    addRole: () => void;
+    removeRole: (i: number) => void;
+    save: () => void;
+    remove: () => void;
+};
+export type ScheduleShiftPopoverApi = ReturnType<typeof useScheduleShiftPopover>;

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

@@ -0,0 +1,17 @@
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
+/** The rail's rows ARE the shared identity block's data — one derivation, so the rail and the
+ * employee grid's name column can't disagree about somebody's load. */
+export type ScheduleRailRow = ScheduleEmployeeLoad;
+/** The area view's staff rail — least-loaded first over the same roster the employee view's
+ * name column shows, plus each person's load bar. Search and the sort picker both live in the
+ * filter bar / name column now, not here. Ported from the mockup's
+ * renderStaffRail()/orderedRoster()/staffLoad(), scoped to a single week (no day/area
+ * combination — Daily view stays employee-only for now). */
+export declare function useScheduleStaffRail(board: ScheduleBoardApi, 
+/** Lazy: the auto-scheduler is built after the rail, and only read when rows are computed. */
+proposalAt?: () => ((empId: number, dayIdx: number) => Proposal | undefined) | undefined): {
+    rows: import("vue").ComputedRef<ScheduleEmployeeLoad[]>;
+};
+export type ScheduleStaffRailApi = ReturnType<typeof useScheduleStaffRail>;

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

@@ -0,0 +1,24 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleCostRailApi } from './useScheduleCostRail';
+import type { useScheduleLegend } from './useScheduleLegend';
+/** The collapsible weekly-summary band under the day header: totals when collapsed,
+ * a per-day cost/hours/forecast breakdown when open. Ported from the mockup's
+ * buildStatsRow() — the band always mirrors whatever days the grid currently shows
+ * (board.visibleDayIndices), collapsing to one day's figures in Daily view exactly like
+ * the reference's renderedDays()-scoped totals. The 7-day RULES.salesForecast/SALES_CURVE
+ * baseline underneath it stays weekly regardless — only the on-screen total and the
+ * redistribution on edit are span-scoped. */
+export declare function useScheduleStatsRow(board: ScheduleBoardApi, costRail: ScheduleCostRailApi, legend: ReturnType<typeof useScheduleLegend>): {
+    open: import("vue").Ref<boolean, boolean>;
+    toggle: () => void;
+    forecast: import("vue").Ref<number, number>;
+    visibleForecast: import("vue").ComputedRef<number>;
+    visibleCost: import("vue").ComputedRef<number>;
+    visibleHours: import("vue").ComputedRef<number>;
+    salesFor: (dayIdx: number) => number;
+    isDayOverridden: (dayIdx: number) => boolean;
+    setDayForecast: (dayIdx: number, value: string) => void;
+    labourPct: (dayIdx: number) => number | null;
+    isShort: (dayIdx: number) => boolean;
+};
+export type ScheduleStatsRowApi = ReturnType<typeof useScheduleStatsRow>;

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

@@ -0,0 +1,49 @@
+export interface ScheduleTimePickerOption {
+    value: string;
+    label: string;
+    am: boolean;
+    sel: boolean;
+    typed: boolean;
+    /** An existing value that doesn't land on the half hour — kept in the list rather than
+     * snapped, because silently moving somebody's 11:20 start is a change to their shift, not
+     * a rounding. */
+    odd: boolean;
+}
+export interface ScheduleTimePickerState {
+    open: boolean;
+    /** The field's own value when the popover opened — what `.sel` marks, and what an off-grid
+     * value gets read from to appear in the list at all. */
+    value: string;
+    query: string;
+    /** Which trigger button opened it, so only that one wears the open state. */
+    key: string;
+    left: number;
+    top: number;
+}
+/** "8:00 AM", "10:15 PM" — the picker's own display face, and the trigger button's label. */
+export declare function formatTime12(hhmm: string): string;
+/** The time-of-day combobox behind every `sp2-time.tp-btn` field on the board (demand periods,
+ * shift segments) — one popover instance shared across all of them, the same way the add-pick
+ * and gap popovers are. Half-hour options grouped AM/PM, plus a type-in field for anything the
+ * grid doesn't land on and a search over the same list. */
+export declare function useScheduleTimePicker(): {
+    state: {
+        open: boolean;
+        value: string;
+        query: string;
+        key: string;
+        left: number;
+        top: number;
+    };
+    options: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    amOptions: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    pmOptions: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    typedValue: import("vue").ComputedRef<string | null>;
+    openFor: (anchor: HTMLElement, value: string, pick: (hhmm: string) => void, key?: string) => void;
+    anchorRect: () => DOMRect | null;
+    isOpenFor: (key: string) => boolean;
+    close: () => void;
+    pick: (value: string) => void;
+    submitQuery: () => void;
+};
+export type ScheduleTimePickerApi = ReturnType<typeof useScheduleTimePicker>;

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

@@ -0,0 +1,10 @@
+export type ScheduleTopbarMenu = 'actions' | 'export';
+/** Open/close state for the topbar's two dropdowns (Actions, Share) — only one is ever open at a
+ * time, matching the mockup's toggleMenu()/closeMenus() behavior of closing the others whenever
+ * one opens. */
+export declare function useScheduleTopbar(): {
+    openMenu: import("vue").Ref<ScheduleTopbarMenu | null, ScheduleTopbarMenu | null>;
+    toggleMenu: (id: ScheduleTopbarMenu) => void;
+    closeMenus: () => void;
+};
+export type ScheduleTopbarApi = ReturnType<typeof useScheduleTopbar>;

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

@@ -0,0 +1,93 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandRowApi } from './useScheduleDemandRow';
+import type { ScheduleDemandSheetApi } from './useScheduleDemandSheet';
+import type { ScheduleGapPopoverApi } from './useScheduleGapPopover';
+import type { ScheduleAutoScheduleApi } from './useScheduleAutoSchedule';
+import type { SchedulePublishApi } from './useSchedulePublish';
+import type { ScheduleExportApi } from './useScheduleExport';
+import type { IntroRecapRow } from './onboarding-types';
+interface TourDeps {
+    board: ScheduleBoardApi;
+    demandRow: ScheduleDemandRowApi;
+    demandSheet: ScheduleDemandSheetApi;
+    gap: ScheduleGapPopoverApi;
+    autoSchedule: ScheduleAutoScheduleApi;
+    publish: SchedulePublishApi;
+    exportApi: ScheduleExportApi;
+    onToast: (message: string) => void;
+}
+/** The guided tour: one coachmark at a time, walking from where demand is set through to
+ * sharing the published week. Ported from V6.2's `OBA_TOUR` / `obaTourGo` — same six stops,
+ * same "open the real surface, then point at it" steps for the demand sheet and the gap
+ * popover. No Back button, matching the source: the only way on is Next or Skip. */
+export declare function useScheduleTour(deps: TourDeps): {
+    coach: {
+        open: import("vue").Ref<boolean, boolean>;
+        placing: import("vue").Ref<boolean, boolean>;
+        tip: import("vue").Ref<{
+            title: string;
+            body: string;
+            count?: string | undefined;
+            nextLabel?: string | undefined;
+            skipLabel?: string | undefined;
+            next?: (() => void) | undefined;
+            skip?: (() => void) | undefined;
+        } | null, import("./useScheduleCoach").CoachTipData | {
+            title: string;
+            body: string;
+            count?: string | undefined;
+            nextLabel?: string | undefined;
+            skipLabel?: string | undefined;
+            next?: (() => void) | undefined;
+            skip?: (() => void) | undefined;
+        } | null>;
+        maskT: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskB: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskL: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskR: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        spot: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        tipPos: {
+            left: number;
+            top: number;
+        };
+        arrow: {
+            side: "top" | "bottom" | "left" | "right";
+            offset: number;
+        };
+        start: (el: HTMLElement, data: import("./useScheduleCoach").CoachTipData, onMiss?: () => void) => void;
+        end: () => void;
+        next: () => void;
+        skip: () => void;
+    };
+    start: () => void;
+    allSetOpen: import("vue").Ref<boolean, boolean>;
+    allSetRecap: import("vue").ComputedRef<IntroRecapRow[]>;
+    closeAllSet: () => void;
+};
+export type ScheduleTourApi = ReturnType<typeof useScheduleTour>;
+export {};

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

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+/** Pins the scheduling screen to the viewport so only the grid scrolls.
+ *
+ * `PortalShell` wraps every route in two unstyled divs, and the height chain above them is the
+ * host app's, not ours: with no definite height anywhere up there, `.sch { height: 100% }` has
+ * nothing to resolve against, the whole page grows to its content and the browser scrolls it —
+ * header rows included. Measuring where the shell starts and giving it the rest of the viewport
+ * is the one thing that does not depend on how the host lays itself out. */
+export declare function useScheduleViewportFit(rootEl: Ref<HTMLElement | null | undefined>): void;