@feedmepos/mf-hrm-portal 2.2.5-dev.5 → 2.2.5-dev.7

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

@@ -0,0 +1,6 @@
+import type { ScheduleExportApi } from '../composables/useScheduleExport';
+type __VLS_Props = {
+    exportApi: ScheduleExportApi;
+};
+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/SchedulePublishModal.vue.d.ts

@@ -0,0 +1,8 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { SchedulePublishApi } from '../composables/useSchedulePublish';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    publish: SchedulePublishApi;
+};
+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/ScheduleReviewBar.vue.d.ts

@@ -0,0 +1,12 @@
+import type { ScheduleAutoScheduleApi } from '../composables/useScheduleAutoSchedule';
+type __VLS_Props = {
+    autoSchedule: ScheduleAutoScheduleApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    applied: (count: number) => any;
+    appliedAndPublish: (count: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onApplied?: ((count: number) => any) | undefined;
+    onAppliedAndPublish?: ((count: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,24 @@
+/** One row of the menu. `group` heads the rows that carry it — consecutive options sharing
+ * a group are drawn under one heading, the way an `<optgroup>` would. A disabled option is a
+ * statement rather than a choice ("No position yet" is the field saying the catalogue is
+ * empty), so it is dimmed and inert rather than offered and refused. */
+export interface ScheduleSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+declare const _default: import("vue").DefineComponent<{
+    modelValue: string;
+    options: ScheduleSelectOption[];
+    disabled?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue: string;
+    options: ScheduleSelectOption[];
+    disabled?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

@@ -0,0 +1,12 @@
+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, {
+    editShift: (empId: number, dayIdx: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEditShift?: ((empId: number, dayIdx: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,31 @@
+import type { DaySlot, Proposal } from '../types';
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    slot: DaySlot;
+    empId: number;
+    dayIdx: number;
+    /** Position in the VISIBLE column order — month-edge is a neighbour comparison. */
+    colIndex: number;
+    proposal?: Proposal | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    drop: (empId: number, dayIdx: number, ev: DragEvent) => any;
+    addShift: (empId: number, dayIdx: number, anchor: HTMLElement) => any;
+    editShift: (empId: number, dayIdx: number) => any;
+    editLeave: (empId: number, dayIdx: number) => any;
+    dragStart: (empId: number, dayIdx: number, ev: DragEvent) => any;
+    dragEnd: () => any;
+    openMenu: (empId: number, dayIdx: number, anchor: HTMLElement) => any;
+    toggleProposal: (id: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDrop?: ((empId: number, dayIdx: number, ev: DragEvent) => any) | undefined;
+    onAddShift?: ((empId: number, dayIdx: number, anchor: HTMLElement) => any) | undefined;
+    onEditShift?: ((empId: number, dayIdx: number) => any) | undefined;
+    onEditLeave?: ((empId: number, dayIdx: number) => any) | undefined;
+    onDragStart?: ((empId: number, dayIdx: number, ev: DragEvent) => any) | undefined;
+    onDragEnd?: (() => any) | undefined;
+    onOpenMenu?: ((empId: number, dayIdx: number, anchor: HTMLElement) => any) | undefined;
+    onToggleProposal?: ((id: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,6 @@
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+type __VLS_Props = {
+    popover: ScheduleShiftPopoverApi;
+};
+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/ScheduleShiftImpact.vue.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+type __VLS_Props = {
+    popover: ScheduleShiftPopoverApi;
+};
+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/ScheduleShiftMoreOptions.vue.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+type __VLS_Props = {
+    popover: ScheduleShiftPopoverApi;
+};
+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

@@ -0,0 +1,14 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+import type { ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    popover: ScheduleShiftPopoverApi;
+    timePicker: ScheduleTimePickerApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    swap: (empId: number, dayIdx: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSwap?: ((empId: number, dayIdx: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,8 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    popover: ScheduleShiftPopoverApi;
+};
+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/ScheduleShiftSegmentsEditor.vue.d.ts

@@ -0,0 +1,8 @@
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+import { type ScheduleTimePickerApi } from '../composables/useScheduleTimePicker';
+type __VLS_Props = {
+    popover: ScheduleShiftPopoverApi;
+    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/ScheduleShiftWhoPicker.vue.d.ts

@@ -0,0 +1,25 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleShiftPopoverApi } from '../composables/useScheduleShiftPopover';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    popover: ScheduleShiftPopoverApi;
+    /** "Empty shift — leave it open" reads as a real option when this shift is free to stay
+     * unstaffed. A shift authored to answer a specific coverage gap has no such reading — it
+     * does nothing for that gap unstaffed — so its caller passes a placeholder that asks
+     * for a pick instead of offering to skip one. */
+    placeholder?: string;
+    /** Pairs with the placeholder above: the blank option itself becomes unpickable, so
+     * there's no way back to "nobody" once this select is showing. */
+    forceChoice?: boolean;
+    /** In the header this picker IS the heading — a name-sized control with an avatar next
+     * to it. Reused lower down as one field among Hours and Headcount, it has to take
+     * their treatment instead: a bordered, row-sized select with no avatar, since nobody
+     * is picked yet on a shift still being created. */
+    compact?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    placeholder: string;
+    compact: boolean;
+    forceChoice: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleAllShiftsRowApi } from '../composables/useScheduleAllShiftsRow';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    row: ScheduleAllShiftsRowApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    editShift: (empId: number, dayIdx: number) => any;
+    openAssign: (openId: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEditShift?: ((empId: number, dayIdx: number) => any) | undefined;
+    onOpenAssign?: ((openId: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,16 @@
+import type { ScheduleStaffRailApi } from '../composables/useScheduleStaffRail';
+import type { ScheduleAreaDragDropApi } from '../composables/useScheduleAreaDragDrop';
+type __VLS_Props = {
+    rail: ScheduleStaffRailApi;
+    dragDrop: ScheduleAreaDragDropApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    addEmployee: () => any;
+    jumpToOpen: () => any;
+    openEmployee: (empId: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAddEmployee?: (() => any) | undefined;
+    onJumpToOpen?: (() => any) | undefined;
+    onOpenEmployee?: ((empId: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,54 @@
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleRosterApi } from '../composables/useScheduleRoster';
+import type { ScheduleOpenShiftCardApi } from '../composables/useScheduleOpenShiftCard';
+import type { ScheduleAllShiftsRowApi } from '../composables/useScheduleAllShiftsRow';
+import type { ScheduleDemandRowApi } from '../composables/useScheduleDemandRow';
+type __VLS_Props = {
+    board: ScheduleBoardApi;
+    roster: ScheduleRosterApi;
+    openShiftCard: ScheduleOpenShiftCardApi;
+    allShiftsRow: ScheduleAllShiftsRowApi;
+    demandRow: ScheduleDemandRowApi;
+    proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    addShift: (empId: number, dayIdx: number, anchor: HTMLElement) => any;
+    editShift: (empId: number, dayIdx: number) => any;
+    editLeave: (empId: number, dayIdx: number) => any;
+    dragEnd: () => any;
+    toggleProposal: (id: number) => any;
+    openAssign: (openId: number) => any;
+    openOpenShiftMenu: (openId: number, anchor: HTMLElement) => any;
+    addOpenShift: (dayIdx: number) => 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;
+    openEmployeeMenu: (empId: number) => any;
+    dragShiftStart: (empId: number, dayIdx: number, ev: DragEvent) => any;
+    dropOnCell: (empId: number, dayIdx: number, ev: DragEvent) => any;
+    openCardMenu: (empId: number, dayIdx: number, anchor: HTMLElement) => any;
+    addEmployee: () => any;
+    openDemandSheet: (dayIdx: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAddShift?: ((empId: number, dayIdx: number, anchor: HTMLElement) => any) | undefined;
+    onEditShift?: ((empId: number, dayIdx: number) => any) | undefined;
+    onEditLeave?: ((empId: number, dayIdx: number) => any) | undefined;
+    onDragEnd?: (() => any) | undefined;
+    onToggleProposal?: ((id: number) => any) | undefined;
+    onOpenAssign?: ((openId: number) => any) | undefined;
+    onOpenOpenShiftMenu?: ((openId: number, anchor: HTMLElement) => any) | undefined;
+    onAddOpenShift?: ((dayIdx: number) => 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;
+    onOpenEmployeeMenu?: ((empId: number) => any) | undefined;
+    onDragShiftStart?: ((empId: number, dayIdx: number, ev: DragEvent) => any) | undefined;
+    onDropOnCell?: ((empId: number, dayIdx: number, ev: DragEvent) => any) | undefined;
+    onOpenCardMenu?: ((empId: number, dayIdx: number, anchor: HTMLElement) => any) | undefined;
+    onAddEmployee?: (() => 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,22 @@
+import type { ScheduleBoardApi } from '../composables/useScheduleBoard';
+import type { ScheduleTopbarApi } from '../composables/useScheduleTopbar';
+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, {
+    "dev-reset": () => any;
+    "sched-status-click": () => any;
+    "clear-shifts": () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onDev-reset"?: (() => any) | undefined;
+    "onSched-status-click"?: (() => any) | undefined;
+    "onClear-shifts"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,67 @@
+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;
+    otAfterDaily: string;
+    maxOtHours: 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;
+}
+/** 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): FdtoScheduleUpdateEmployeeProfileReq;

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

@@ -0,0 +1,38 @@
+import type { DaySlot, Employee, LeaveSlot, WorkSlot } from '../types';
+import type { FdtoScheduleSaveAssignmentReq } from '@/types/schedule';
+/** 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 isoDateKey(d: Date): string;
+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[];
+/** A WorkSlot, in the shape ShiftAssignments 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;
+/** 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-day-meta.d.ts

@@ -0,0 +1,29 @@
+import { type Ref } from 'vue';
+import type { Employee, 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(employees: Ref<Employee[]>, dateKey: (dayIdx: number) => string | null, handlers?: {
+    onPersistError?: (message: string) => void;
+}): {
+    dayNote: (dayIdx: number) => ScheduleDayNote | null;
+    setDayNote: (dayIdx: number, title: string, desc: string) => void;
+    clearDayNote: (dayIdx: number) => void;
+    toggleClosed: (dayIdx: number) => {
+        closed: boolean;
+        rostered: number;
+    };
+    isManuallyClosed: (dayIdx: number) => boolean;
+    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;
+};

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-shift-time.d.ts

@@ -0,0 +1,14 @@
+export type ScheduleBreakChoice = 0 | 30 | 60 | 90 | 120 | 'custom';
+export interface ScheduleShiftSegment {
+    start: string;
+    end: 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-week-cache.d.ts

@@ -0,0 +1,10 @@
+import type { Employee, OpenShift } from '../types';
+export declare const RANGE_LEN = 7;
+export declare function mostRecentMonday(from: Date): Date;
+export declare function weekDates(offset: number): Date[];
+export declare function weeksBetween(a: Date, b: Date): number;
+export interface WeekBucket {
+    employees: Employee[];
+    openShifts: OpenShift[];
+}
+export declare function weekData(offset: number): WeekBucket;

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

@@ -0,0 +1,86 @@
+import type { Employee } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import { type ScheduleAddEmployeeMode, type ScheduleAddEmployeeStep } from './schedule-add-employee-form';
+export type { ScheduleAddEmployeeForm, ScheduleAddEmployeeMode, ScheduleAddEmployeeStep, } from './schedule-add-employee-form';
+/** 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): {
+    open: import("vue").Ref<boolean, boolean>;
+    selectExistingOpen: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleAddEmployeeStep, ScheduleAddEmployeeStep>;
+    mode: import("vue").Ref<ScheduleAddEmployeeMode, ScheduleAddEmployeeMode>;
+    form: {
+        name: string;
+        mobile: string;
+        dial: string;
+        employment: "full" | "part";
+        locations: string[];
+        payBasis: "hourly" | "monthly";
+        payAmount: string;
+        maxHours: string;
+        otAfterDaily: string;
+        maxOtHours: string;
+        availDays: boolean[];
+        availHours: {
+            from: string;
+            to: string;
+        }[];
+        preferences: string;
+        primaryPosition: string;
+        secondaryPositions: string[];
+        seniority: "" | "senior" | "junior";
+        passcode: string[];
+        masterUser: boolean;
+    };
+    sectionId: import("vue").Ref<string, string>;
+    isEditing: import("vue").ComputedRef<boolean>;
+    locOpen: import("vue").Ref<boolean, boolean>;
+    secOpen: import("vue").Ref<boolean, boolean>;
+    secondaryOptions: import("vue").ComputedRef<string[]>;
+    isPart: import("vue").ComputedRef<boolean>;
+    dayLit: (i: 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>;
+    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
+    effectiveRate: import("vue").ComputedRef<number>;
+    passcodeValue: import("vue").ComputedRef<string>;
+    passcodeOk: 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.">;
+    primaryRoleLabel: import("vue").ComputedRef<string>;
+    locationsSummary: import("vue").ComputedRef<string>;
+    payLine: import("vue").ComputedRef<string>;
+    nameError: import("vue").ComputedRef<boolean>;
+    passError: import("vue").ComputedRef<boolean>;
+    availabilityError: import("vue").ComputedRef<boolean>;
+    saving: import("vue").Ref<boolean, boolean>;
+    saveError: import("vue").Ref<string | null, string | null>;
+    candidatesLoading: import("vue").Ref<boolean, boolean>;
+    candidatesError: import("vue").Ref<string | null, string | null>;
+    openWizard: (section: string) => void;
+    openEditFor: (emp: Employee) => void;
+    close: () => void;
+    setMode: (m: ScheduleAddEmployeeMode) => void;
+    openSelectExisting: () => void;
+    closeSelectExisting: () => void;
+    pickExisting: (employeeId: string) => void;
+    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;
+    setPayBasis: (basis: "hourly" | "monthly") => void;
+    toggleAvailDay: (i: number) => void;
+    availAll: () => void;
+    setAvailHour: (i: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (i: number) => void;
+    setPasscodeDigit: (i: number, value: string) => void;
+    generatePasscode: () => void;
+    create: () => Promise<boolean>;
+};
+export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;