@feedmepos/mf-hrm-portal 2.3.0-dev.2 → 2.3.0-dev.20

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

@@ -27,8 +27,17 @@ export interface ScheduleOtRisk {
     empId: number;
     name: string;
     hours: number;
+    otHours: number;
     contract: number;
 }
+export interface ScheduleMonthlyOtSummary {
+    key: string;
+    label: string;
+    used: number;
+    cap: number | null;
+    progress: number;
+    high: boolean;
+}
 /** 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
@@ -41,7 +50,10 @@ export declare function useScheduleCostRail(board: ScheduleBoardApi, proposalAt?
     weeklyCost: import("vue").ComputedRef<number>;
     otHours: import("vue").ComputedRef<number>;
     monthlyOtUsed: import("vue").ComputedRef<number>;
-    monthlyOtCapHours: number;
+    monthlyOtSummaries: import("vue").ComputedRef<ScheduleMonthlyOtSummary[]>;
+    monthlyOtCapHours: import("vue").ComputedRef<number | null>;
+    monthlyOtProgress: import("vue").ComputedRef<number>;
+    monthlyOtHigh: import("vue").ComputedRef<boolean>;
     bySection: import("vue").ComputedRef<ScheduleSectionCost[]>;
     otRisk: import("vue").ComputedRef<ScheduleOtRisk[]>;
 };

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

@@ -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

@@ -2,14 +2,19 @@ import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleRosterApi } from './useScheduleRoster';
 import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleEmployeeLoad } from './useScheduleEmployeeIdentity';
 declare function minToHHMM(m: number): string;
 export interface ScheduleTimelineBar {
     key: string;
+    start: number;
+    end: number;
     left: number;
     width: number;
     cls: string;
     label: string;
+    labels?: string[];
     sub?: string;
+    conflict?: boolean;
     title: string;
     brk?: {
         left: number;
@@ -17,6 +22,8 @@ export interface ScheduleTimelineBar {
     };
     laneTop?: number;
     laneHeight?: number;
+    employeeId?: number;
+    slotIndex?: number;
     onClick?: () => void;
 }
 export interface ScheduleTimelineRow {
@@ -27,6 +34,7 @@ export interface ScheduleTimelineRow {
     avatarInitials?: string;
     avatarColor?: string;
     employeeId?: number;
+    employeeLoad?: ScheduleEmployeeLoad;
     roleLabel?: string;
     hoursLabel?: string;
     hoursPct?: number;
@@ -34,9 +42,14 @@ export interface ScheduleTimelineRow {
     name: string;
     sub: string;
     bars: ScheduleTimelineBar[];
+    pastDay?: boolean;
+    lockedDay?: boolean;
+    closedDay?: boolean;
+    availabilityDay?: boolean;
+    availabilityLabel?: string;
     minHeight?: number;
     emptyText?: string;
-    onTrackClick?: () => void;
+    onTrackClick?: (anchor: HTMLElement) => void;
 }
 export interface ScheduleHourCell {
     m: number;
@@ -48,11 +61,10 @@ export interface ScheduleHourCell {
     n: number;
 }
 export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, demand: ScheduleDemandApi, handlers: {
-    onAddShift: (empId: number, dayIdx: number) => void;
+    onAddShift: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
+    onAddPositionShift: (dayIdx: number, position: string, anchor: HTMLElement) => 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 +80,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

@@ -8,12 +8,10 @@ export type { ScheduleCoverageAxis } from './schedule-demand-domain';
  *
  * 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[]>;

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

@@ -14,8 +14,7 @@ export interface ScheduleDemandSheetOptions {
     onNeedPosition?: (periodIdx: number, roleIdx: number) => void;
 }
 /** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
- * real cancel. The sheet also carries the recurrence choice, because "every Tuesday" is a
- * property of the statement being made rather than a second screen. */
+ * real cancel. Apply scopes are expanded into explicit dates in the visible week. */
 export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand: ScheduleDemandApi, opts: ScheduleDemandSheetOptions): {
     open: import("vue").Ref<boolean, boolean>;
     dayIdx: import("vue").Ref<number | null, number | null>;
@@ -25,6 +24,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         n: number;
         roles?: {
             position: string;
+            positionId?: string | undefined;
             n: number;
         }[] | undefined;
     }[], DemandPeriod[] | {
@@ -33,6 +33,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         n: number;
         roles?: {
             position: string;
+            positionId?: string | undefined;
             n: number;
         }[] | undefined;
     }[]>;
@@ -65,6 +66,13 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     }[]>;
     toggleCustomDay: (i: number) => void;
     applyNote: import("vue").ComputedRef<string>;
