@feedmepos/mf-hrm-portal 2.2.5-dev → 2.2.5-dev.10

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

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

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

@@ -0,0 +1,143 @@
+import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleAutoScheduleStep = 'options' | 'summary';
+export interface ScheduleAutoScheduleOptions {
+    fillGaps: boolean;
+    objective: FdtoScheduleAutoScheduleObjective;
+    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). */
+    respectAvailability: boolean;
+    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. */
+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;
+        allowOvertime: boolean;
+        respectAvailability: boolean;
+        followPatterns: boolean;
+        costEfficient: boolean;
+    };
+    generating: import("vue").Ref<boolean, boolean>;
+    generateError: import("vue").Ref<string | null, string | null>;
+    result: import("vue").Ref<{
+        proposals: {
+            employeeId: string;
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string;
+        }[];
+        unfilledCount: 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;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+                message: string;
+            }[];
+            coverage: {
+                position: number;
+                availability: number;
+                wage: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+    } | null, FdtoScheduleAutoScheduleResult | {
+        proposals: {
+            employeeId: string;
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string;
+        }[];
+        unfilledCount: 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;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+                message: string;
+            }[];
+            coverage: {
+                position: number;
+                availability: number;
+                wage: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+    } | null>;
+    gapCount: import("vue").ComputedRef<number>;
+    hasDemand: import("vue").ComputedRef<boolean>;
+    noDemandOpen: import("vue").Ref<boolean, boolean>;
+    rangeLabel: import("vue").ComputedRef<string>;
+    openWizard: () => void;
+    closeWizard: () => void;
+    next: () => void;
+    back: () => void;
+    generate: () => Promise<void>;
+    reviewMode: import("vue").ComputedRef<boolean>;
+    proposals: import("vue").ComputedRef<{
+        id: number;
+        empId: number;
+        dayIdx: number;
+        start: string;
+        end: string;
+        role: string;
+        openId?: number | undefined;
+        status: "pending" | "rejected";
+        weekKey?: string | undefined;
+        reason?: string | undefined;
+    }[]>;
+    weekHasProposals: import("vue").ComputedRef<boolean>;
+    unmetCount: import("vue").Ref<number, number>;
+    acceptedCount: import("vue").ComputedRef<number>;
+    rejectedCount: import("vue").ComputedRef<number>;
+    removedCount: import("vue").ComputedRef<number>;
+    changedCount: import("vue").ComputedRef<number>;
+    unqualifiedCount: import("vue").ComputedRef<number>;
+    conflictCount: import("vue").ComputedRef<number>;
+    projectedCost: import("vue").ComputedRef<number | null>;
+    proposalAt: (empId: number, dayIdx: number) => Proposal | undefined;
+    draggingId: import("vue").Ref<number | null, number | null>;
+    moveProposal: (id: number, empId: number, dayIdx: number) => string | null;
+    toggleReject: (id: number) => void;
+    rejectAll: () => void;
+    exitReview: () => void;
+    apply: () => number;
+};
+export type ScheduleAutoScheduleApi = ReturnType<typeof useScheduleAutoSchedule>;

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

