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

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

@@ -0,0 +1,179 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAddEmployeeApi } from './useScheduleAddEmployee';
+export type ScheduleOnboardingStep = 'positions' | 'pay' | 'staffing' | 'team';
+export declare const STEP_LABELS: Record<ScheduleOnboardingStep, string>;
+/** "Set up scheduling", step by step — four real screens over four already-real pieces
+ * (positions, pay rate, staffing needs, the team), not a fifth new form pretending to be a
+ * summary of them. Shift patterns are deliberately not a step here: `SHIFT_TEMPLATES` has no
+ * authoring UI or backend anywhere in this board yet, and inventing one wasn't what this
+ * wizard was asked to do — see the welcome dialog's own two-option copy, which never promises
+ * a step for it either. */
+export declare function useScheduleOnboardingWizard(board: ScheduleBoardApi, addEmployee: ScheduleAddEmployeeApi): {
+    open: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleOnboardingStep, ScheduleOnboardingStep>;
+    stepIndex: import("vue").ComputedRef<number>;
+    isFirstStep: import("vue").ComputedRef<boolean>;
+    isLastStep: import("vue").ComputedRef<boolean>;
+    totalSteps: number;
+    positions: {
+        positions: import("vue").Ref<{
+            id: string;
+            name: string;
+        }[], import("./useSchedulePositions").SchedulePositionRow[] | {
+            id: string;
+            name: string;
+        }[]>;
+        count: import("vue").ComputedRef<number>;
+        isAdding: import("vue").Ref<boolean, boolean>;
+        newName: import("vue").Ref<string, string>;
+        editingId: import("vue").Ref<string | null, string | null>;
+        editingName: import("vue").Ref<string, string>;
+        pendingDeleteId: import("vue").Ref<string | null, string | null>;
+        saving: import("vue").Ref<boolean, boolean>;
+        error: import("vue").Ref<string | null, string | null>;
+        usageCountFor: (name: string) => number;
+        startAdd: () => void;
+        cancelAdd: () => void;
+        confirmAdd: () => Promise<void>;
+        startEdit: (id: string) => void;
+        cancelEdit: () => void;
+        saveEdit: (id: string) => Promise<void>;
+        askDelete: (id: string) => void;
+        cancelDelete: () => void;
+        confirmDelete: (id: string) => Promise<void>;
+    };
+    settings: {
+        isOpen: import("vue").Ref<boolean, boolean>;
+        activeSection: import("vue").Ref<import("./useScheduleSettings").ScheduleSettingsSection, import("./useScheduleSettings").ScheduleSettingsSection>;
+        draft: {
+            salesForecast: number;
+            labourTarget: number;
+            budgetFromSales: boolean;
+            budget: number;
+            payRate: {
+                NORMAL: {
+                    overtime: number;
+                };
+                REST_DAY: {
+                    regular: number;
+                    overtime: number;
+                };
+                PUBLIC_HOLIDAY: {
+                    regular: number;
+                    overtime: number;
+                };
+            };
+            otCapHours: number;
+            otBudget: number;
+            notify: {
+                waConnected: boolean;
+                waNumber: string;
+                waDisplayName: string;
+                defaults: {
+                    wa: boolean;
+                    push: boolean;
+                    email: boolean;
+                };
+            };
+        };
+        dirty: import("vue").ComputedRef<boolean>;
+        open: (section?: import("./useScheduleSettings").ScheduleSettingsSection) => void;
+        close: () => boolean;
+        discard: () => void;
+        save: () => void;
+    };
+    staffingDays: import("vue").Reactive<boolean[]>;
+    staffingStart: import("vue").Ref<string, string>;
+    staffingEnd: import("vue").Ref<string, string>;
+    staffingCount: import("vue").Ref<number, number>;
+    staffingSaving: import("vue").Ref<boolean, boolean>;
+    staffingError: import("vue").Ref<string | null, string | null>;
+    staffingSaved: import("vue").Ref<boolean, boolean>;
+    employeeCount: import("vue").ComputedRef<number>;
+    addEmployee: {
+        open: import("vue").Ref<boolean, boolean>;
+        selectExistingOpen: import("vue").Ref<boolean, boolean>;
+        step: import("vue").Ref<import("./schedule-add-employee-form").ScheduleAddEmployeeStep, import("./schedule-add-employee-form").ScheduleAddEmployeeStep>;
+        mode: import("vue").Ref<import("./schedule-add-employee-form").ScheduleAddEmployeeMode, import("./schedule-add-employee-form").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: import("../types").Employee) => void;
+        close: () => void;
+        setMode: (m: import("./schedule-add-employee-form").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>;
+    };
+    openWizard: () => void;
+    close: () => void;
+    next: () => void;
+    back: () => void;
+    toggleStaffingDay: (dayIdx: number) => void;
+    submitStaffing: () => Promise<void>;
+    addTeamMember: () => void;
+};
+export type ScheduleOnboardingWizardApi = ReturnType<typeof useScheduleOnboardingWizard>;

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

