@feedmepos/mf-hrm-portal 2.3.2-dev → 2.3.2-dev.2

package/dist/src/views/scheduling/components/ScheduleStaffRows.vue.d.ts

@@ -0,0 +1,50 @@
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleDragDropApi } from '../composables/useScheduleDragDrop';
+import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
+import type { ScheduleDemandRowApi } from '../composables/useScheduleDemandRow';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    dragDrop: ScheduleDragDropApi;
+    roster: ScheduleRosterApi;
+    demandRow: ScheduleDemandRowApi;
+    proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    addEmployee: () => any;
+    addShift: (empId: number, dayIdx: number, anchor: HTMLElement) => any;
+    editShift: (empId: number, dayIdx: number, slotIndex?: number | undefined) => any;
+    editLeave: (empId: number, dayIdx: number) => any;
+    dragEnd: () => any;
+    toggleProposal: (id: number) => any;
+    proposalDragStart: (id: number, ev: DragEvent) => any;
+    proposalDragEnd: () => any;
+    segEnter: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => any;
+    segLeave: () => any;
+    segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => any;
+    segFocus: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => any;
+    openEmployee: (empId: number) => any;
+    openEmployeeMenu: (empId: number, anchor: HTMLElement) => any;
+    dragShiftStart: (empId: number, dayIdx: number, ev: DragEvent, slotIndex: number) => any;
+    dropOnCell: (empId: number, dayIdx: number, ev: DragEvent) => any;
+    openDemandSheet: (dayIdx: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAddEmployee?: (() => any) | undefined;
+    onAddShift?: ((empId: number, dayIdx: number, anchor: HTMLElement) => any) | undefined;
+    onEditShift?: ((empId: number, dayIdx: number, slotIndex?: number | undefined) => any) | undefined;
+    onEditLeave?: ((empId: number, dayIdx: number) => any) | undefined;
+    onDragEnd?: (() => any) | undefined;
+    onToggleProposal?: ((id: number) => any) | undefined;
+    onProposalDragStart?: ((id: number, ev: DragEvent) => any) | undefined;
+    onProposalDragEnd?: (() => any) | undefined;
+    onSegEnter?: ((dayIdx: number, from: number, to: number, anchor: HTMLElement) => any) | undefined;
+    onSegLeave?: (() => any) | undefined;
+    onSegClick?: ((dayIdx: number, from: number, to: number, anchor: HTMLElement) => any) | undefined;
+    onSegFocus?: ((dayIdx: number, from: number, to: number, anchor: HTMLElement) => any) | undefined;
+    onOpenEmployee?: ((empId: number) => any) | undefined;
+    onOpenEmployeeMenu?: ((empId: number, anchor: HTMLElement) => any) | undefined;
+    onDragShiftStart?: ((empId: number, dayIdx: number, ev: DragEvent, slotIndex: number) => any) | undefined;
+    onDropOnCell?: ((empId: number, dayIdx: number, ev: DragEvent) => any) | undefined;
+    onOpenDemandSheet?: ((dayIdx: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/scheduling/components/ScheduleStatsRow.vue.d.ts

@@ -0,0 +1,12 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleCostRailApi } from '../composables/useScheduleCostRail';
+import type { ScheduleStatsRowApi } from '../composables/useScheduleStatsRow';
+import type { ScheduleViewMode } from '../composables/useScheduleFilterBar';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    costRail: ScheduleCostRailApi;
+    stats: ScheduleStatsRowApi;
+    mode: ScheduleViewMode;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/scheduling/components/ScheduleSwapShiftsModal.vue.d.ts

@@ -0,0 +1,8 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleShiftActionsApi } from '../composables/useScheduleShiftActions';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    actions: ScheduleShiftActionsApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/scheduling/components/ScheduleTimePickerPopover.vue.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
+type __VLS_Props = {
+    timePicker: ScheduleTimePickerApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/scheduling/components/ScheduleTopbar.vue.d.ts

@@ -0,0 +1,20 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleTopbarApi } from '../composables/useSchedulePageOverlays';
+import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSchedule';
+import type { ScheduleCopyWeekApi } from '../composables/useScheduleCopyWeek';
+import type { ScheduleExportApi } from '../composables/useScheduleExport';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    topbar: ScheduleTopbarApi;
+    autoSchedule: ScheduleAutoScheduleApi;
+    copyWeek: ScheduleCopyWeekApi;
+    exportApi: ScheduleExportApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: (kind: "shifts" | "demand" | "both") => any;
+    "sch-status-click": () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: ((kind: "shifts" | "demand" | "both") => any) | undefined;
+    "onSch-status-click"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/scheduling/composables/auto-schedule-mapping.d.ts

@@ -0,0 +1,35 @@
+import type { FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoScheduleProposal, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+import { ApiError } from '@/api';
+import type { Proposal } from '../types';
+/** ISO date of `dayIdx` in the week starting `weekKey` (YYYY-MM-DD, local arithmetic). */
+export declare function dateOfProposal(weekKey: string, dayIdx: number): string;
+/** Server proposals → board proposals for the week whose Monday is `weekKey`. A proposal whose
+ * date is not one of `dateKeyOf(0..RANGE_LEN-1)` or whose employee the board does not hold is
+ * dropped. Ids come from `nextId` so they stay unique across weeks. */
+export declare function proposalsFromResult(proposals: FdtoScheduleAutoScheduleProposal[], weekKey: string, dateKeyOf: (dayIdx: number) => string | null, nextId: () => number, holds: (empId: number) => boolean): Proposal[];
+/** The apply body for the accepted proposals, each re-dated from its own week and day. */
+export declare function applyRequestOf(proposals: Proposal[], allowOvertime: boolean, status?: FdtoScheduleAutoScheduleApplyReq['status']): FdtoScheduleAutoScheduleApplyReq;
+/** The `t` from `useI18n()`, passed into these pure helpers so they stay free of Vue setup. */
+export type TranslateFn = (key: string, params?: Record<string, unknown>) => string;
+export interface ClassifiedExplanation {
+    kind: 'reject' | 'ai' | 'plain';
+    text: string;
+}
+/** Sorts one `result.explanations` line into what the Details panel renders it as. The matched
+ * prefix is stripped from `text` in every case — the panel re-adds its own label/marker for
+ * `reject` and `ai`, so the raw wire prefix never doubles up with it. */
+export declare function classifyExplanation(line: string): ClassifiedExplanation;
+/** Whether `error` is a server refusal whose own message is meant for the user: a client error
+ * (0 < status < 500). A network failure (0) or a server error (5xx) is not. */
+export declare function isClientRefusal(error: unknown): error is ApiError;
+/** A client-error refusal shows its own message; a network failure or 5xx shows the generic one. */
+export declare function generateErrorMessage(error: unknown, t: TranslateFn): string;
+/** The result shown when "fill gaps" is off: nothing proposed, one explanation. */
+export declare function fillGapsOffResult(week: {
+    from: string;
+    to: string;
+}, objective: FdtoScheduleAutoScheduleObjective, allowOvertime: boolean, t: TranslateFn): FdtoScheduleAutoScheduleResult;
+/** The snackbar shown once a run finishes, whether it went to the server or (fill gaps off) was
+ * answered locally. `wallMs` is measured client-side around the request — it is what the manager
+ * actually waited, not just the server's own `timing.totalMs`. */
+export declare function generateDoneMessage(result: FdtoScheduleAutoScheduleResult, wallMs: number, t: TranslateFn): string;

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

@@ -0,0 +1,7 @@
+import type { ScheduleOnboardingStep } from './onboarding-types';
+export declare const ONBOARDING_STEPS: ScheduleOnboardingStep[];
+export declare const SKIPPABLE_ONBOARDING_STEPS: ScheduleOnboardingStep[];
+export declare const COMMON_POSITION_SUGGESTIONS: string[];
+export declare const ANY_POSITION_KEY = "__any__";
+/** i18n key for a Monday-first weekday index's short name (WEEKDAYS in ../data stays English). */
+export declare function weekdayKey(dayIdx: number): string;

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

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

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

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

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

@@ -0,0 +1,15 @@
+export type RemyDemandScope = {
+    mode: 'day';
+    isoDate: string;
+    label: string;
+} | {
+    mode: 'weekday';
+    weekday: string;
+} | {
+    mode: 'weekdays';
+};
+/** The text prefilled into the host Remy panel: one line naming the outlet and day, which the
+ * user continues with their demand. The "attach a roster image or describe it in words" guidance
+ * lives on the sheet's Ask Remy tooltip, not here. Names the outlet the way a manager knows it;
+ * Remy resolves it to an id itself (hrm_find_outlet), so no outlet id appears in the text. */
+export declare function remyDemandPrompt(outletName: string, scope: RemyDemandScope): string;

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

@@ -0,0 +1,82 @@
+import type { EmployeeAvailHours } from '../types';
+import type { FdtoScheduleUpdateEmployeeProfileReq } from '@/types/schedule';
+export type ScheduleAddEmployeeStep = 'mode' | 'details';
+export type ScheduleAddEmployeeMode = 'new' | 'existing';
+export interface ScheduleAddEmployeeForm {
+    name: string;
+    mobile: string;
+    dial: string;
+    employment: 'full' | 'part';
+    locations: string[];
+    payBasis: 'hourly' | 'monthly';
+    payAmount: string;
+    maxHours: string;
+    maxHoursPerDay: string;
+    minHours: string;
+    workingHoursEnabled: boolean;
+    overtimeEnabled: boolean;
+    /** Blank means no employee override; the outlet overtime setting is inherited. */
+    maxHoursPerMonth: string;
+    /** For a part-timer: days they CAN work. For a full-timer: days they're OFF — the
+     * mockup inverts the same array's meaning by employment type. */
+    availDays: boolean[];
+    availHours: EmployeeAvailHours[];
+    preferences: string;
+    primaryPosition: string;
+    secondaryPositions: string[];
+    seniority: '' | 'senior' | 'junior';
+    passcode: string[];
+    masterUser: boolean;
+    /** Required by the POS for a master user. */
+    masterCode: string;
+    /** Gates the fields below it — someone can be fully scheduled with this off. */
+    posAccessEnabled: boolean;
+    /** WHAT the passcode opens the till as, and WHERE — a row per outlet. Not restricted to the
+     * outlets picked in Work locations above: a floating manager can be rostered at one outlet
+     * and hold POS admin at several others. */
+    posRoles: {
+        outlet: string;
+        roleId: string;
+    }[];
+}
+/** A salaried month, for converting a monthly figure into the hourly one the cost rail
+ * actually reads. Ported verbatim from the mockup's MONTH_HOURS. */
+export declare const MONTH_HOURS = 173;
+/** A freshly-ticked worked day defaults to the whole day rather than the outlet's current
+ * trading hours — trading hours can change, and narrowing a person's stated availability to
+ * whatever the outlet happens to trade today isn't something this form should assume for them.
+ * `23:59`, not `24:00`: a part-timer's per-day fields are native `<input type="time">`s, which
+ * only accept `00:00`–`23:59` — `24:00` would render as blank there despite being a valid
+ * `FdtoScheduleTime` on the wire. */
+export declare function defaultAvailHours(): EmployeeAvailHours;
+export declare function blankForm(): ScheduleAddEmployeeForm;
+/** Coverage and Auto-Schedule are still authored per role, so a role is derived from the
+ * primary position rather than asked for twice. Unlike position, Employee.role is one of a
+ * fixed small set the grid groups by, so an unrecognised (or unset) position falls back to
+ * the first known role instead of leaving the record without one. */
+export declare function roleFromPosition(position: string): string;
+export declare function generateCode(): string;
+/** `raw` is typed `string` because that's the form field's declared type, but Vue 3 casts
+ * `v-model` on an `<input type="number">` to an actual `number` regardless — the DOM does this
+ * itself, independent of the `.number` modifier, so the runtime value disagrees with the type
+ * the moment someone types a digit. `String()` first is what makes `.trim()` safe either way. */
+export declare function parsePositiveInt(raw: string, min: number, max: number): number | undefined;
+export declare function parseNonNegativeInt(raw: string, max: number): number | undefined;
+export declare function initials(name: string): string;
+export declare function isPartTimeForm(form: ScheduleAddEmployeeForm): boolean;
+/** `availDays[i]` always means "is this a working day" — the same convention the board model
+ * and `ScheduleEmployeeDetailPanel` read (a day off is one marked NOT worked), regardless of
+ * employment type. Only the full-time TOGGLE BUTTON is framed as "mark a day off" rather than
+ * "mark a work day" — see `useScheduleAddEmployee`'s `dayLit`, which flips this value for
+ * that button's pressed state without touching what's actually stored. */
+export declare function dayIsWorkedInForm(form: ScheduleAddEmployeeForm, i: number): boolean;
+/** Days this form currently marks as worked, converted to Mongo's weekday convention. */
+export declare function availabilityPayload(form: ScheduleAddEmployeeForm): Array<{
+    dayOfWeek: number;
+    start: string;
+    end: string;
+}>;
+/** The EmployeeProfile fields `createExisting` and `updateExisting` both send — everything but
+ * `employeeId`, which only the create path has (an update targets one already known from the
+ * URL). Shared here so the two payloads cannot silently drift apart. */
+export declare function toEmployeeProfileFields(form: ScheduleAddEmployeeForm, name: string, payAmountNumber: number, t: (key: string) => string): FdtoScheduleUpdateEmployeeProfileReq;

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

@@ -0,0 +1,63 @@
+import type { DaySlot, Employee, LeaveSlot, WorkSlot } from '../types';
+import type { FdtoScheduleSaveAssignmentReq } from '@/types/schedule';
+export { isoDateKey } from './schedule-calendar';
+/** dayjs-free local-date key — matches on the browser's local Y/M/D, not UTC, so this stays
+ * correct regardless of timezone. */
+export declare function isWorkSlot(slot: DaySlot): slot is WorkSlot;
+export declare function isLeaveSlot(slot: DaySlot): slot is LeaveSlot;
+export declare function workSlotsOf(day: DaySlot): WorkSlot[];
+/** Whether two periods occupy any of the same working time. Endpoints that touch are
+ * back-to-back, not a conflict. Overnight ranges use the shared clock rules. */
+export declare function shiftsOverlap(a: Pick<WorkSlot, 'start' | 'end'>, b: Pick<WorkSlot, 'start' | 'end'>): boolean;
+export declare function overlapsAnotherSlot(slots: WorkSlot[], target: WorkSlot): boolean;
+/** The inverse of `workSlotsOf` — bare slot for one, the array for two or more, so a day
+ * that's back down to its last period reads as a normal single shift again rather than a
+ * one-element array everything else has to unwrap. */
+export declare function collapseSlots(slots: WorkSlot[]): WorkSlot | WorkSlot[] | null;
+/** Whether a day's periods are genuinely one shift split across a gap — same `splitGroupId`,
+ * set only by the popover's "+ Split" — versus two or more independent shifts that happen to
+ * land on the same day (a swap override, say). The card/popover both branch on this: a
+ * genuine split draws and edits as one shift; anything else stays separate, card per shift. */
+export declare function isGenuineSplitGroup(slots: WorkSlot[]): boolean;
+/** A WorkSlot, in the shape ScheduleShiftAssignments actually stores. `pending` is the only status
+ * this board's own writers ever set on a fresh slot (see commitShift's callers) — `ot` is
+ * derived at cost-rail time, never authored, so it has nowhere sensible to map but PUBLISHED. */
+export declare function toAssignmentReq(employeeId: string, date: string, slot: WorkSlot): FdtoScheduleSaveAssignmentReq;
+/** Which coverage-position (a RULES.coverage.full key, e.g. 'grill', 'customer service') a
+ * work slot's `role` counts toward for area-view grouping and cost-by-position breakdowns.
+ * The shift popover's "Position needed" field writes a coverage-position key directly into
+ * `role` for anything authored through it — so a role that's already a coverage key is
+ * used as-is. Seed data instead recorded a station label ('FOH', 'Kitchen', ...), which
+ * ROLE_POSITIONS translates to that station's first/primary position. This can't tell a
+ * Kitchen employee's grill shifts apart from their prep shifts when the seed data only
+ * ever recorded the station — that distinction only exists once a shift is authored (or
+ * re-saved) through the popover, which does record the specific position. */
+export declare function positionKeyOf(role: string): string;
+/** The hours this employee is contracted to in a week — what "18h / 44h" measures against.
+ * Stated per person on their own profile now that ScheduleSettings carries pay rates alone, so
+ * there is no venue-wide full/part pair to fall back to: somebody nobody has agreed hours with
+ * reads 0, which is the truth rather than a default they never signed. */
+export declare function contractCapFor(emp: Employee): number;
+/** Whether `hours` runs past what this person is contracted to.
+ *
+ * A cap of 0 means no hours were ever agreed, which is NOT a contract of zero hours: read
+ * naively, `hours > 0` makes every rostered minute overtime, flags everybody on the cost rail's
+ * over-contract list and makes copy-week refuse every shift. An unknown limit cannot be
+ * exceeded, so it is treated as no limit and the question is answered false. */
+export declare function overContract(emp: Employee, hours: number): boolean;
+export declare function isPartTime(emp: Employee): boolean;
+/** Colour keys off the POSITION's rank in the alphabetical position list, looped every six —
+ * position 7 repeats position 1's colour, which is expected once a page holds more than six.
+ * Unset ("Any position") isn't a real position at all, so it skips the rotation entirely and is
+ * always stone, the one of the seven neutral enough to read as "no position". A role no longer in
+ * the list (e.g. since deleted) falls back to the first band rather than erroring.
+ *
+ * Rotation by name, not a keyword lookup — a position is whatever the outlet typed into the
+ * Positions page, so there's no fixed vocabulary ("cashier", "kitchen", ...) to match against.
+ *
+ * Shared by the employee view's own card and the area view's position-row header + card, so the
+ * same position never disagrees on its colour anywhere on the board. */
+export declare function positionColorClass(role: string): string;
+/** Which weekday (0 = Mon) is today, relative to no particular week — used to seed
+ * focusDayIdx whenever "today" needs a weekday index rather than a date. */
+export declare function todayWeekdayIdx(): number;

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

@@ -0,0 +1,9 @@
+import type { FdtoScheduleBreak } from '@/types/schedule';
+import type { WorkSlot } from '../types';
+type BreakSource = FdtoScheduleBreak[] | Pick<WorkSlot, 'breaks' | 'breakMins'> | undefined;
+export declare function breakMinutesOf(source: BreakSource): number;
+/** Net paid minutes. Legacy board slots only have `breakMins`; persisted slots use the richer
+ * break array, so both representations pass through this function. */
+export declare function paidMinutesOf(slot: Pick<WorkSlot, 'start' | 'end' | 'breaks' | 'breakMins'>, gross?: number): number;
+export declare function durationBreaksOf(minutes: number | undefined): FdtoScheduleBreak[];
+export {};

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

@@ -0,0 +1,17 @@
+export declare const RANGE_LEN = 7;
+export declare function isoDateKey(date: Date): string;
+export declare function addDays(date: Date, days: number): Date;
+export declare function mostRecentMonday(from: Date): Date;
+export declare function weekDates(offset: number, from?: Date): Date[];
+export declare function weeksBetween(a: Date, b: Date): number;
+export declare function todayWeekdayIdx(): number;
+/** Monday-first weekday ids, matching the board's `dayIdx` (0 = Mon .. 6 = Sun). */
+export declare const WEEKDAY_IDS: readonly ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+/** i18n key of a weekday's short name ("Mon" / "จ."). */
+export declare function weekdayShortKey(dayIdx: number): string;
+/** i18n key of a weekday's full name ("Monday" / "วันจันทร์"). */
+export declare function weekdayLongKey(dayIdx: number): string;
+/** BCP 47 tag for `Intl`/`toLocale*String` from the active i18n locale. English keeps the
+ * board's existing format (`enFallback`); Thai stays on the Gregorian calendar so years line up
+ * with ISO dates shown elsewhere instead of switching to the Buddhist era. */
+export declare function intlLocale(locale: string | undefined, enFallback?: string): string;

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

@@ -0,0 +1,24 @@
+import type { Employee, WorkSlot } from '../types';
+export interface ScheduleCostBreakdown {
+    hours: number;
+    overtimeHours: number;
+    baseCost: number;
+    overtimeCost: number;
+    totalCost: number;
+}
+export declare function costOfSlot(slot: WorkSlot, rate: number, multiplier: number): {
+    hours: number;
+    cost: number;
+};
+/** Splits a sequence of paid shift minutes at the employee's contract line. This is the single
+ * overtime/cost calculation used by rails and exports; callers provide the applicable pay rate
+ * multiplier for each slot. */
+export declare function costOfSlots(employee: Employee, slots: Array<{
+    slot: WorkSlot;
+    multiplier: number;
+}>): ScheduleCostBreakdown;
+/** The slice of vue-i18n's `t` the format helpers below need, so pure modules can take it as a
+ * parameter instead of calling `useI18n()` themselves. */
+export type ScheduleTranslate = (key: string, named?: Record<string, unknown>) => string;
+/** "7h 30m" / "7 ชม. 30 น." — hours rendered as whole hours plus leftover minutes. */
+export declare function formatHoursMinutes(hours: number, t: ScheduleTranslate): string;

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

@@ -0,0 +1,22 @@
+import { type ComputedRef } from 'vue';
+interface CurrencyFormat {
+    label: string;
+    /** Where the label sits next to the number: "RM 3" vs "3 บาท" — how each market reads it. */
+    position: 'before' | 'after';
+}
+export declare function currencyFormatFor(country: string | null | undefined): CurrencyFormat;
+export declare function currencyLabelFor(country: string | null | undefined): string;
+/** Adds the label to an already-formatted number, on the side that market reads it. */
+export declare function withCurrency(value: string, format: CurrencyFormat): string;
+export interface ScheduleCurrency {
+    /** "RM" / "บาท", from the current business country (not the UI language). */
+    currency: ComputedRef<string>;
+    /** True when the label goes after the number (บาท), so input adornments flip sides. */
+    currencyAfter: ComputedRef<boolean>;
+    /** "RM 1,234" / "1,234 บาท" — rounded to whole units unless `fractionDigits` is given. */
+    formatMoney: (amount: number, fractionDigits?: number) => string;
+    /** Adds the currency label to a number that is already formatted. */
+    withCurrency: (value: string | number) => string;
+}
+export declare function useScheduleCurrency(): ScheduleCurrency;
+export {};

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

@@ -0,0 +1,21 @@
+import type { ScheduleDayNote } from '../types';
+/** Everything a manager authors about a DATE rather than about a shift — the note on its
+ * card, whether the venue opens, whether it bills at the holiday rate. Keyed by ISO date
+ * (via the board's `dateKey`), not by weekday index: the mockup's flat single-week horizon
+ * could use the weekday index directly, but the board pages through weeks, and a note put on
+ * this Monday must not reappear on every other Monday. */
+export declare function useScheduleDayMeta(dateKey: (dayIdx: number) => string | null, handlers?: {
+    onPersistError?: (message: string) => void;
+}): {
+    dayNote: (dayIdx: number) => ScheduleDayNote | null;
+    setDayNote: (dayIdx: number, title: string, desc: string, isPublicHoliday?: boolean) => void;
+    clearDayNote: (dayIdx: number) => void;
+    isStandingClosedWeekday: (dayIdx: number) => boolean;
+    holidayName: (dayIdx: number) => string | null;
+    isPublicHoliday: (dayIdx: number) => boolean;
+    holidayRateApplies: (dayIdx: number) => boolean;
+    setPublicHoliday: (dayIdx: number, on: boolean) => void;
+    otRateOn: (dayIdx: number) => number;
+    regularRateOn: (dayIdx: number) => number;
+    isHoliday: (dayIdx: number) => boolean;
+};

package/dist/src/views/scheduling/composables/schedule-demand-domain.d.ts

@@ -0,0 +1,23 @@
+import type { DemandPeriod, Employee } from '../types';
+import { format12h as t12, formatShortMinutes as minToShort, fromMinutes as minToHHMM, spanMinutes as spanOf, toMinutes as toMin } from './schedule-time';
+export { minToHHMM, minToShort, spanOf, t12, toMin };
+export declare function rangeText(from: number, to: number): string;
+export declare function roleTotalOf(period: DemandPeriod): number;
+/** The unnamed part of a period's headcount. Derived so it cannot disagree with the total. */
+export declare function anyLeftOf(period: DemandPeriod): number;
+export interface ScheduleCoverageAxis {
+    from: number;
+    to: number;
+}
+/** Fills named position rows from the people on, as a maximum matching (Kuhn's augmenting
+ * paths) so a flexible person is moved off one row when another row has nobody else. Rows are
+ * tried in the order given (scarcest first); within a row, main-position holders are offered
+ * first, then secondary holders, then people with no positions. Returns heads filled per row
+ * (same order as `rows`) and the ids spent. */
+export declare function matchSlots(rows: Array<{
+    position: string;
+    required: number;
+}>, on: Employee[], qualified: (e: Employee, position: string) => boolean): {
+    got: number[];
+    spent: Set<number>;
+};

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

@@ -0,0 +1,7 @@
+import type { Employee } from '../types';
+/** Adds `positionName` to the employee's own profile — the backend write path a real
+ * "existing employee" record has (see `useScheduleAddEmployee.ts`'s `toEmployeeProfileFields`
+ * for the same shape, built from the add-employee form instead of a live `Employee`).
+ * Fire-and-forget: the local roster already shows the grant, and a failed profile write isn't
+ * worth a second error dialog on top of whatever caller-side save this followed. */
+export declare function grantSkillToEmployee(emp: Employee, positionName: string): void;

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

@@ -0,0 +1 @@
+export declare function errorMessage(error: unknown, fallback: string): string;

package/dist/src/views/scheduling/composables/schedule-export-matrix.d.ts

@@ -0,0 +1,14 @@
+export interface ExportShiftCell {
+    note: string;
+    shifts: {
+        when: string;
+        pos: string;
+    }[];
+}
+export declare function esc(value: string | number): string;
+export declare function cellText(value: string | ExportShiftCell): string;
+export declare function dayCellLines(value: ExportShiftCell): {
+    text: string;
+    kind: 'note' | 'when' | 'pos';
+}[];
+export declare function dayHeaderLabel(date: Date, locale?: string): string;

package/dist/src/views/scheduling/composables/schedule-leave-split.d.ts

@@ -0,0 +1,9 @@
+import type { FdtoScheduleCreateTimeOffReq, FdtoScheduleTimeOff } from '@/types/schedule';
+import type { LeaveSlot } from '../types';
+/** The i18n key naming a leave slot's type, for display — `LeaveSlot.reason` stays English
+ * (other code matches on it). */
+export declare function timeOffLabelKey(slot: Pick<LeaveSlot, 'type' | 'leaveType'>): string;
+/** The create requests that keep the rest of a multi-day record alive once `date` is carved out
+ * of it. Single-day records leave nothing behind. The contract requires a same-day request to
+ * have matching parts, so a one-day remainder takes the part from its outer edge. */
+export declare function remainderRequests(record: FdtoScheduleTimeOff, date: string): FdtoScheduleCreateTimeOffReq[];

package/dist/src/views/scheduling/composables/schedule-popover-position.d.ts

@@ -0,0 +1,16 @@
+export interface ScheduleAnchorRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** Measures the element a popover was opened from. Takes the rect while the anchor is still on
+ * screen; a hidden or detached element measures 0×0 and counts as "no anchor". */
+export declare function anchorRectOf(el: Element | null | undefined): ScheduleAnchorRect | null;
+/** Port of HRM V6.2 placePopover(): below the anchor by preference (6px gap), flipped above when
+ * there is no room, clamped to the viewport on both edges. Uses the popover's rendered size, so
+ * call it once the element is in the DOM. */
+export declare function placePopover(el: HTMLElement, anchor: ScheduleAnchorRect | null): {
+    left: number;
+    top: number;
+};

package/dist/src/views/scheduling/composables/schedule-quick-pick.d.ts

@@ -0,0 +1,23 @@
+import type { CoverageSegment, Employee } from '../types';
+import type { ScheduleCoverageAxis } from './schedule-demand-domain';
+export interface QuickPickRules {
+    minHoursPerDay: number | null;
+    maxHoursPerDay: number | null;
+}
+export interface QuickPickCandidate {
+    start: string;
+    end: string;
+    /** Position name, or '' for any position. */
+    role: string;
+    /** Max short among the runs this shift covers. */
+    short: number;
+    label: string;
+    covers: string;
+    title: string;
+}
+export type QuickPickTranslate = (key: string, named?: Record<string, unknown>) => string;
+/** Up to 3 shifts for one employee on one day, built the way the auto-schedule planner builds
+ * them: one per (short run, position the person can fill), padded to their daily minimum,
+ * capped at their maximum, kept inside their availability window and clear of their existing
+ * shifts. Rest-gap and weekly-cap checks are left to the shift editor's own warnings. */
+export declare function buildQuickPicks(emp: Employee, dayIdx: number, segments: CoverageSegment[], axis: ScheduleCoverageAxis, rules: QuickPickRules, qualifiedFor: (emp: Employee, position: string) => boolean, t?: QuickPickTranslate): QuickPickCandidate[];

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

@@ -0,0 +1,29 @@
+import type { WorkSlot } from '../types';
+export type ScheduleBreakChoice = 0 | 30 | 60 | 90 | 120 | 'custom';
+export interface ScheduleShiftSegment {
+    start: string;
+    end: string;
+}
+/** The one break shape that names a clock window rather than just a duration — when present,
+ * the card reads as two periods around it, each on its own line, instead of one span that
+ * quietly got shorter. Shared by the employee view's own card and the area view's position-row
+ * card, so a TIME_RANGE break draws the same split face wherever a shift is shown. */
+export declare function timeRangeBreakOf(sl: WorkSlot): {
+    startTime: string;
+    endTime: string;
+} | null;
+/** The two visible paid periods around a custom clock-window break. Shared by Weekly cards and
+ * Daily timeline bars so the split wording cannot drift between views. */
+export declare function splitTimeLabels(sl: WorkSlot): [string, string] | null;
+/** Same face as `t12`, but never drops the minutes — two ranges stacked on a split card need
+ * to line up at a glance, and "10am" next to "10:30am" reads as two different units. */
+export declare function t12Full(hhmm: string): string;
+/** A break length that doesn't match one of the presets becomes 'custom', carrying its own
+ * minutes/unit back out for the caller to seed its custom-break fields from. */
+export declare function normalizeBreak(mins: number | undefined): {
+    choice: ScheduleBreakChoice;
+    customMins?: number;
+    customUnit?: 'mins' | 'hrs';
+};
+export declare function resolvedBreakMins(choice: ScheduleBreakChoice, customMins: number, customUnit: 'mins' | 'hrs'): number | undefined;
+export declare function segmentHours(seg: ScheduleShiftSegment, breakMins: number): number;

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

@@ -0,0 +1,8 @@
+/** Shared clock arithmetic for the scheduling board. All spans are minutes from midnight;
+ * an end at or before the start is treated as an overnight end on the following day. */
+export declare function toMinutes(value: string): number;
+export declare function fromMinutes(value: number): string;
+export declare function spanMinutes(start: string, end: string): [number, number];
+export declare function durationMinutes(start: string, end: string): number;
+export declare function format12h(value: string): string;
+export declare function formatShortMinutes(value: number): string;