@feedmepos/mf-hrm-portal 2.3.0-dev → 2.3.0-dev.11

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

@@ -1,4 +1,3 @@
-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';
@@ -6,7 +5,9 @@ export type { ScheduleAddEmployeeForm, ScheduleAddEmployeeMode, ScheduleAddEmplo
 /** Add-employee wizard: a "how do you want to add them" step, then one detail form covering
  * identity, locations, pay, scheduling caps, availability, positions and POS access — plus
  * the "select existing POS staff" side dialog the first step can hand off to. */
-export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
+export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?: {
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
     open: import("vue").Ref<boolean, boolean>;
     selectExistingOpen: import("vue").Ref<boolean, boolean>;
     step: import("vue").Ref<ScheduleAddEmployeeStep, ScheduleAddEmployeeStep>;
@@ -20,10 +21,11 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         payBasis: "hourly" | "monthly";
         payAmount: string;
         maxHours: string;
+        maxHoursPerDay: string;
         minHours: string;
-        otEnabled: boolean;
-        otAfterDaily: string;
-        maxOtHours: string;
+        workingHoursEnabled: boolean;
+        overtimeEnabled: boolean;
+        maxHoursPerMonth: string;
         availDays: boolean[];
         availHours: {
             from: string;
@@ -37,7 +39,10 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         masterUser: boolean;
         masterCode: string;
         posAccessEnabled: boolean;
-        posRoleId: string;
+        posRoles: {
+            outlet: string;
+            roleId: string;
+        }[];
     };
     sectionId: import("vue").Ref<string, string>;
     isEditing: import("vue").ComputedRef<boolean>;
@@ -46,12 +51,14 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     secOpen: import("vue").Ref<boolean, boolean>;
     secondaryOptions: import("vue").ComputedRef<string[]>;
     isPart: import("vue").ComputedRef<boolean>;
-    dayLit: (i: number) => boolean;
+    dayLit: (index: 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>;
-    toggleOt: () => void;
+    maxHoursPlaceholder: import("vue").ComputedRef<string>;
+    minHoursPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerDayPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerMonthPlaceholder: import("vue").ComputedRef<string>;
+    toggleOvertime: () => void;
     payUnit: import("vue").ComputedRef<"/month" | "/hour">;
     effectiveRate: import("vue").ComputedRef<number>;
     passcodeValue: import("vue").ComputedRef<string>;
@@ -66,6 +73,7 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     payLine: import("vue").ComputedRef<string>;
     nameError: import("vue").ComputedRef<boolean>;
     passError: import("vue").ComputedRef<boolean>;
+    posRolesError: import("vue").ComputedRef<boolean>;
     availabilityError: import("vue").ComputedRef<boolean>;
     saving: import("vue").Ref<boolean, boolean>;
     saveError: import("vue").Ref<string | null, string | null>;
@@ -73,6 +81,7 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     candidatesError: import("vue").Ref<string | null, string | null>;
     openWizard: (section: string) => void;
     openEditFor: (emp: Employee) => void;
+    confirmClose: () => void;
     close: () => void;
     setMode: (m: ScheduleAddEmployeeMode) => void;
     openSelectExisting: () => void;
@@ -81,21 +90,26 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     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;
+    toggleLocation: (location: string) => void;
+    removeLocation: (location: string) => void;
+    toggleSecondary: (position: string) => void;
+    removeSecondary: (position: string) => void;
+    setPrimaryPosition: (position: string) => void;
     setPayBasis: (basis: "hourly" | "monthly") => void;
-    toggleAvailDay: (i: number) => void;
+    toggleAvailDay: (index: number) => void;
     availAll: () => void;
-    setAvailHour: (i: number, field: "from" | "to", value: string) => void;
-    copyAvailHourDown: (i: number) => void;
-    setPasscodeDigit: (i: number, value: string) => void;
+    setAvailHour: (index: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (index: number) => void;
+    setPasscodeDigit: (index: number, value: string) => void;
     generatePasscode: () => void;
     togglePosAccess: () => void;
-    setPosRole: (roleId: string) => void;
-    posRoleOptions: import("vue").ComputedRef<Role[]>;
+    addPosRoleRow: () => void;
+    removePosRoleRow: (index: number) => void;
+    isCurrentOutletRow: (index: number) => boolean;
+    setPosRoleOutlet: (index: number, outlet: string) => void;
+    setPosRoleId: (index: number, roleId: string) => void;
+    posRoleOptionsFor: (outlet: string) => import("../../../types/role").Role[];
+    posRolesHint: import("vue").ComputedRef<"" | "No outlet assigned, so their passcode will not open a till yet." | "The same outlet is listed twice — only the last role on it will apply.">;
     create: () => Promise<boolean>;
 };
 export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -37,19 +37,6 @@ export declare function qualifiedFor(emp: Employee, position: string): boolean;
 export declare function useScheduleAreaBoard(board: ScheduleBoardApi): {
     positionRows: import("vue").ComputedRef<string[]>;
     assignedOn: (dayIdx: number, position: string) => ScheduleAssignedSlot[];
-    unfilledOpenShiftsOn: (dayIdx: number, position: string) => {
-        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;
-    }[];
     poolFor: (position: string) => Employee[];
     cellMeta: (dayIdx: number, position: string) => SchedulePositionCellMeta;
     positionWeekMeta: (position: string) => {

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

@@ -1,12 +1,6 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
-import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
-/** Dragging a person from the staff rail onto a position/day cell — ported from the mockup's
- * dropStaffOnCell(), scoped to this board's model (no "unspecialised, so ask what they can
- * do" grant flow, no split shifts): dropping fills an existing open shift for that position/day
- * if there is one, otherwise opens the shift editor pre-filled with this person, day and
- * position so the manager sets the hours. */
-export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, handlers: {
-    onFillOpenShift: (openId: number, empId: number) => void;
+/** Dragging a person from the staff rail onto a position/day cell opens a normal assigned shift. */
+export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, handlers: {
     onCreateShift: (empId: number, dayIdx: number, position: string) => void;
     onNotQualified: (empName: string, position: string) => void;
 }): {

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

@@ -0,0 +1,13 @@
+import type { DaySlot, Employee, WorkSlot } from '../types';
+export interface ScheduleAssignmentMutationOptions {
+    dateFor: (offset: number, dayIdx: number) => string | null;
+    employeeAt: (offset: number, employeeId: number) => Employee | undefined;
+    currentOffset: () => number;
+    onPersistError?: (message: string) => void;
+}
+export declare function useScheduleAssignmentMutations(options: ScheduleAssignmentMutationOptions): {
+    persistSlot: (empId: number, dayIdx: number, oldSlot: DaySlot, newSlot: WorkSlot | WorkSlot[], dateOverride?: string | null, offset?: number, restoreDaySlot?: DaySlot) => Promise<void>;
+    persistRemoval: (oldSlot: DaySlot) => Promise<void>;
+    persistMove: (toEmpId: number, dayIdx: number, slot: WorkSlot | WorkSlot[], dateOverride?: string | null) => Promise<void>;
+    recoverPersistFailure: (error: unknown, fallback: string) => Promise<void>;
+};

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

@@ -57,9 +57,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -121,9 +121,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {
@@ -185,9 +185,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
                 occupied: number;
                 notQualified: number;
                 weeklyCap: number;
+                dailyCap: number;
                 rest: number;
                 dayOff: number;
-                dayCap: number;
             };
         }[];
         metrics: {

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

@@ -1,27 +1,26 @@
 import type { Employee, OpenShift, PendingChange, ScheduleStatusInfo, ScheduleVersion, ScheduleVersionSnapshot, Section, WorkSlot } from '../types';
 import { RANGE_LEN } from './schedule-week-cache';
-import { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
-export { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, positionKeyOf, workSlotsOf, };
+import { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, overlapsAnotherSlot, positionKeyOf, workSlotsOf } from './schedule-board-helpers';
+export { contractCapFor, isGenuineSplitGroup, isLeaveSlot, isPartTime, isoDateKey, isWorkSlot, overContract, overlapsAnotherSlot, 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;
+    setDayNote: (dayIdx: number, title: string, desc: string, isPublicHoliday?: boolean) => void;
     clearDayNote: (dayIdx: number) => void;
     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;
+        sourceId: string;
         name: string;
         employmentType: "FULLTIME" | "PARTTIME";
         role: string;
@@ -32,10 +31,12 @@ export declare function useScheduleBoard(handlers?: {
         contractHours?: number | undefined;
         rate: number;
         positions: string[];
+        archivedPositions?: string[] | undefined;
         shifts: ({
             start: string;
             end: string;
             role: string;
+            positionId?: string | undefined;
             status: import("../types").ShiftStatus;
             clock?: {
                 in: string | null;
@@ -57,6 +58,7 @@ export declare function useScheduleBoard(handlers?: {
                 breakPayType: "PAID" | "UNPAID";
             })[] | undefined;
             assignmentId?: string | undefined;
+            updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         } | {
             timeOff: "approved" | "pending";
@@ -83,6 +85,7 @@ export declare function useScheduleBoard(handlers?: {
             start: string;
             end: string;
             role: string;
+            positionId?: string | undefined;
             status: import("../types").ShiftStatus;
             clock?: {
                 in: string | null;
@@ -104,6 +107,7 @@ export declare function useScheduleBoard(handlers?: {
                 breakPayType: "PAID" | "UNPAID";
             })[] | undefined;
             assignmentId?: string | undefined;
+            updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         }[] | null)[];
         remarks: {
@@ -120,9 +124,16 @@ export declare function useScheduleBoard(handlers?: {
         payBasis?: "hourly" | "monthly" | undefined;
         payAmount?: number | undefined;
         maxHours?: number | undefined;
-        maxOtHours?: number | undefined;
         minHours?: number | undefined;
-        otAfterDaily?: number | undefined;
+        minHoursPerDay?: number | undefined;
+        workingHours?: {
+            minHoursPerDay: number | null;
+            maxHoursPerDay: number | null;
+            maxHoursPerWeek: number | null;
+        } | undefined;
+        overtime?: {
+            maxHoursPerMonth: number | null;
+        } | undefined;
         preferences?: string[] | undefined;
         seniority?: "senior" | "junior" | "" | undefined;
         availDays?: boolean[] | undefined;
@@ -131,9 +142,11 @@ export declare function useScheduleBoard(handlers?: {
             to: string;
         }[] | undefined;
         passcode?: string | undefined;
+        code?: string | undefined;
         masterUser?: boolean | undefined;
     }[], Employee[] | {
         id: number;
+        sourceId: string;
         name: string;
         employmentType: "FULLTIME" | "PARTTIME";
         role: string;
@@ -144,10 +157,12 @@ export declare function useScheduleBoard(handlers?: {
         contractHours?: number | undefined;
         rate: number;
         positions: string[];
+        archivedPositions?: string[] | undefined;
         shifts: ({
             start: string;
             end: string;
             role: string;
+            positionId?: string | undefined;
             status: import("../types").ShiftStatus;
             clock?: {
                 in: string | null;
@@ -169,6 +184,7 @@ export declare function useScheduleBoard(handlers?: {
                 breakPayType: "PAID" | "UNPAID";
             })[] | undefined;
             assignmentId?: string | undefined;
+            updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         } | {
             timeOff: "approved" | "pending";
@@ -195,6 +211,7 @@ export declare function useScheduleBoard(handlers?: {
             start: string;
             end: string;
             role: string;
+            positionId?: string | undefined;
             status: import("../types").ShiftStatus;
             clock?: {
                 in: string | null;
@@ -216,6 +233,7 @@ export declare function useScheduleBoard(handlers?: {
                 breakPayType: "PAID" | "UNPAID";
             })[] | undefined;
             assignmentId?: string | undefined;
+            updatedAt?: string | undefined;
             splitGroupId?: string | undefined;
         }[] | null)[];
         remarks: {
@@ -232,9 +250,16 @@ export declare function useScheduleBoard(handlers?: {
         payBasis?: "hourly" | "monthly" | undefined;
         payAmount?: number | undefined;
         maxHours?: number | undefined;
-        maxOtHours?: number | undefined;
         minHours?: number | undefined;
-        otAfterDaily?: number | undefined;
+        minHoursPerDay?: number | undefined;
+        workingHours?: {
+            minHoursPerDay: number | null;
+            maxHoursPerDay: number | null;
+            maxHoursPerWeek: number | null;
+        } | undefined;
+        overtime?: {
+            maxHoursPerMonth: number | null;
+        } | undefined;
         preferences?: string[] | undefined;
         seniority?: "senior" | "junior" | "" | undefined;
         availDays?: boolean[] | undefined;
@@ -243,6 +268,7 @@ export declare function useScheduleBoard(handlers?: {
             to: string;
         }[] | undefined;
         passcode?: string | undefined;
+        code?: string | undefined;
         masterUser?: boolean | undefined;
     }[]>;
     sections: import("vue").Ref<{
@@ -281,7 +307,6 @@ export declare function useScheduleBoard(handlers?: {
         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;
@@ -290,11 +315,13 @@ export declare function useScheduleBoard(handlers?: {
     dayLocked: (dayIdx: number) => boolean;
     pendingChanges: import("vue").Ref<{
         empId: number;
+        employeeKey: string;
         dayIdx: number;
         kind: "add" | "change" | "remove";
         label: string;
     }[], PendingChange[] | {
         empId: number;
+        employeeKey: string;
         dayIdx: number;
         kind: "add" | "change" | "remove";
         label: string;
@@ -304,7 +331,8 @@ export declare function useScheduleBoard(handlers?: {
         empId: number;
         dayIdx: number;
         slot: WorkSlot;
-    }>) => Promise<void>;
+    }>) => Promise<boolean>;
+    flushAssignmentWrites: () => Promise<void>;
     recordChange: (empId: number, dayIdx: number, kind: PendingChange["kind"], label: string) => void;
     scheduleVersions: import("vue").Ref<{
         v: number;
@@ -321,6 +349,7 @@ export declare function useScheduleBoard(handlers?: {
                 start: string;
                 end: string;
                 role: string;
+                positionId?: string | undefined;
                 status: import("../types").ShiftStatus;
                 clock?: {
                     in: string | null;
@@ -342,6 +371,7 @@ export declare function useScheduleBoard(handlers?: {
                     breakPayType: "PAID" | "UNPAID";
                 })[] | undefined;
                 assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
                 splitGroupId?: string | undefined;
             } | {
                 timeOff: "approved" | "pending";
@@ -368,6 +398,7 @@ export declare function useScheduleBoard(handlers?: {
                 start: string;
                 end: string;
                 role: string;
+                positionId?: string | undefined;
                 status: import("../types").ShiftStatus;
                 clock?: {
                     in: string | null;
@@ -389,6 +420,7 @@ export declare function useScheduleBoard(handlers?: {
                     breakPayType: "PAID" | "UNPAID";
                 })[] | undefined;
                 assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
                 splitGroupId?: string | undefined;
             }[] | null)[];
         }[];
@@ -407,6 +439,7 @@ export declare function useScheduleBoard(handlers?: {
                 start: string;
                 end: string;
                 role: string;
+                positionId?: string | undefined;
                 status: import("../types").ShiftStatus;
                 clock?: {
                     in: string | null;
@@ -428,6 +461,7 @@ export declare function useScheduleBoard(handlers?: {
                     breakPayType: "PAID" | "UNPAID";
                 })[] | undefined;
                 assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
                 splitGroupId?: string | undefined;
             } | {
                 timeOff: "approved" | "pending";
@@ -454,6 +488,7 @@ export declare function useScheduleBoard(handlers?: {
                 start: string;
                 end: string;
                 role: string;
+                positionId?: string | undefined;
                 status: import("../types").ShiftStatus;
                 clock?: {
                     in: string | null;
@@ -475,6 +510,7 @@ export declare function useScheduleBoard(handlers?: {
                     breakPayType: "PAID" | "UNPAID";
                 })[] | undefined;
                 assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
                 splitGroupId?: string | undefined;
             }[] | null)[];
         }[];
@@ -498,6 +534,7 @@ export declare function useScheduleBoard(handlers?: {
     rangeLabel: import("vue").ComputedRef<string>;
     isToday: (dayIdx: number) => boolean;
     dateKey: (dayIdx: number) => string | null;
+    dateKeyAt: (offset: number, dayIdx: number) => string | null;
     navigate: (delta: number) => void;
     goToday: () => void;
     membersOf: (sectionId: string) => Employee[];
@@ -508,6 +545,10 @@ export declare function useScheduleBoard(handlers?: {
     commitShiftAt: (offset: number, empId: number, dayIdx: number, slot: WorkSlot | WorkSlot[], replaceIndex?: number, replaceCount?: number) => void;
     removeShift: (empId: number, dayIdx: number, slotIndex?: number, count?: number) => void;
     removeShiftAt: (offset: number, empId: number, dayIdx: number, slotIndex?: number, count?: number) => void;
+    employeeShiftsToClear: (empId: number) => number[];
+    clearEmployeeShifts: (empId: number) => {
+        shifts: number;
+    };
     moveShift: (fromEmpId: number, fromDayIdx: number, toEmpId: number, toDayIdx: number, fromSlotIndex?: number, fromSlotCount?: number) => boolean;
     swapShifts: (empIdA: number, empIdB: number, dayA: number, dayB?: number, slotIndexA?: number, slotIndexB?: number, slotCountA?: number) => boolean;
     clearShiftsInRange: () => {

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

@@ -3,7 +3,9 @@ import type { ScheduleOutletApi } from './useScheduleOutlet';
  * not the page's draft — to one or more other outlets the manager ticks. Scoped to pay rates
  * because that is the only outlet-scoped setting this page persists; the mockup's broader
  * "rules, shifts, coverage and positions" clone lives on pages this one doesn't own. */
-export declare function useScheduleCloneOutletModal(outlet: ScheduleOutletApi): {
+export declare function useScheduleCloneOutletModal(outlet: ScheduleOutletApi, options?: {
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
     open: import("vue").Ref<boolean, boolean>;
     query: import("vue").Ref<string, string>;
     selected: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;

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

@@ -1,4 +1,6 @@
+import type { Proposal } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
 export declare function slotHours(start: string, end: string): number;
 export interface ScheduleDayCost {
     hours: number;
@@ -27,10 +29,13 @@ export interface ScheduleOtRisk {
     hours: number;
     contract: number;
 }
+/** The staff rail consumes the same employee identity/load derivation as the area view. */
+export type ScheduleRailRow = ScheduleEmployeeLoad;
 /** Weekly labour cost + monthly OT gauge for the collapsible cost rail, built off one
  * per-day breakdown so the rail's totals and the stats row's per-day figures can never
  * disagree about what a day cost. */
-export declare function useScheduleCostRail(board: ScheduleBoardApi): {
+export declare function useScheduleCostRail(board: ScheduleBoardApi, proposalAt?: () => ((empId: number, dayIdx: number) => Proposal | undefined) | undefined): {
+    rows: import("vue").ComputedRef<ScheduleEmployeeLoad[]>;
     collapsed: import("vue").Ref<boolean, boolean>;
     byDay: import("vue").ComputedRef<ScheduleDayCost[]>;
     weeklyCost: import("vue").ComputedRef<number>;

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

@@ -7,7 +7,7 @@ export interface ScheduleDayNoteState {
 }
 export interface ScheduleDayNoteOptions {
     /** Toasts for the writes that happen on the spot — closing a day, repricing it, saving. */
-    onToast?: (message: string) => void;
+    onToast?: (message: string, type?: 'info' | 'success' | 'error') => void;
 }
 /** One decimal, always: "2×" reads as a count, and 1.5 beside a bare 2 in one sentence looks
  * like two different kinds of number. Ported from the mockup's fmtRate(). */
@@ -33,7 +33,6 @@ export declare function useScheduleDayNote(board: ScheduleBoardApi, opts?: Sched
     savedNote: import("vue").ComputedRef<import("../types").ScheduleDayNote | null>;
     hasSaved: import("vue").ComputedRef<boolean>;
     whenLabel: import("vue").ComputedRef<string>;
-    isAuto: import("vue").ComputedRef<boolean>;
     rateApplies: import("vue").ComputedRef<boolean>;
     holidayHint: import("vue").ComputedRef<string>;
     openFor: (dayIdx: number, anchor: HTMLElement) => void;

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

@@ -51,8 +51,6 @@ export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster:
     onAddShift: (empId: number, dayIdx: number) => void;
     onEditShift: (empId: number, dayIdx: number) => void;
     onEditLeave: (empId: number, dayIdx: number) => void;
-    onOpenAssign: (openId: number) => void;
-    onAddAreaShift: (dayIdx: number, position: string) => void;
     onOpenDemand: (dayIdx: number) => void;
     onOpenEmployeeMenu: (empId: number, anchor: HTMLElement) => void;
     onDemandSegment: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
@@ -68,7 +66,6 @@ export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster:
         clock: string;
     }[]>;
     isOpenHour: (m: number) => boolean;
-    openShiftsRow: import("vue").ComputedRef<ScheduleTimelineRow | null>;
     employeeRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
     positionTimelineRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
     demandRow: import("vue").ComputedRef<{

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

@@ -1,34 +1,17 @@
 import type { CoverageSegment, DaySlot, DemandPeriod, Employee, Proposal } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
-export declare function toMin(t: string): number;
-export declare function minToHHMM(m: number): string;
-/** Minutes from midnight for a start/end pair, with the end pushed past 1440 when it wraps —
- * so an overnight stretch stays one interval rather than two that cross zero. */
-export declare function spanOf(start: string, end: string): [number, number];
-/** 12-hour clock for prose — the sheet and the popovers read as sentences, and "16:00" in the
- * middle of one does not. */
-export declare function t12(hhmm: string): string;
-/** The timeline's two end labels — "8am", "10:30pm", meridiem spelled out. */
-export declare function minToShort(m: number): string;
-export declare function rangeText(from: number, to: number): string;
-export declare function roleTotalOf(p: DemandPeriod): number;
-/** The unnamed part of a period's headcount. Derived, never typed — so it cannot disagree with
- * the total above it. Negative means the breakdown has overrun that total. */
-export declare function anyLeftOf(p: DemandPeriod): number;
-export interface ScheduleCoverageAxis {
-    from: number;
-    to: number;
-}
+import { anyLeftOf, minToHHMM, minToShort, rangeText, roleTotalOf, spanOf, t12, toMin } from './schedule-demand-domain';
+import type { ScheduleCoverageAxis } from './schedule-demand-domain';
+export { anyLeftOf, minToHHMM, minToShort, rangeText, roleTotalOf, spanOf, t12, toMin };
+export type { ScheduleCoverageAxis } from './schedule-demand-domain';
 /** Staffing demand, and coverage read against it.
  *
  * Storage follows this board's dayNotes rather than the mockup's flat `di` index: the mockup
  * renders one long horizon so a day index identifies a date, but this board pages through
- * weeks, and demand put on this Monday must not reappear on every other Monday. So a date's
- * own demand is keyed by ISO date, and a standing weekday rule is keyed by weekday index.
+ * weeks, and demand put on this Monday must not reappear on every other Monday. Demand is
+ * therefore keyed by explicit ISO date.
  *
- * A date's own demand wins over the weekday rule it would otherwise inherit — "every Tuesday
- * needs eight" is a standing statement, and "this Tuesday is different" has to be able to
- * override it without rewriting the rule. */
+ * The weekday fallback remains only as a defensive read path until legacy records are removed. */
 export declare function useScheduleDemand(board: ScheduleBoardApi): {
     byDate: Record<string, DemandPeriod[]>;
     byWeekday: Record<number, DemandPeriod[]>;