@@ -0,0 +1,426 @@
+import type { Employee, OpenShift, PendingChange, ScheduleStatusInfo, ScheduleVersion, ScheduleVersionSnapshot, Section, WorkSlot } from '../types';
+import { RANGE_LEN } from './schedule-week-cache';
+import { contractCapFor, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
+export { contractCapFor, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf, };
+export { RANGE_LEN };
+export type ScheduleGranularity = 'day' | 'week';
+export declare function useScheduleBoard(handlers?: {
+    onPersistError?: (message: string) => void;
+}): {
+    dayNote: (dayIdx: number) => import("../types").ScheduleDayNote | null;
+    setDayNote: (dayIdx: number, title: string, desc: string) => void;
+    clearDayNote: (dayIdx: number) => void;
+    toggleClosed: (dayIdx: number) => {
+        closed: boolean;
+        rostered: number;
+    };
+    isManuallyClosed: (dayIdx: number) => boolean;
+    isStandingClosedWeekday: (dayIdx: number) => boolean;
+    holidayName: (dayIdx: number) => string | null;
+    holidayIsAuto: (dayIdx: number) => boolean;
+    isPublicHoliday: (dayIdx: number) => boolean;
+    holidayRateApplies: (dayIdx: number) => boolean;
+    setHolidayNormal: (dayIdx: number, toNormal: boolean) => void;
+    setPublicHoliday: (dayIdx: number, on: boolean) => void;
+    otRateOn: (dayIdx: number) => number;
+    regularRateOn: (dayIdx: number) => number;
+    isHoliday: (dayIdx: number) => boolean;
+    employees: import("vue").Ref<{
+        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;
+            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;
+            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;
+        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;
+    }[], Employee[] | {
+        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;
+            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;
+            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;
+        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;
+    }[]>;
+    sections: import("vue").Ref<{
+        id: string;
+        label: string;
+        roles: string[];
+        system?: boolean | undefined;
+    }[], Section[] | {
+        id: string;
+        label: string;
+        roles: string[];
+        system?: boolean | undefined;
+    }[]>;
+    openShifts: import("vue").Ref<{
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    }[], OpenShift[] | {
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    }[]>;
+    highlightEmpId: import("vue").Ref<number | null, number | null>;
+    rangeStart: import("vue").Ref<Date, Date>;
+    weekOffset: import("vue").ComputedRef<number>;
+    peekWeek: (offset: number) => import("./schedule-week-cache").WeekBucket;
+    isRecentlySaved: (empId: number, dayIdx: number) => boolean;
+    isWeekLocked: (offset?: number) => boolean;
+    dayLocked: (dayIdx: number) => boolean;
+    pendingChanges: import("vue").Ref<{
+        empId: number;
+        dayIdx: number;
+        kind: "add" | "change" | "remove";
+        label: string;
+    }[], PendingChange[] | {
+        empId: number;
+        dayIdx: number;
+        kind: "add" | "change" | "remove";
+        label: string;
+    }[]>;
+    unpublishedChanges: import("vue").ComputedRef<PendingChange[]>;
+    persistPublish: (items: Array<{
+        empId: number;
+        dayIdx: number;
+        slot: WorkSlot;
+    }>) => Promise<void>;
+    recordChange: (empId: number, dayIdx: number, kind: PendingChange["kind"], label: string) => void;
+    scheduleVersions: import("vue").Ref<{
+        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;
+                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;
+                assignmentId?: string | undefined;
+            }[] | null)[];
+        }[];
+    }[], ScheduleVersion[] | {
+        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;
+                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;
+                assignmentId?: string | undefined;
+            }[] | null)[];
+        }[];
+    }[]>;
+    lastUpdatedAt: import("vue").Ref<Date | null, Date | null>;
+    lastPublishedAt: import("vue").Ref<Date | null, Date | null>;
+    pushVersion: (note: string, opts?: Partial<ScheduleVersion>) => ScheduleVersion;
+    snapshotSchedule: () => ScheduleVersionSnapshot[];
+    scheduleStatus: import("vue").ComputedRef<ScheduleStatusInfo>;
+    conflictCount: () => number;
+    granularity: import("vue").Ref<ScheduleGranularity, ScheduleGranularity>;
+    focusDayIdx: import("vue").Ref<number, number>;
+    setGranularity: (value: ScheduleGranularity) => void;
+    dayDates: import("vue").ComputedRef<Date[]>;
+    dayLabels: import("vue").ComputedRef<string[]>;
+    visibleDayIndices: import("vue").ComputedRef<number[]>;
+    visibleDays: import("vue").ComputedRef<{
+        dayIdx: number;
+        date: Date;
+    }[]>;
+    rangeLabel: import("vue").ComputedRef<string>;
+    isToday: (dayIdx: number) => boolean;
+    dateKey: (dayIdx: number) => string | null;
+    navigate: (delta: number) => void;
+    goToday: () => void;
+    membersOf: (sectionId: string) => Employee[];
+    sectionCost: (sectionId: string, members?: Employee[]) => number;
+    totalWeeklyCost: import("vue").ComputedRef<number>;
+    employeeById: (id: number) => Employee | undefined;
+    commitShift: (empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[]) => void;
+    commitShiftAt: (offset: number, empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[]) => void;
+    removeShift: (empId: number, dayIdx: number) => void;
+    removeShiftAt: (offset: number, empId: number, dayIdx: number) => void;
+    moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number) => boolean;
+    swapShifts: (empIdA: number, empIdB: number, dayA: number, dayB?: number) => boolean;
+    clearShiftsInRange: () => {
+        shifts: number;
+        open: number;
+        leave: number;
+    };
+    requiredFor: (dayIdx: number, position: string) => number;
+    scheduledFor: (dayIdx: number, position: string) => number;
+    compGroupRate: (name: string | undefined) => number | undefined;
+    UNASSIGNED: string;
+};
+export type ScheduleBoardApi = ReturnType<typeof useScheduleBoard>;