@feedmepos/mf-hrm-portal 2.3.0-dev.9 → 2.3.1-dev.1

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

@@ -5,6 +5,7 @@ import type { useScheduleStatsRow } from '../composables/useScheduleStatsRow';
 import type { ScheduleDayTimelineApi } from '../composables/useScheduleDayTimeline';
 import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
 import type { ScheduleAreaDragDropApi } from '../composables/useScheduleAreaDragDrop';
+import type { ScheduleDragDropApi } from '../composables/useScheduleDragDrop';
 type ScheduleLegendApi = ReturnType<typeof useScheduleLegend>;
 type ScheduleStatsRowApi = ReturnType<typeof useScheduleStatsRow>;
 type __VLS_Props = {
@@ -15,6 +16,10 @@ type __VLS_Props = {
     dayTimeline: ScheduleDayTimelineApi;
     roster: ScheduleRosterApi;
     areaDragDrop: ScheduleAreaDragDropApi;
+    shiftDragDrop: ScheduleDragDropApi;
+    onDropEmployee: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPosition: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPositionCell: (position: string, event: DragEvent) => void;
     mode: 'employee' | 'area';
     onScroll: (delta: number) => void;
     onComingSoon: () => void;

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

@@ -6,6 +6,7 @@ import type { SchedulePositionModalApi } from '../composables/useSchedulePositio
 import type { ScheduleShiftActionsApi } from '../composables/useScheduleShiftActions';
 import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
 import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSchedule';
+import type { ScheduleTourApi } from '../composables/useScheduleTour';
 import type { ScheduleDemandSheetApi } from '../composables/useScheduleDemandSheet';
 type ScheduleEmployeeProfileApi = ReturnType<typeof useScheduleEmployeeProfile>;
 type __VLS_Props = {
@@ -17,6 +18,7 @@ type __VLS_Props = {
     shiftActions: ScheduleShiftActionsApi;
     popover: ScheduleShiftPopoverApi;
     autoSchedule: ScheduleAutoScheduleApi;
+    tour: ScheduleTourApi;
     demandSheet: ScheduleDemandSheetApi;
     removeEmployeeOpen: boolean;
     removeEmployeeName: string;

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

@@ -18,6 +18,7 @@ type __VLS_Props = {
     clearTitle: string;
     clearMessage: string;
     clearConfirmLabel: string;
+    clearLoading: boolean;
     onConfirmClear: () => void;
     onCloseClear: () => void;
 };

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

@@ -22,7 +22,6 @@ type __VLS_Props = {
     filterBar: ScheduleFilterBarApi;
     outlet: ScheduleOutletApi;
     roster: ScheduleRosterApi;
-    loading: boolean;
     error: string | null;
     onSchedStatusClick: () => void;
     onComingSoon: () => void;

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

@@ -4,7 +4,7 @@ import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSche
 import type { ScheduleExportApi } from '../composables/useScheduleExport';
 import type { SchedulePublishApi } from '../composables/useSchedulePublish';
 type __VLS_Props = {
-    kind: 'onboarding' | 'tour' | 'export' | 'publish-share';
+    kind: 'onboarding' | 'tour' | 'auto-schedule' | 'export' | 'publish-share';
     wizard?: ScheduleOnboardingWizardApi;
     tour?: ScheduleTourApi;
     autoSchedule?: ScheduleAutoScheduleApi;

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

@@ -2,6 +2,7 @@ type __VLS_Props = {
     open: boolean;
     title: string;
     message: string;
+    affectedDates?: string[];
     /** `clash-q` gives the message an orange warning-callout background instead of plain text —
      * used by the "might conflict" dialog, kept as an opt-in rather than the default look. */
     messageClass?: string;
@@ -10,6 +11,7 @@ type __VLS_Props = {
      * consequence of pressing the button. Omitted entirely when there's nothing to point to. */
     note?: string;
     confirmLabel?: string;
+    loading?: boolean;
     cancelLabel?: string;
     tone?: 'primary' | 'danger';
     /** The "!" mark is for dialogs guarding something irreversible — a reversible action
@@ -24,9 +26,8 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     onConfirm?: (() => any) | undefined;
 }>, {
     icon: boolean;
-    confirmLabel: string;
-    tone: "primary" | "danger";
+    loading: boolean;
     messageClass: string;
-    cancelLabel: string;
+    tone: "primary" | "danger";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -2,11 +2,16 @@ import type { ScheduleDayTimelineApi } from '../composables/useScheduleDayTimeli
 import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
 import type { ScheduleViewMode } from '../composables/useScheduleFilterBar';
 import type { ScheduleAreaDragDropApi } from '../composables/useScheduleAreaDragDrop';
+import type { ScheduleDragDropApi } from '../composables/useScheduleDragDrop';
 type __VLS_Props = {
     timeline: ScheduleDayTimelineApi;
     roster: ScheduleRosterApi;
     mode: ScheduleViewMode;
     dragDrop?: ScheduleAreaDragDropApi;
+    shiftDragDrop?: ScheduleDragDropApi;
+    onDropEmployee?: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPosition?: (employeeId: number, event: DragEvent, slotIndex?: number) => void;
+    onDropPositionCell?: (position: string, event: DragEvent) => void;
 };
 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/ScheduleLoadState.vue.d.ts

@@ -1,5 +1,4 @@
 type __VLS_Props = {
-    loading: boolean;
     error: string | null;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

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

@@ -0,0 +1,6 @@
+import type { ScheduleOnboardingWizardApi } from '../composables/useScheduleOnboardingWizard';
+type __VLS_Props = {
+    wizard: ScheduleOnboardingWizardApi;
+};
+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/ScheduleShiftPopover.vue.d.ts

@@ -1,6 +1,6 @@
 import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
 import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
-import type { ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
+import { type ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
 type __VLS_Props = {
     board: ScheduleBoardApi;
     popover: ScheduleShiftPopoverApi;

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

@@ -1,4 +1,4 @@
-import type { FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoSchedulePlanner, FdtoScheduleAutoScheduleProposal, FdtoScheduleAutoScheduleResult } from '@/types/schedule';
+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). */
@@ -8,7 +8,9 @@ export declare function dateOfProposal(weekKey: string, dayIdx: number): string;
  * 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): FdtoScheduleAutoScheduleApplyReq;
+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;
@@ -21,13 +23,13 @@ export declare function classifyExplanation(line: string): ClassifiedExplanation
  * (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): string;
+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): FdtoScheduleAutoScheduleResult;
+}, 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, requested: FdtoScheduleAutoSchedulePlanner, wallMs: number): string;
+export declare function generateDoneMessage(result: FdtoScheduleAutoScheduleResult, wallMs: number, t: TranslateFn): string;

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

@@ -3,3 +3,5 @@ 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-types.d.ts

@@ -23,7 +23,8 @@ export interface TeamRow {
     picked: boolean;
     /** '' means "Any position" — a person with none. */
     position: string;
-    second: string;
+    /** Additional positions this employee also covers. */
+    second: string[];
     employment: TeamEmployment;
     maxHours: string;
     rate: string;

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

@@ -8,6 +8,8 @@ export type RemyDemandScope = {
 } | {
     mode: 'weekdays';
 };
-/** The sentence prefilled into the host Remy panel. Names the outlet the way a manager knows it;
- * Remy resolves it to an id itself (hrm_find_outlet), so no identifier appears in the text. */
+/** 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

@@ -79,4 +79,4 @@ export declare function availabilityPayload(form: ScheduleAddEmployeeForm): Arra
 /** 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): FdtoScheduleUpdateEmployeeProfileReq;
+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

@@ -6,6 +6,10 @@ export { isoDateKey } from './schedule-calendar';
 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. */

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

@@ -5,3 +5,13 @@ 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

@@ -17,3 +17,8 @@ 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

@@ -8,14 +8,12 @@ export declare function useScheduleDayMeta(dateKey: (dayIdx: number) => string |
     onPersistError?: (message: string) => void;
 }): {
     dayNote: (dayIdx: number) => 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;

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

@@ -1,4 +1,4 @@
-import type { DemandPeriod } from '../types';
+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;
@@ -9,3 +9,15 @@ 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-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

@@ -11,4 +11,4 @@ export declare function dayCellLines(value: ExportShiftCell): {
     text: string;
     kind: 'note' | 'when' | 'pos';
 }[];
-export declare function dayHeaderLabel(date: Date): string;
+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-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

@@ -12,6 +12,9 @@ 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;

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

@@ -4,4 +4,6 @@ export interface WeekBucket {
     employees: Employee[];
     openShifts: OpenShift[];
 }
-export declare function weekData(offset: number): WeekBucket;
+/** `from` is the date the offset is relative to (the board passes the Monday it anchored on, so a
+ * tab left open past midnight keeps building the week it is showing). */
+export declare function weekData(offset: number, from?: Date): WeekBucket;

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

@@ -2,6 +2,7 @@ import { useAppStore } from '@feedmepos/mf-remy-panel';
 export interface RemyActivateOptions {
     prompt?: string;
     forceNewConversation?: boolean;
+    fullscreen?: boolean;
 }
 /** HRM never bundles or mounts a Remy panel of its own — `@feedmepos/mf-remy-panel` is externalised
  * by the shared vite preset, so inside the host portal this import resolves to the ONE panel

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

@@ -52,22 +52,21 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     secondaryOptions: import("vue").ComputedRef<string[]>;
     isPart: import("vue").ComputedRef<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">;
+    avLabel: import("vue").ComputedRef<string>;
+    avAllLabel: import("vue").ComputedRef<string>;
     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">;
+    payUnit: import("vue").ComputedRef<string>;
     effectiveRate: import("vue").ComputedRef<number>;
     passcodeValue: import("vue").ComputedRef<string>;
     passcodeOk: import("vue").ComputedRef<boolean>;
     currentLocationLabel: import("vue").ComputedRef<string>;
     locationOptions: import("vue").Reactive<string[]>;
-    masterCodeError: import("vue").ComputedRef<boolean>;
     isNewUser: import("vue").ComputedRef<boolean>;
-    footerHint: import("vue").ComputedRef<"Pick who — this outlet's own pay, position and hours are still set here." | "One short form. Rest days are set on their profile afterwards.">;
+    footerHint: import("vue").ComputedRef<string>;
     primaryRoleLabel: import("vue").ComputedRef<string>;
     locationsSummary: import("vue").ComputedRef<string>;
     payLine: import("vue").ComputedRef<string>;
@@ -77,10 +76,30 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     availabilityError: import("vue").ComputedRef<boolean>;
     saving: import("vue").Ref<boolean, boolean>;
     saveError: import("vue").Ref<string | null, string | null>;
+    deferScheduleWrites: 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>;
+    candidates: import("vue").Ref<{
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[], import("../types").ExistingStaffCandidate[] | {
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[]>;
+    candidatesTotal: import("vue").Ref<number, number>;
+    candidatesPage: import("vue").Ref<number, number>;
+    candidatesPageItemCount: import("vue").Ref<number, number>;
+    candidatesPageSize: number;
+    searchExisting: (search: string) => void;
+    goToExistingPage: (page: number, search: string) => void;
     openWizard: (section: string) => void;
     openEditFor: (emp: Employee) => void;
+    confirmClose: () => void;
     close: () => void;
     setMode: (m: ScheduleAddEmployeeMode) => void;
     openSelectExisting: () => void;
@@ -100,7 +119,8 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     setAvailHour: (index: number, field: "from" | "to", value: string) => void;
     copyAvailHourDown: (index: number) => void;
     setPasscodeDigit: (index: number, value: string) => void;
-    generatePasscode: () => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
     togglePosAccess: () => void;
     addPosRoleRow: () => void;
     removePosRoleRow: (index: number) => void;
@@ -108,7 +128,10 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?
     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.">;
+    isPosRoleUsable: (role: import("../../../types/role").Role) => boolean;
+    setMasterUserRoleAccess: (roleIds: string[] | null | undefined) => void;
+    isPosOutletUsable: (outlet: string) => boolean;
+    posRolesHint: import("vue").ComputedRef<string>;
     create: () => Promise<boolean>;
 };
 export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -1,5 +1,6 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type QuickPickCandidate } from './schedule-quick-pick';
 import { type ScheduleAnchorRect } from './schedule-popover-position';
 export interface ScheduleAddPickState {
     open: boolean;
@@ -13,17 +14,10 @@ export interface ScheduleAddPickState {
 }
 export interface ScheduleAddPickLeaveOption {
     reason: string;
+    /** i18n key for the row's label — `reason` itself is an id and stays English. */
+    labelKey: string;
     swatch: string;
 }
-export interface ScheduleAddPickSuggestion {
-    start: string;
-    end: string;
-    short: number;
-    label: string;
-    /** "Covers 16:00–22:00 demand" — the demand this offer answers, shown under the label. */
-    covers: string;
-    title: string;
-}
 /** The "+ Add" quick-pick popover on an employee's empty cell — ported from the mockup's
  * openAddShiftPicker()/renderAddPickList(), scoped to what this board actually has: our one
  * active shift pattern, a fixed leave-reason list, and a demand-gap suggestion, all committed
@@ -57,7 +51,7 @@ export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: Sche
         start: string;
         end: string;
     } | null>;
-    suggested: import("vue").ComputedRef<ScheduleAddPickSuggestion | null>;
+    suggestions: import("vue").ComputedRef<QuickPickCandidate[]>;
     filteredPatterns: import("vue").ComputedRef<{
         key: string;
         label: string;
@@ -71,7 +65,7 @@ export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: Sche
     hasResults: import("vue").ComputedRef<boolean>;
     openFor: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
     close: () => void;
-    pickSuggested: () => void;
+    pickSuggested: (index: number) => void;
     pickPattern: (key: string) => void;
     pickTypedRange: (start: string, end: string) => void;
     pickLeave: (reason: string) => void;

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

@@ -2,7 +2,6 @@ import type { ScheduleBoardApi } from './useScheduleBoard';
 /** 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;
 }): {
     draggingEmpId: import("vue").Ref<number | null, number | null>;
     startRailDrag: (empId: number) => void;