+    replaceConfirmOpen: import("vue").ComputedRef<boolean>;
+    replaceConfirmTitle: import("vue").ComputedRef<"Replace existing demand?" | "Clear existing demand?">;
+    replaceConfirmActionLabel: import("vue").ComputedRef<"Confirm" | "Clear demand">;
+    replaceConfirmMessage: import("vue").ComputedRef<"Demand already exists on the dates below. Applying this demand will replace it on all selected dates." | "Demand exists on the dates below. Saving an empty time range will clear it on all selected dates.">;
+    replaceConfirmDates: import("vue").ComputedRef<string[]>;
+    confirmReplace: () => Promise<void>;
+    cancelReplace: () => void;
     overlapWarning: import("vue").ComputedRef<string>;
     whenLabel: import("vue").ComputedRef<string>;
     openFor: (idx: number) => void;
@@ -115,6 +123,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
             n: number;
             roles?: {
                 position: string;
+                positionId?: string | undefined;
                 n: number;
             }[] | undefined;
         }[];
@@ -126,6 +135,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
             n: number;
             roles?: {
                 position: string;
+                positionId?: string | undefined;
                 n: number;
             }[] | undefined;
         }[];
@@ -151,6 +161,6 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     openCopy: () => void;
     closeCopy: () => void;
     confirmCopy: () => Promise<void>;
-    setApply: (k: DemandApplyMode) => DemandApplyMode;
+    setApply: (mode: DemandApplyMode) => void;
 };
 export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

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

@@ -50,5 +50,6 @@ export declare function useScheduleDragDrop(board: ScheduleBoardApi): {
     setDragHover: (empId: number, dayIdx: number, onCard: boolean, slotIndex: number | null) => void;
     clearDragHover: (empId: number, dayIdx: number) => void;
     dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
+    dropOnPosition: (targetDayIdx: number, targetPosition: string, allowLocked?: boolean) => void;
 };
 export type ScheduleDragDropApi = ReturnType<typeof useScheduleDragDrop>;

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

@@ -1,11 +1,24 @@
+import { type ComputedRef } from 'vue';
 import type { Role } from '@/types/role';
-import { type ScheduleAddEmployeeForm } from './schedule-add-employee-form';
-export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm): {
-    passcodeValue: import("vue").ComputedRef<string>;
-    passcodeOk: import("vue").ComputedRef<boolean>;
+import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm, options?: {
+    excludePosUserId?: ComputedRef<string | undefined>;
+}): {
+    passcodeValue: ComputedRef<string>;
+    passcodeOk: ComputedRef<boolean>;
     setPasscodeDigit: (index: number, value: string) => void;
-    generatePasscode: () => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
     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) => Role[];
+    isPosRoleUsable: (role: Role) => boolean;
+    setMasterUserRoleAccess: (roleIds: string[] | null | undefined) => void;
+    isPosOutletUsable: (outlet: string) => boolean;
+    setMasterUserRestaurantAccess: (restaurantIds: string[] | null | undefined) => void;
+    posRolesHint: 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.">;
 };

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

