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

package/dist/src/views/scheduling/composables/onboarding-constants.d.ts

@@ -0,0 +1,5 @@
+import type { ScheduleOnboardingStep } from './onboarding-types';
+export declare const ONBOARDING_STEPS: ScheduleOnboardingStep[];
+export declare const SKIPPABLE_ONBOARDING_STEPS: ScheduleOnboardingStep[];
+export declare const COMMON_POSITION_SUGGESTIONS: string[];
+export declare const ANY_POSITION_KEY = "__any__";

package/dist/src/views/scheduling/composables/onboarding-hours.d.ts

@@ -0,0 +1,7 @@
+import type { ScheduleRules } from '../types';
+import type { ScheduleOnboardingDayHours } from './onboarding-types';
+import type { FdtoScheduleDayOperatingHours } from '@feedmepos/hrm-schedule-contract';
+/** Converts persisted outlet hours into the wizard's editable draft shape. */
+export declare function onboardingHoursFromRules(rules: ScheduleRules): ScheduleOnboardingDayHours[];
+/** Converts the grid's Monday-first draft back to the restaurant profile's Sunday-first wire shape. */
+export declare function onboardingHoursToProfile(hours: ScheduleOnboardingDayHours[]): FdtoScheduleDayOperatingHours[];

package/dist/src/views/scheduling/composables/onboarding-types.d.ts

@@ -0,0 +1,50 @@
+export type ScheduleOnboardingStep = 'hours' | 'staffing' | 'positions' | 'team' | 'availability' | 'review';
+export interface ScheduleOnboardingSession {
+    from: string;
+    to: string;
+}
+export interface ScheduleOnboardingDayHours {
+    open: boolean;
+    sessions: ScheduleOnboardingSession[];
+}
+export interface ScheduleOnboardingRange {
+    from: string;
+    to: string;
+    /** Blank until typed: an unset range asks for nobody. */
+    n: number | null;
+    roles: Array<{
+        position: string;
+        n: number | null;
+    }>;
+}
+export type TeamEmployment = 'full' | 'part';
+export type TeamBasis = 'monthly' | 'hourly';
+export interface TeamRow {
+    picked: boolean;
+    /** '' means "Any position" — a person with none. */
+    position: string;
+    second: string;
+    employment: TeamEmployment;
+    maxHours: string;
+    rate: string;
+    basis: TeamBasis;
+}
+export interface AvailDay {
+    on: boolean;
+    from: string;
+    to: string;
+}
+export interface AvailRow {
+    offDays: boolean[];
+    days: AvailDay[];
+}
+export interface ReviewRow {
+    step: ScheduleOnboardingStep;
+    title: string;
+    text: string;
+    sub?: string;
+}
+export interface IntroRecapRow {
+    label: string;
+    value: string;
+}

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