@@ -0,0 +1,23 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleOpenShiftMenuState {
+    open: boolean;
+    openShiftId: number | null;
+    left: number;
+    top: number;
+}
+/** The open-shift card's "⋯" menu (Assign/Edit/Remove) and its "N can cover" candidate
+ * count — split out from the shift popover itself, since these apply to the card at rest,
+ * not to the form. */
+export declare function useScheduleOpenShiftCard(board: ScheduleBoardApi): {
+    menu: {
+        open: boolean;
+        openShiftId: number | null;
+        left: number;
+        top: number;
+    };
+    openMenu: (openShiftId: number, anchor: HTMLElement) => void;
+    closeMenu: () => void;
+    remove: (openShiftId: number) => void;
+    candidateCountFor: (openShiftId: number) => number;
+};
+export type ScheduleOpenShiftCardApi = ReturnType<typeof useScheduleOpenShiftCard>;

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

@@ -0,0 +1,19 @@
+import type { ScheduleSelectOption } from '../components/ScheduleSelect.vue';
+/** Which outlet the board is scheduling, and the picker that changes it.
+ *
+ * On entry the host shell's own selection wins — mf-common keeps `currentRestaurant` in sync
+ * with the `?restaurantId=` in the URL, so arriving from anywhere else in the portal lands on
+ * the outlet that was already being looked at. Only when the shell has no opinion does this
+ * fall back to the first outlet in the business, which is better than an empty board.
+ *
+ * Switching from the picker deliberately does NOT write back to the shell: the URL is the
+ * shell's to own, and a board that silently repoints the whole portal is doing more than the
+ * control it was clicked on said it would. */
+export declare function useScheduleOutlet(): {
+    options: import("vue").ComputedRef<ScheduleSelectOption[]>;
+    ready: import("vue").Ref<boolean, boolean>;
+    outletId: import("vue").Ref<string, string>;
+    resolve: () => Promise<string>;
+    switchTo: (restaurantId: string, weekStart: Date) => Promise<boolean>;
+};
+export type ScheduleOutletApi = ReturnType<typeof useScheduleOutlet>;

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

@@ -0,0 +1,32 @@
+export interface SchedulePositionRow {
+    id: string;
+    name: string;
+}
+export declare function useSchedulePositions(): {
+    positions: import("vue").Ref<{
+        id: string;
+        name: string;
+    }[], SchedulePositionRow[] | {
+        id: string;
+        name: string;
+    }[]>;
+    count: import("vue").ComputedRef<number>;
+    isAdding: import("vue").Ref<boolean, boolean>;
+    newName: import("vue").Ref<string, string>;
+    editingId: import("vue").Ref<string | null, string | null>;
+    editingName: import("vue").Ref<string, string>;
+    pendingDeleteId: import("vue").Ref<string | null, string | null>;
+    saving: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    usageCountFor: (name: string) => number;
+    startAdd: () => void;
+    cancelAdd: () => void;
+    confirmAdd: () => Promise<void>;
+    startEdit: (id: string) => void;
+    cancelEdit: () => void;
+    saveEdit: (id: string) => Promise<void>;
+    askDelete: (id: string) => void;
+    cancelDelete: () => void;
+    confirmDelete: (id: string) => Promise<void>;
+};
+export type SchedulePositionsApi = ReturnType<typeof useSchedulePositions>;

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

