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

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

@@ -0,0 +1,225 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleCardMenuState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    left: number;
+    top: number;
+}
+export interface ScheduleChangeState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+}
+export interface ScheduleSwapState {
+    open: boolean;
+    empId: number | null;
+    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;
+        left: number;
+        top: number;
+    };
+    openMenu: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
+    closeMenu: () => void;
+    change: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+    };
+    changeSlot: import("vue").ComputedRef<import("../types").WorkSlot[]>;
+    changeCandidates: 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;
+    }[]>;
+    openChange: (empId: number, dayIdx: number) => void;
+    closeChange: () => void;
+    confirmChange: (toId: number) => void;
+    swap: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+    };
+    swapSlot: import("vue").ComputedRef<import("../types").WorkSlot[]>;
+    swapCandidates: import("vue").ComputedRef<{
+        emp: {
+            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;
+        };
+        slot: import("../types").WorkSlot[];
+    }[]>;
+    openSwap: (empId: number, dayIdx: number) => void;
+    closeSwap: () => void;
+    confirmSwap: (toEmpId: number) => void;
+    removeShift: (empId: number, dayIdx: number) => void;
+};
+export type ScheduleShiftActionsApi = ReturnType<typeof useScheduleShiftActions>;

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

@@ -0,0 +1,174 @@
+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;
+        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">;
+    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;
+        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;
+    }[]>;
+    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>;
+    openForEmployee: (forEmpId: number, day: number, roleHint?: string, hours?: ScheduleShiftSegment) => void;
+    openForNewOpenShift: (day: number, roleHint?: string, hours?: ScheduleShiftSegment) => void;
+    openForEditOpenShift: (openShiftId: number) => void;
+    close: () => void;
+    addSegment: () => 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,20 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
+export type ScheduleRailSort = 'load' | 'name' | 'hours' | 'cost';
+/** 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 — search/sort over the same roster the employee view's name
+ * column shows, plus each person's load bar and an "Open shifts" jump summary. 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): {
+    search: import("vue").Ref<string, string>;
+    sort: import("vue").Ref<ScheduleRailSort, ScheduleRailSort>;
+    rows: import("vue").ComputedRef<ScheduleEmployeeLoad[]>;
+    openSummary: import("vue").ComputedRef<{
+        count: number;
+        hours: number;
+    }>;
+};
+export type ScheduleStaffRailApi = ReturnType<typeof useScheduleStaffRail>;

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

@@ -0,0 +1,25 @@
+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;
+    setForecast: (value: string) => void;
+    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,44 @@
+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;
+    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;
+        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) => void;
+    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 = 'copy' | 'actions' | 'export';
+/** Open/close state for the topbar's three dropdowns (Copy schedule, 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/data.d.ts

@@ -0,0 +1,105 @@
+import type { CompGroupMeta, Employee, ExistingStaffCandidate, OpenShift, ScheduleRules, Section, ShiftTemplate } from './types';
+import type { FdtoSchedulePosition, FdtoSchedulePositionSelectorReq } from '@/types/schedule';
+export declare const UNASSIGNED = "unassigned";
+export declare const WEEKDAYS: string[];
+export declare const DEFAULT_POSITION = "Any position";
+export declare const ALL_STATIONS = "All Stations";
+/** Employment seniority is a closed set in the model, not something an outlet configures. */
+export declare const SENIORITY_OPTIONS: Array<'senior' | 'junior'>;
+/** The one section every board has. Scheduling sections are not a Mongo concept yet, so the
+ * whole roster sits in this bucket and its `roles` list stays empty. */
+export declare const SECTIONS: Section[];
+/** The position catalogue, from the Positions collection. Name-only: this is read as plain
+ * strings everywhere on this board (dropdown options, coverage-matrix keys, role lookups), and
+ * changing its shape would touch every one of those. */
+export declare const POSITIONS: string[];
+/** The same catalogue, kept with its real backend id — the id-less `POSITIONS` above can't
+ * identify which document to edit or delete. Only the Position management page reads this. */
+export declare const POSITION_RECORDS: FdtoSchedulePosition[];
+/** Resolves a position name (every picker on this board only ever offers a name — see
+ * `POSITIONS` above) to its backend id, for save requests that can now name a position by id
+ * instead. `undefined` when the catalogue hasn't loaded yet or the name no longer matches one —
+ * callers still send the name alongside, so the backend's own by-name lookup is the fallback. */
+export declare function positionIdOf(name: string): string | undefined;
+/** The selector shape every position-carrying save request wants — `undefined` for a blank
+ * name (the field itself has nothing to name), a resolved id alongside the name otherwise. */
+export declare function positionSelectorOf(name: string | undefined): FdtoSchedulePositionSelectorReq | undefined;
+/** Which coverage positions a station label counts toward. Positions ARE the roles in this
+ * model — a shift records the position it is for — so nothing needs translating and this stays
+ * empty, which makes `positionKeyOf()` pass a role through unchanged. */
+export declare const ROLE_POSITIONS: Record<string, string[]>;
+/** The outlet this board is scheduling, from the Restaurants document. An object rather than a
+ * bare string so the two components that name it re-render when it arrives. */
+export declare const OUTLET: {
+    name: string;
+};
+/** Outlets a person may be rostered at. Filled by useScheduleOutlet from the restaurant store
+ * — the board payload only ever describes the one outlet it was asked for. */
+export declare const LOCATION_OPTIONS: string[];
+/** No Mongo source: departments and compensation groups are not modelled. The Add Employee
+ * form renders these as empty pickers rather than offering choices nobody configured. */
+export declare const DEPT_OPTIONS: string[];
+export declare const COMPGRP_OPTIONS: string[];
+export declare const COMPGRP_META: Record<string, CompGroupMeta>;
+/** Candidates for "add an employee who already exists elsewhere in the business". No source
+ * yet — EmployeeProfiles is per-outlet, and the business-wide directory lives in CouchDB. */
+export declare const EXISTING_STAFF: ExistingStaffCandidate[];
+/** The venue's shift patterns. No collection holds these yet; consumers already handle an empty
+ * list by falling back to the trading window in RULES. */
+export declare const SHIFT_TEMPLATES: ShiftTemplate[];
+/** Mon → Sun weighting used to spread a weekly sales forecast across days. Flat while there is
+ * no real forecast to shape: a curve invented here would make one day look busier than another
+ * for no reason anybody could point at. */
+export declare const SALES_CURVE: number[];
+/** Scheduling configuration, from two places and no others: `payRate` is the whole content of
+ * the ScheduleSettings document, and the trading window comes from the outlet's own Restaurants
+ * profile (see `restaurantProfile` on the DTO).
+ *
+ * The fields with no Mongo source stay zero rather than being guessed: `coverage` (per-template
+ * headcount matrices), `salesForecast`, `labourTarget`, `budget`, the OT caps and the
+ * notification channels. Nothing on screen derived from them is a figure this file made up.
+ *
+ * `openFrom`/`openTo` are the one pair that must never be blank — they are the axis every
+ * coverage bar, day timeline and shift form is drawn against, and there is no such thing as a
+ * zero-length day to draw. A neutral 00:00–24:00 stands in until a real window lands.
+ *
+ * `payRate` defaults to 1× throughout for the same reason the API does: billing a premium hour
+ * as an ordinary one understates a wage bill, and understating is the safe direction to be wrong
+ * in where inventing a 1.5 is not. */
+export declare const RULES: ScheduleRules;
+/** JS `getDay()` (0 = Sunday) → grid column (0 = Monday). */
+export declare function gridDayIdx(dayOfWeek: number): number;
+/** Grid column (0 = Monday) → JS `getDay()` (0 = Sunday). Inverse of gridDayIdx — needed
+ * wherever the board writes a day back to Mongo instead of reading one from it. */
+export declare function jsDayOfWeek(gridIdx: number): number;
+export declare function employeeIdOf(num: number): string | undefined;
+export declare function employeeNumberOf(employeeId: string): number;
+export declare function createScheduleEmployees(dates?: Date[]): Employee[];
+/** Open shifts backed by a persisted Shift requirement never shipped — the backend never
+ * carried that collection, so this always produced an empty list in practice. Kept as a stub,
+ * rather than removed, so the week cache's seed call (`schedule-week-cache.ts`) doesn't need
+ * its own special-casing: every open-shift row on the board today is added ad hoc through the
+ * shift popover instead (`useScheduleShiftPopover`'s `pushOpenShift`), entirely in local state. */
+export declare function createScheduleOpenShifts(): OpenShift[];
+/** Staffing demand for the held window, in the shape useScheduleDemand stores it: dated
+ * overrides keyed by ISO date, standing rules keyed by grid weekday. */
+export declare function scheduleDemand(): {
+    byDate: Record<string, Array<{
+        from: string;
+        to: string;
+        n: number;
+        roles: Array<{
+            position: string;
+            n: number;
+        }>;
+    }>>;
+    byWeekday: Record<number, Array<{
+        from: string;
+        to: string;
+        n: number;
+        roles: Array<{
+            position: string;
+            n: number;
+        }>;
+    }>>;
+};