@@ -12,6 +12,9 @@ export interface ScheduleAddEmployeeForm {
     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
@@ -24,10 +27,13 @@ export interface ScheduleAddEmployeeForm {
     seniority: '' | 'senior' | 'junior';
     passcode: string[];
     masterUser: boolean;
-    /** POS role for a brand-new user (applied at every outlet in `locations`). */
-    roleId: string;
     /** 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. */

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

@@ -6,7 +6,16 @@ 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
+/** 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;
@@ -33,6 +42,18 @@ export declare function contractCapFor(emp: Employee): number;
  * 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,3 @@
+import type { FdtoScheduleBreak } from '@/types/schedule';
+export declare function breakMinutesOf(breaks: FdtoScheduleBreak[] | undefined): number;
+export declare function durationBreaksOf(minutes: number | undefined): FdtoScheduleBreak[];

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

@@ -1,21 +1,15 @@
-import { type Ref } from 'vue';
-import type { Employee, ScheduleDayNote } from '../types';
+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(employees: Ref<Employee[]>, dateKey: (dayIdx: number) => string | null, handlers?: {
+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;
-    toggleClosed: (dayIdx: number) => {
-        closed: boolean;
-        rostered: number;
-    };
-    isManuallyClosed: (dayIdx: number) => boolean;
     isStandingClosedWeekday: (dayIdx: number) => boolean;
     holidayName: (dayIdx: number) => string | null;
     holidayIsAuto: (dayIdx: number) => boolean;

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

@@ -1,8 +1,20 @@
+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): {

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

@@ -1,3 +1,4 @@
+import type { Role } from '@/types/role';
 import type { Employee } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import { type ScheduleAddEmployeeMode, type ScheduleAddEmployeeStep } from './schedule-add-employee-form';
@@ -20,6 +21,7 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         payAmount: string;
         maxHours: string;
         minHours: string;
+        otEnabled: boolean;
         otAfterDaily: string;
         maxOtHours: string;
         availDays: boolean[];
@@ -33,11 +35,13 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         seniority: "" | "senior" | "junior";
         passcode: string[];
         masterUser: boolean;
-        roleId: string;
         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[]>;
@@ -47,19 +51,15 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     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>;
-    roleOptions: import("vue").ComputedRef<{
-        value: string;
-        label: string;
-    }[]>;
-    roleError: import("vue").ComputedRef<boolean>;
+    locationOptions: import("vue").Reactive<string[]>;
     masterCodeError: import("vue").ComputedRef<boolean>;
     isNewUser: import("vue").ComputedRef<boolean>;
-    needsRole: 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>;
@@ -77,7 +77,7 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     setMode: (m: ScheduleAddEmployeeMode) => void;
     openSelectExisting: () => void;
     closeSelectExisting: () => void;
-    pickExisting: (employeeId: string) => void;
+    pickExisting: (employeeId: string) => Promise<void>;
     next: () => void;
     back: () => void;
     toggleMulti: (which: "loc" | "sec") => void;
@@ -93,6 +93,9 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     copyAvailHourDown: (i: number) => void;
     setPasscodeDigit: (i: number, value: string) => void;
     generatePasscode: () => void;
+    togglePosAccess: () => void;
+    setPosRole: (roleId: string) => void;
+    posRoleOptions: import("vue").ComputedRef<Role[]>;
     create: () => Promise<boolean>;
 };
 export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -35,7 +35,7 @@ export interface ScheduleAddPickSuggestion {
  * 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;
+    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;
 }): {
@@ -58,7 +58,15 @@ export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: Sche
         end: string;
     } | null>;
     suggested: import("vue").ComputedRef<ScheduleAddPickSuggestion | null>;
-    filteredPatterns: import("vue").ComputedRef<import("../types").ShiftTemplate[]>;
+    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;

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

@@ -3,6 +3,9 @@ import type { Employee, WorkSlot } from '../types';
 export interface ScheduleAssignedSlot {
     emp: Employee;
     slot: WorkSlot;
+    /** This slot's position within the employee's day — what a drag of this card has to hand
+     * `board.moveShift`/`swapShifts` to pick the right period out of a day holding more than one. */
+    slotIndex: number;
 }
 export interface SchedulePositionCellMeta {
     required: number;
@@ -12,6 +15,16 @@ export interface SchedulePositionCellMeta {
 }
 /** Shared by the week and day area views, so a position's colour never disagrees between them. */
 export declare function positionSwatchClass(position: string): string;
+/** Where shifts and employees go that name no station at all — either because the outlet
+ * hasn't named its positions yet, or because a shift deliberately names none. Rostering
+ * shouldn't be blocked on the Positions page being filled in first, so this row exists
+ * whenever there's anyone or anything to put in it (see `positionRows`). */
+export declare const ANY_POSITION_ROW = "Any position";
+/** Every other row is named after the position its shifts carry, so the row name and the
+ * position key are the same string. This one differs: it collects records that name nothing,
+ * so anything that queries BY position — qualifiedFor, assignedOn, a new shift's role — has to
+ * ask for '' instead, or the row would answer "nobody holds Any position". */
+export declare function rowAsk(row: 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

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

@@ -1,4 +1,4 @@
-import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoSchedulePlanner } from '@/types/schedule';
 import type { Proposal } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
@@ -6,6 +6,7 @@ export type ScheduleAutoScheduleStep = 'options' | 'summary';
 export interface ScheduleAutoScheduleOptions {
     fillGaps: boolean;
     objective: FdtoScheduleAutoScheduleObjective;
+    planner: FdtoScheduleAutoSchedulePlanner;
     allowOvertime: boolean;
     /** Shown as preferences in the dialog but not sent: the generator takes no input for them yet
      * (availability and time off are always respected; patterns and cost ride on the objective). */
@@ -13,30 +14,54 @@ export interface ScheduleAutoScheduleOptions {
     followPatterns: boolean;
     costEfficient: boolean;
 }
-/** Backend-powered draft generation and local proposal review. Generation never writes;
- * accepted proposals use the board's existing assignment persistence path. */
+/** Backend-powered draft generation and local proposal review — the engine lives in hr-backend;
+ * this composable only maps its result onto the board and lets a manager review it. Generation
+ * never writes; accepted proposals use the board's existing assignment persistence path. */
 export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
     wizardOpen: import("vue").Ref<boolean, boolean>;
     step: import("vue").Ref<ScheduleAutoScheduleStep, ScheduleAutoScheduleStep>;
     options: {
         fillGaps: boolean;
         objective: FdtoScheduleAutoScheduleObjective;
+        planner: FdtoScheduleAutoSchedulePlanner;
         allowOvertime: boolean;
         respectAvailability: boolean;
         followPatterns: boolean;
         costEfficient: boolean;
     };
+    planners: import("vue").Ref<("GREEDY" | "LLM")[], ("GREEDY" | "LLM")[]>;
+    plannerChoice: import("vue").ComputedRef<boolean>;
     generating: import("vue").Ref<boolean, boolean>;
     generateError: import("vue").Ref<string | null, string | null>;
     result: import("vue").Ref<{
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
         proposals: {
-            employeeId: string;
             date: string;
             startTime: string;
             endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
             position: string;
+            reason: string;
         }[];
         unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
         metrics: {
             minimumCoveragePercent: number;
             recommendedCoveragePercent: number;
@@ -52,27 +77,55 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
             capabilities: string[];
             issues: {
                 code: string;
-                severity: "BLOCKER" | "WARNING" | "INFO";
                 message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
             }[];
             coverage: {
-                position: number;
-                availability: number;
                 wage: number;
+                availability: number;
+                position: number;
                 targetHours: number;
             };
         };
         explanations: string[];
         solver: string;
-    } | null, FdtoScheduleAutoScheduleResult | {
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
+    } | null, {
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
         proposals: {
-            employeeId: string;
             date: string;
             startTime: string;
             endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
             position: string;
+            reason: string;
         }[];
         unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
         metrics: {
             minimumCoveragePercent: number;
             recommendedCoveragePercent: number;
@@ -88,18 +141,90 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
             capabilities: string[];
             issues: {
                 code: string;
-                severity: "BLOCKER" | "WARNING" | "INFO";
                 message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
             }[];
             coverage: {
-                position: number;
+                wage: number;
                 availability: number;
+                position: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
+    } | {
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
+        proposals: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
+            position: string;
+            reason: string;
+        }[];
+        unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+            }[];
+            coverage: {
                 wage: number;
+                availability: number;
+                position: number;
                 targetHours: number;
             };
         };
         explanations: string[];
         solver: string;
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
     } | null>;
     gapCount: import("vue").ComputedRef<number>;
     hasDemand: import("vue").ComputedRef<boolean>;
@@ -118,6 +243,7 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
         start: string;
         end: string;
         role: string;
+        positionId?: string | null | undefined;
         openId?: number | undefined;
         status: "pending" | "rejected";
         weekKey?: string | undefined;
@@ -138,6 +264,26 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     toggleReject: (id: number) => void;
     rejectAll: () => void;
     exitReview: () => void;
-    apply: () => number;
+    apply: () => Promise<number | null>;
+    applying: import("vue").Ref<boolean, boolean>;
+    applyRejections: import("vue").Ref<{
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[], {
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[] | {
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[]>;
+    applyError: import("vue").Ref<string | null, string | null>;
+    detailsOpen: import("vue").Ref<boolean, boolean>;
+    toggleDetails: () => void;
 };
 export type ScheduleAutoScheduleApi = ReturnType<typeof useScheduleAutoSchedule>;