@@ -0,0 +1,91 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleVersion } from '../types';
+export interface VersionDiffRow {
+    name: string;
+    day: string;
+    kind: 'add' | 'rem' | 'chg';
+    from: string | null;
+    to: string | null;
+}
+/** The mockup's Publish modal (openPublish/renderPublish/confirmPublish) — draft vs. published
+ * stamps, a conflict-acknowledgement gate, the pending-change list, and per-version diffing
+ * against the previous version. The mockup's WhatsApp/push/email notify-channel block is not
+ * ported: it depends on per-employee notification-preference data that doesn't exist anywhere
+ * in this mock model, and building it would mean inventing a whole notification-preferences
+ * concept with no other consumer — publish here just publishes. */
+export declare function useSchedulePublish(board: ScheduleBoardApi): {
+    isOpen: import("vue").Ref<boolean, boolean>;
+    pubAcked: import("vue").Ref<boolean, boolean>;
+    showAllVersions: import("vue").Ref<boolean, boolean>;
+    expandedVersion: import("vue").Ref<number | null, number | null>;
+    open: () => void;
+    close: () => void;
+    conflicts: import("vue").ComputedRef<number>;
+    confirmDisabled: import("vue").ComputedRef<boolean>;
+    visibleVersions: import("vue").ComputedRef<{
+        v: number;
+        at: Date;
+        by: string;
+        note: string;
+        changeCount: number;
+        staffAffected: number;
+        snapshot: {
+            id: number;
+            name: string;
+            weekHours: number;
+            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;
+                assignmentId?: string | undefined;
+            } | {
+                timeOff: "approved" | "pending";
+                reason: string;
+                half?: boolean | undefined;
+                halfPart?: "AM" | "PM" | 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;
+                assignmentId?: string | undefined;
+            }[] | null)[];
+        }[];
+    }[]>;
+    toggleAllVersions: () => void;
+    toggleVersionDiff: (v: number) => void;
+    diffFor: (version: ScheduleVersion) => VersionDiffRow[];
+    confirm: () => void;
+    restoreVersion: (v: number) => void;
+};
+export type SchedulePublishApi = ReturnType<typeof useSchedulePublish>;

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

@@ -0,0 +1,18 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** Range-calendar popover behind the topbar's date label — month grid + Today/This
+ * week/Next week presets, matching the mockup's range calendar. */
+export declare function useScheduleRangeCalendar(board: ScheduleBoardApi): {
+    open: import("vue").Ref<boolean, boolean>;
+    toggle: () => void;
+    close: () => void;
+    cursorMonth: import("vue").Ref<Date, Date>;
+    shiftMonth: (delta: number) => void;
+    monthLabel: import("vue").ComputedRef<string>;
+    calendarDays: import("vue").ComputedRef<{
+        date: Date | null;
+    }[]>;
+    isInRange: (date: Date) => boolean;
+    pickDate: (date: Date) => void;
+    presetToday: () => void;
+    presetNextWeek: () => void;
+};

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