@@ -4,7 +4,7 @@ export declare function useScheduleEmployeeAvailability(form: ScheduleAddEmploye
     dayLit: (index: number) => boolean;
     avLabel: ComputedRef<"Weekly availability" | "Time off days">;
     avAllLabel: ComputedRef<"Clear all" | "Select all" | "No days off" | "Every day off">;
-    maxHoursPlaceholder: ComputedRef<"Hours per week" | "No cap">;
+    maxHoursPlaceholder: ComputedRef<string>;
     ensureAvailHours: (index: number) => void;
     toggleAvailDay: (index: number) => void;
     availAll: () => void;

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

@@ -12,13 +12,17 @@ interface UseScheduleEmployeeCandidatesOptions {
         value: boolean;
     };
     onPicked: (employeeId: string) => void;
-    onPrefillPasscode: (employeeId: string) => void;
+    onPrefillPasscode: (employeeId: string) => void | Promise<void>;
+    onPrefillPosRoles: (employeeId: string) => void | Promise<void>;
+    onPrefillPosRoleAccess: (roleIds: string[] | null | undefined) => void;
+    onPrefillPosRestaurantAccess: (restaurantIds: string[] | null | undefined) => void;
 }
 /** Directory lookup and profile prefill for the existing-employee path of the add wizard. */
 export declare function useScheduleEmployeeCandidates(options: UseScheduleEmployeeCandidatesOptions): {
     selectExistingOpen: import("vue").Ref<boolean, boolean>;
     candidatesLoading: import("vue").Ref<boolean, boolean>;
     candidatesError: import("vue").Ref<string | null, string | null>;
+    selectingExisting: import("vue").Ref<boolean, boolean>;
     openSelectExisting: () => void;
     closeSelectExisting: () => void;
     pickExisting: (employeeId: string) => Promise<void>;

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

@@ -12,8 +12,13 @@ interface UseScheduleEmployeePersistenceOptions {
     board: ScheduleBoardApi;
     editingEmployeeId: Ref<number | null>;
     originalLocations: Ref<string[]>;
+    originalPosRoles: Ref<{
+        outlet: string;
+        roleId: string;
+    }[]>;
     effectiveRate: ComputedRef<number>;
     passcodeValue: ComputedRef<string>;
+    deferScheduleWrites: Ref<boolean>;
     notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
 }
 /** Persistence for an existing business employee being added to this schedule. */

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

@@ -4,15 +4,15 @@ interface UseScheduleEmployeeValidationOptions {
     form: ScheduleAddEmployeeForm;
     submitAttempted: Ref<boolean>;
     passcodeOk: ComputedRef<boolean>;
-    isNewUser: ComputedRef<boolean>;
 }
 /** Validation guards for the add/edit employee form. Keeping them together makes create and
  * the field-level error indicators consume the same rules. */
 export declare function useScheduleEmployeeValidation(options: UseScheduleEmployeeValidationOptions): {
     nameError: ComputedRef<boolean>;
     passError: ComputedRef<boolean>;
+    posRolesOk: ComputedRef<boolean>;
+    posRolesError: ComputedRef<boolean>;
     availabilityOk: ComputedRef<boolean>;
     availabilityError: ComputedRef<boolean>;
-    masterCodeError: ComputedRef<boolean>;
 };
 export {};

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

@@ -21,6 +21,7 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
         over: number;
         roles: {
             position: string;
+            positionId?: string | undefined;
             n: number;
             required: number;
             got: number;
@@ -41,6 +42,7 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
         over: number;
         roles: {
             position: string;
+            positionId?: string | undefined;
             n: number;
             required: number;
             got: number;

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

@@ -1,7 +1,7 @@
 import { type Ref } from 'vue';
 import type { ScheduleOnboardingDayHours, ScheduleOnboardingRange } from './onboarding-types';
 import type { SchedulePositionsApi } from './useSchedulePositions';
-export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>): {
+export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>, isPastDay?: (dayIdx: number) => boolean): {
     demand: import("vue").Reactive<ScheduleOnboardingRange[][]>;
     dmDay: Ref<number, number>;
     staffingSaving: Ref<boolean, boolean>;

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

@@ -22,10 +22,12 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
             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;
@@ -74,6 +76,7 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
                 start: string;
                 end: string;
                 role: string;
+                positionId?: string | undefined;
                 status: import("../types").ShiftStatus;
                 clock?: {
                     in: string | null;
@@ -98,6 +101,28 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
                 updatedAt?: string | undefined;
                 splitGroupId?: string | undefined;
             }[] | null)[];
+            timeOff?: ({
+                timeOff: "approved" | "pending";
+                requestId?: string | undefined;
+                type?: "OFF_DAY" | "LEAVE" | undefined;
+                leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+                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;
+            } | null)[] | undefined;
             remarks: {
                 author: string;
                 date: string;
@@ -112,9 +137,16 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
             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;
@@ -123,6 +155,7 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
                 to: string;
             }[] | undefined;
             passcode?: string | undefined;
+            code?: string | undefined;
             masterUser?: boolean | undefined;
         };
         row: TeamRow;
@@ -137,10 +170,18 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
         end: string;
     }[]>;
     rawEmployee: (empId: number) => {
+        overtime?: {
+            maxHoursPerMonth: number | null;
+        } | undefined;
+        minHoursPerDay?: number | null | undefined;
+        workingHours?: {
+            minHoursPerDay: number | null;
+            maxHoursPerDay: number | null;
+            maxHoursPerWeek: number | null;
+        } | undefined;
         name: string;
         employeeId: string;
         employmentType: "FULLTIME" | "PARTTIME";
-        workingHour: number;
         wage: {
             type: "HOURLY" | "MONTHLY";
             amount: number;
@@ -162,7 +203,10 @@ export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardi
     seedEmployees: (missingOnly?: boolean) => void;
     pickAll: (checked: boolean) => void;
     setPosition: (empId: number, value: string) => void;
+    removePositionFromRows: (position: string) => void;
+    toggleSecond: (empId: number, position: string) => void;
     setEmployment: (empId: number, kind: TeamEmployment) => void;
+    maxHoursFor: (employment: TeamEmployment) => number | null;
     setHours: (empId: number, value: string) => void;
     setRate: (empId: number, value: string) => void;
     bulkOpen: import("vue").Ref<boolean, boolean>;