@@ -0,0 +1,183 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** The employee grid's own row list — search-filtered, in the roster's own order.
+ *
+ * Ported from the mockup's getSorted()/EMP_ORDER. The grid's rows are the axis you edit along,
+ * so load-sorting them (the way the area view's staff rail does) meant every assignment moved
+ * that person down the list — the row you just used slid out from under the cursor. The order
+ * seeds from name order and only ever changes when a manager drags a name, so a row stays put
+ * while you work. There is deliberately no "sort by load" control here; that's a staff-rail
+ * feature. */
+export declare function useScheduleRoster(board: ScheduleBoardApi): {
+    search: import("vue").Ref<string, string>;
+    filteredEmployees: import("vue").ComputedRef<{
+        id: number;
+        name: string;
+        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;
+            assignmentId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | 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;
+            assignmentId?: 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;
+        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;
+    }[]>;
+    orderedEmployees: import("vue").ComputedRef<{
+        id: number;
+        name: string;
+        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;
+            assignmentId?: string | undefined;
+        } | {
+            timeOff: "approved" | "pending";
+            reason: string;
+            half?: boolean | undefined;
+            halfPart?: "AM" | "PM" | 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;
+            assignmentId?: 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;
+        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;
+    }[]>;
+    order: import("vue").Ref<number[], number[]>;
+    reorder: (draggedId: number, targetId: number, after: boolean) => void;
+};
+export type ScheduleRosterApi = ReturnType<typeof useScheduleRoster>;

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

@@ -0,0 +1,54 @@
+export type ScheduleSettingsSection = 'budget' | 'overtime' | 'notify';
+/** Labour budget and Notifications are out of the General page for now — see
+ * ScheduleSettingsPage's own note. `ScheduleSettingsSection` stays the full union (rather
+ * than narrowing to a literal `'overtime'`) so `draft`/`save()` below don't have to change
+ * shape the day a section comes back; only the nav and the page's own rendering are trimmed. */
+export declare const SETTINGS_SECTIONS: {
+    key: ScheduleSettingsSection;
+    label: string;
+}[];
+/** The mockup's Scheduling Settings page, scoped to the 3 tabs the topbar gear icon opens
+ * (Labour budget / Overtime / Notifications). The mockup's sibling Shift & coverage / Seasonal
+ * / Positions pages are a separate, out-of-scope epic — not built here. One draft object, like
+ * the mockup's settingsDraft/spSnapshot(). */
+export declare function useScheduleSettings(): {
+    isOpen: import("vue").Ref<boolean, boolean>;
+    activeSection: import("vue").Ref<ScheduleSettingsSection, ScheduleSettingsSection>;
+    draft: {
+        salesForecast: number;
+        labourTarget: number;
+        budgetFromSales: boolean;
+        budget: number;
+        payRate: {
+            NORMAL: {
+                overtime: number;
+            };
+            REST_DAY: {
+                regular: number;
+                overtime: number;
+            };
+            PUBLIC_HOLIDAY: {
+                regular: number;
+                overtime: number;
+            };
+        };
+        otCapHours: number;
+        otBudget: number;
+        notify: {
+            waConnected: boolean;
+            waNumber: string;
+            waDisplayName: string;
+            defaults: {
+                wa: boolean;
+                push: boolean;
+                email: boolean;
+            };
+        };
+    };
+    dirty: import("vue").ComputedRef<boolean>;
+    open: (section?: ScheduleSettingsSection) => void;
+    close: () => boolean;
+    discard: () => void;
+    save: () => void;
+};
+export type ScheduleSettingsApi = ReturnType<typeof useScheduleSettings>;

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

@@ -0,0 +1,18 @@
+/** "Set it up" banner — no positions means no roles to hang a pay rate or a shift pattern off,
+ * so an empty catalogue is the one signal this checks. Dismissing is a session choice: the
+ * banner is cheap enough to see again on the next visit while the outlet really is
+ * unconfigured.
+ *
+ * The welcome dialog answers a different question — "has this outlet's owner seen the
+ * onboarding greeting" — and is deliberately NOT tied to whether positions currently exist:
+ * the board's positions land from an async fetch, so gating the dialog on `POSITIONS.length`
+ * meant a fast response for an outlet that already had positions saved could yank the dialog
+ * shut within the same tick it opened, before anyone could read it. `localStorage`, keyed per
+ * outlet, is what makes "seen" durable and independent of that fetch. */
+export declare function useScheduleSetupBanner(): {
+    open: import("vue").ComputedRef<boolean>;
+    start: () => void;
+    dismiss: () => void;
+    welcomeOpen: import("vue").ComputedRef<boolean>;
+    dismissWelcome: () => void;
+};