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

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

@@ -0,0 +1,16 @@
+import type { Role } from '@/types/role';
+import { type ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+export declare function useScheduleEmployeeAccess(form: ScheduleAddEmployeeForm): {
+    passcodeValue: import("vue").ComputedRef<string>;
+    passcodeOk: import("vue").ComputedRef<boolean>;
+    setPasscodeDigit: (index: number, value: string) => void;
+    generatePasscode: () => void;
+    togglePosAccess: () => void;
+    addPosRoleRow: () => void;
+    removePosRoleRow: (index: number) => void;
+    isCurrentOutletRow: (index: number) => boolean;
+    setPosRoleOutlet: (index: number, outlet: string) => void;
+    setPosRoleId: (index: number, roleId: string) => void;
+    posRoleOptionsFor: (outlet: string) => Role[];
+    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.">;
+};

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

@@ -0,0 +1,13 @@
+import { type ComputedRef } from 'vue';
+import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+export declare function useScheduleEmployeeAvailability(form: ScheduleAddEmployeeForm, isPart: ComputedRef<boolean>): {
+    dayLit: (index: number) => boolean;
+    avLabel: ComputedRef<"Weekly availability" | "Time off days">;
+    avAllLabel: ComputedRef<"Clear all" | "Select all" | "No days off" | "Every day off">;
+    maxHoursPlaceholder: ComputedRef<string>;
+    ensureAvailHours: (index: number) => void;
+    toggleAvailDay: (index: number) => void;
+    availAll: () => void;
+    setAvailHour: (index: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (index: number) => void;
+};

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

@@ -0,0 +1,27 @@
+import { type ComputedRef } from 'vue';
+import type { ScheduleAddEmployeeForm, ScheduleAddEmployeeStep } from './schedule-add-employee-form';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+interface UseScheduleEmployeeCandidatesOptions {
+    board: ScheduleBoardApi;
+    form: ScheduleAddEmployeeForm;
+    currentLocationLabel: ComputedRef<string>;
+    step: {
+        value: ScheduleAddEmployeeStep;
+    };
+    open: {
+        value: boolean;
+    };
+    onPicked: (employeeId: string) => void;
+    onPrefillPasscode: (employeeId: string) => void;
+    onPrefillPosRoles: (employeeId: string) => void;
+}
+/** Directory lookup and profile prefill for the existing-employee path of the add wizard. */
+export declare function useScheduleEmployeeCandidates(options: UseScheduleEmployeeCandidatesOptions): {
+    selectExistingOpen: import("vue").Ref<boolean, boolean>;
+    candidatesLoading: import("vue").Ref<boolean, boolean>;
+    candidatesError: import("vue").Ref<string | null, string | null>;
+    openSelectExisting: () => void;
+    closeSelectExisting: () => void;
+    pickExisting: (employeeId: string) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+export declare function useScheduleEmployeeCompensation(form: ScheduleAddEmployeeForm): {
+    setPayBasis: (basis: "hourly" | "monthly") => void;
+    payUnit: import("vue").ComputedRef<"/month" | "/hour">;
+    payAmountNumber: import("vue").ComputedRef<number>;
+    effectiveRate: import("vue").ComputedRef<number>;
+};

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

@@ -0,0 +1,22 @@
+import { type Ref } from 'vue';
+import type { ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+interface UseScheduleEmployeeFormOptions {
+    form: ScheduleAddEmployeeForm;
+    currentLocationLabel: {
+        value: string;
+    };
+    positions: readonly string[];
+    locOpen: Ref<boolean>;
+    secOpen: Ref<boolean>;
+}
+/** Field editing for locations and positions in the employee wizard. */
+export declare function useScheduleEmployeeForm(options: UseScheduleEmployeeFormOptions): {
+    secondaryOptions: import("vue").ComputedRef<string[]>;
+    toggleMulti: (which: "loc" | "sec") => void;
+    toggleLocation: (location: string) => void;
+    removeLocation: (location: string) => void;
+    toggleSecondary: (position: string) => void;
+    removeSecondary: (position: string) => void;
+    setPrimaryPosition: (position: string) => void;
+};
+export {};

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

@@ -28,6 +28,15 @@ export interface ScheduleEmployeeLoad {
     /** The suggested part's width on the bar, as a fraction of contract. With no contract to measure
      * against it fills the track, so suggested hours still show. */
     proposedPct: number;
+    /** Of `boardPct`, how much is still DRAFT (unpublished) rather than confirmed — drawn as a
+     * hatch over the tail of the bar rather than a different colour, same as the grid's own
+     * closed-day treatment: the colour still says over/under contract, the hatch just adds
+     * "and part of this hasn't gone out to the employee yet" on top of it. */
+    draftPct: number;
+    /** Of `hours`, how many are on the board but still DRAFT (unpublished) — kept as its own
+     * number rather than folded into `hours` so the label can say "published + draft" instead
+     * of one merged total that can't tell the employee has actually seen only part of it. */
+    draftHours: number;
 }
 /** This person's live (not rejected) suggestions in the week on screen. */
 export declare function proposedSlotsOf(emp: Employee, proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined): Pick<Proposal, 'start' | 'end'>[];

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

@@ -1,6 +1,6 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleAnchorRect } from './schedule-popover-position';
-export type ScheduleEmployeeMenuAction = 'profile' | 'edit' | 'hl' | 'remove';
+export type ScheduleEmployeeMenuAction = 'profile' | 'edit' | 'freeall' | 'remove';
 export interface ScheduleEmployeeMenuState {
     open: boolean;
     empId: number | null;
@@ -8,11 +8,13 @@ export interface ScheduleEmployeeMenuState {
     left: number;
     top: number;
 }
-/** The ⋯ menu on a team member's row — V6.2's #empMenu: profile, update, highlight, remove. The actions that need a page-level surface (profile panel,
- * edit wizard, confirm dialog) come in as handlers; highlight lives here. */
+/** The ⋯ menu on a team member's row — V6.2's #empMenu: profile, update, clear shifts, remove.
+ * The actions that need a page-level surface (profile panel, edit wizard, confirm dialog) come in
+ * as handlers. */
 export declare function useScheduleEmployeeMenu(board: ScheduleBoardApi, handlers: {
     onProfile: (empId: number) => void;
     onEdit: (empId: number) => void;
+    onClearAllShifts: (empId: number) => void;
     onRemove: (empId: number) => void;
 }): {
     state: {
@@ -28,6 +30,7 @@ export declare function useScheduleEmployeeMenu(board: ScheduleBoardApi, handler
         top: number;
     };
     employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
+    hasShifts: import("vue").ComputedRef<boolean>;
     openFor: (empId: number, anchor: HTMLElement) => void;
     close: () => void;
     go: (action: ScheduleEmployeeMenuAction) => void;

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

@@ -0,0 +1,29 @@
+import type { ComputedRef, Ref } from 'vue';
+import { type ScheduleAddEmployeeForm } from './schedule-add-employee-form';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+interface UseScheduleEmployeePersistenceOptions {
+    form: ScheduleAddEmployeeForm;
+    pickedEmployeeId: Ref<string | null>;
+    payAmountNumber: ComputedRef<number>;
+    saving: Ref<boolean>;
+    saveError: Ref<string | null>;
+    close: () => void;
+    restaurantIdOfLabel: (label: string) => string | undefined;
+    board: ScheduleBoardApi;
+    editingEmployeeId: Ref<number | null>;
+    originalLocations: Ref<string[]>;
+    originalPosRoles: Ref<{
+        outlet: string;
+        roleId: string;
+    }[]>;
+    effectiveRate: ComputedRef<number>;
+    passcodeValue: ComputedRef<string>;
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}
+/** Persistence for an existing business employee being added to this schedule. */
+export declare function useScheduleEmployeePersistence(options: UseScheduleEmployeePersistenceOptions): {
+    createExisting: (name: string) => Promise<boolean>;
+    createNew: (name: string) => Promise<boolean>;
+    updateExisting: (name: string) => Promise<boolean>;
+};
+export {};

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

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

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

@@ -1,11 +1,5 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ExportShiftCell {
-    note: string;
-    shifts: {
-        when: string;
-        pos: string;
-    }[];
-}
+import type { ExportShiftCell } from './schedule-export-matrix';
 export interface ExportMatrix {
     head: string[];
     body: (string | ExportShiftCell)[][];
@@ -15,19 +9,33 @@ export interface ExportMatrix {
      * and a fully-staffed week with nobody over contract totals 0.0 there. */
     shiftTotal: number;
 }
+export { cellText, dayCellLines, dayHeaderLabel, esc } from './schedule-export-matrix';
+export type { ExportShiftCell } from './schedule-export-matrix';
 /** The mockup's Share/export feature (buildExportMatrix/exportPDF/exportJPG) — no external
- * PDF/canvas library anywhere in the mockup; PDF is an HTML preview handed to window.print(),
- * JPG is a hand-drawn Canvas 2D table converted with toBlob. */
+ * PDF/canvas library here; both PDF and JPG are the same hand-drawn Canvas 2D table
+ * (`buildJpgCanvas`). PDF used to be a separate HTML/`<table>` rendering handed to
+ * window.print(), but printing the live page and CSS-hiding everything around the sheet proved
+ * unreliable (see printNow's own comment) — "Save as PDF" now wraps that same canvas image into a
+ * standalone print window instead, so PDF and JPG are guaranteed to look identical. */
 export declare function useScheduleExport(board: ScheduleBoardApi): {
     buildExportMatrix: () => ExportMatrix;
     pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
-    pdfHtml: import("vue").ComputedRef<string>;
     pdfBarMeta: import("vue").ComputedRef<string>;
     openPdfPreview: () => void;
     closePdfPreview: () => void;
     printNow: () => void;
-    exportJpg: () => void;
+    jpgPreviewOpen: import("vue").Ref<boolean, boolean>;
+    jpgPreviewUrl: import("vue").Ref<string | null, string | null>;
+    jpgPreviewWidth: import("vue").Ref<number, number>;
+    jpgPreviewHeight: import("vue").Ref<number, number>;
+    jpgFilename: import("vue").Ref<string, string>;
+    jpgBarMeta: import("vue").ComputedRef<string>;
+    openJpgPreview: () => void;
+    closeJpgPreview: () => void;
+    saveJpgPreview: () => void;
     exportDoneOpen: import("vue").Ref<boolean, boolean>;
+    exportDoneTitle: import("vue").Ref<string, string>;
+    exportDoneDescription: import("vue").Ref<string, string>;
     exportDoneRecap: import("vue").Ref<{
         label: string;
         value: string;

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

@@ -1,11 +1,9 @@
 import type { CoverageSegment } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
-export interface ScheduleGapActions {
-    /** Open the shift editor on a brand new shift for this day and these hours. */
-    addShift: (dayIdx: number, position: string, start: string, end: string) => void;
-}
-export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi, actions: ScheduleGapActions): {
+/** The gap popover: what a striped stretch of the coverage bar means. Read-only — it states the
+ * shortfall and which positions are missing; nothing here writes. */
+export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
     state: {
         open: boolean;
         pinned: boolean;
@@ -23,6 +21,7 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
         over: number;
         roles: {
             position: string;
+            positionId?: string | undefined;
             n: number;
             required: number;
             got: number;
@@ -43,6 +42,7 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
         over: number;
         roles: {
             position: string;
+            positionId?: string | undefined;
             n: number;
             required: number;
             got: number;
@@ -74,7 +74,6 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
     hold: () => void;
     segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
     segFocus: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
-    addShift: () => void;
     close: () => void;
 };
 export type ScheduleGapPopoverApi = ReturnType<typeof useScheduleGapPopover>;

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

@@ -0,0 +1,58 @@
+import { type ComputedRef } from 'vue';
+import type { Employee } from '../types';
+import type { AvailRow, ScheduleOnboardingDayHours, TeamRow } from './onboarding-types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+type EmployeeRow = {
+    emp: Employee;
+    row: TeamRow;
+};
+type BulkMark = '' | 'y' | 'n';
+export interface ScheduleOnboardingAvailabilityOptions {
+    board: ScheduleBoardApi;
+    hours: ScheduleOnboardingDayHours[];
+    openDays: ComputedRef<number[]>;
+    employeeRows: ComputedRef<EmployeeRow[]>;
+    isShut: (dayIdx: number) => boolean;
+    pendingAvail: Map<number, Array<{
+        dayOfWeek: number;
+        start: string;
+        end: string;
+    }>>;
+}
+export declare function useScheduleOnboardingAvailability(options: ScheduleOnboardingAvailabilityOptions): {
+    avail: Record<number, AvailRow>;
+    avTab: import("vue").Ref<"full" | "part", "full" | "part">;
+    avPicked: Record<number, boolean>;
+    avVary: Record<number, boolean>;
+    avBulkOpen: import("vue").Ref<boolean, boolean>;
+    avBulk: {
+        off: BulkMark[];
+        on: BulkMark[];
+        from: string;
+        to: string;
+    };
+    seedAvailability: (missingOnly?: boolean) => void;
+    avFulls: ComputedRef<EmployeeRow[]>;
+    avParts: ComputedRef<EmployeeRow[]>;
+    avGroup: ComputedRef<EmployeeRow[]>;
+    avSelected: ComputedRef<EmployeeRow[]>;
+    restDays: (empId: number) => number[];
+    avFullDone: ComputedRef<number>;
+    avPartDone: ComputedRef<number>;
+    avOffCount: (dayIdx: number) => number | null;
+    avFullSub: (empId: number) => string;
+    avPartSummary: (empId: number) => string;
+    avShowsByDay: (empId: number) => boolean;
+    canDays: (empId: number) => number[];
+    avPickAll: (checked: boolean) => void;
+    toggleOff: (empId: number, dayIdx: number) => void;
+    toggleCan: (empId: number, dayIdx: number) => void;
+    setAvailTime: (empId: number, dayIdx: number | null, field: "from" | "to", value: string) => void;
+    toggleVary: (empId: number) => void;
+    bulkDay: (which: "off" | "on", dayIdx: number) => void;
+    avBulkReady: ComputedRef<boolean>;
+    applyAvBulk: () => void;
+    saveAvailability: () => void;
+};
+export type ScheduleOnboardingAvailabilityApi = ReturnType<typeof useScheduleOnboardingAvailability>;
+export {};

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

@@ -0,0 +1,45 @@
+import { type Ref } from 'vue';
+import type { ScheduleOnboardingDayHours, ScheduleOnboardingRange } from './onboarding-types';
+import type { SchedulePositionsApi } from './useSchedulePositions';
+export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>): {
+    demand: import("vue").Reactive<ScheduleOnboardingRange[][]>;
+    dmDay: Ref<number, number>;
+    staffingSaving: Ref<boolean, boolean>;
+    note: Ref<string, string>;
+    isShut: (dayIdx: number) => boolean;
+    dayClosedConfirm: {
+        state: {
+            open: boolean;
+            message: string;
+            title: string | null;
+            confirmLabel: string | null;
+            onConfirm: (() => void) | null;
+        };
+        ask: (message: string, onConfirm: () => void, opts?: {
+            title?: string;
+            confirmLabel?: string;
+        }) => void;
+        confirm: () => void;
+        close: () => void;
+    };
+    shutAcknowledged: Record<number, boolean>;
+    dmPeak: (dayIdx: number) => number;
+    namedPositions: import("vue").ComputedRef<string[]>;
+    remainingCommon: import("vue").ComputedRef<string[]>;
+    suggestedPositions: import("vue").ComputedRef<string[]>;
+    openDays: import("vue").ComputedRef<number[]>;
+    daysSet: import("vue").ComputedRef<number>;
+    daySpan: (dayIdx: number) => string;
+    seedDemand: () => void;
+    selectDay: (dayIdx: number) => void;
+    setRangeTime: (index: number, field: "from" | "to", value: string) => void;
+    setRangeCount: (index: number, value: string) => void;
+    addRange: () => void;
+    removeRange: (index: number) => void;
+    addRole: (index: number) => void;
+    setRole: (index: number, roleIndex: number, field: "position" | "n", value: string) => void;
+    removeRole: (index: number, roleIndex: number) => void;
+    namedTotal: (range: ScheduleOnboardingRange) => number;
+    copyDay: (mode: "all" | "wk" | "we") => void;
+};
+export type ScheduleOnboardingDemandApi = ReturnType<typeof useScheduleOnboardingDemand>;

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

@@ -0,0 +1,205 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { TeamBasis, TeamEmployment, TeamRow } from './onboarding-types';
+export interface ScheduleOnboardingEmployeesOptions {
+    board: ScheduleBoardApi;
+    note: {
+        value: string;
+    };
+}
+export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardingEmployeesOptions): {
+    team: Record<number, TeamRow>;
+    employeeRows: import("vue").ComputedRef<{
+        emp: {
+            id: number;
+            sourceId: string;
+            name: string;
+            employmentType: "FULLTIME" | "PARTTIME";
+            role: string;
+            initials: string;
+            color: string;
+            weekHours: number;
+            pct: number;
+            contractHours?: number | undefined;
+            rate: number;
+            positions: string[];
+            archivedPositions?: string[] | undefined;
+            shifts: ({
+                start: string;
+                end: string;
+                role: string;
+                positionId?: string | undefined;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
+                assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
+                splitGroupId?: string | undefined;
+            } | {
+                timeOff: "approved" | "pending";
+                requestId?: string | undefined;
+                type?: "OFF_DAY" | "LEAVE" | undefined;
+                leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+                reason: string;
+                half?: boolean | undefined;
+                halfPart?: "AM" | "PM" | undefined;
+                from?: string | undefined;
+                to?: string | undefined;
+                appliedOn?: string | undefined;
+                note?: string | undefined;
+                cert?: {
+                    name: string;
+                    size: string;
+                } | null | undefined;
+                bal?: {
+                    type: string;
+                    entitled: number;
+                    used: number;
+                } | undefined;
+            } | {
+                start: string;
+                end: string;
+                role: string;
+                positionId?: string | undefined;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
+                assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
+                splitGroupId?: string | undefined;
+            }[] | null)[];
+            remarks: {
+                author: string;
+                date: string;
+                type: "note" | "warning" | "praise";
+                text: string;
+            }[];
+            section: string;
+            compGroup?: string | undefined;
+            mobile?: string | undefined;
+            dial?: string | undefined;
+            locations?: string[] | undefined;
+            payBasis?: "hourly" | "monthly" | undefined;
+            payAmount?: number | undefined;
+            maxHours?: number | undefined;
+            minHours?: number | undefined;
+            minHoursPerDay?: number | undefined;
+            workingHours?: {
+                minHoursPerDay: number | null;
+                maxHoursPerDay: number | null;
+                maxHoursPerWeek: number | null;
+            } | undefined;
+            overtime?: {
+                maxHoursPerMonth: number | null;
+            } | undefined;
+            preferences?: string[] | undefined;
+            seniority?: "senior" | "junior" | "" | undefined;
+            availDays?: boolean[] | undefined;
+            availHours?: {
+                from: string;
+                to: string;
+            }[] | undefined;
+            passcode?: string | undefined;
+            masterUser?: boolean | undefined;
+        };
+        row: TeamRow;
+    }[]>;
+    employeePicked: import("vue").ComputedRef<number>;
+    employeeAllPicked: import("vue").ComputedRef<boolean>;
+    employeeSomePicked: import("vue").ComputedRef<boolean>;
+    pendingTeam: Set<number>;
+    pendingAvail: Map<number, {
+        dayOfWeek: number;
+        start: string;
+        end: string;
+    }[]>;
+    rawEmployee: (empId: number) => {
+        overtime?: {
+            maxHoursPerMonth: number | null;
+        } | undefined;
+        minHoursPerDay?: number | null | undefined;
+        workingHours?: {
+            minHoursPerDay: number | null;
+            maxHoursPerDay: number | null;
+            maxHoursPerWeek: number | null;
+        } | undefined;
+        name: string;
+        employeeId: string;
+        employmentType: "FULLTIME" | "PARTTIME";
+        wage: {
+            type: "HOURLY" | "MONTHLY";
+            amount: number;
+        };
+        primaryPosition: {
+            positionId: string;
+            positionName: string;
+        } | null;
+        secondaryPositions: {
+            positionId: string;
+            positionName: string;
+        }[];
+        availability: {
+            dayOfWeek: number;
+            start: string;
+            end: string;
+        }[];
+    } | undefined;
+    seedEmployees: (missingOnly?: boolean) => void;
+    pickAll: (checked: boolean) => void;
+    setPosition: (empId: number, value: string) => void;
+    setEmployment: (empId: number, kind: TeamEmployment) => void;
+    setHours: (empId: number, value: string) => void;
+    setRate: (empId: number, value: string) => void;
+    bulkOpen: import("vue").Ref<boolean, boolean>;
+    bulk: {
+        scope: "all" | "full" | "part" | "nopos" | "nopay";
+        position: string;
+        second: string;
+        employment: "" | TeamEmployment;
+        maxHours: string;
+        rate: string;
+        basis: "" | TeamBasis;
+    };
+    bulkCount: import("vue").ComputedRef<number>;
+    applyBulk: () => void;
+    BULK_NONE: string;
+    validateEmployees: () => string | null;
+    saveEmployees: () => void;
+    note: {
+        value: string;
+    };
+};
+export type ScheduleOnboardingEmployeesApi = ReturnType<typeof useScheduleOnboardingEmployees>;

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

@@ -0,0 +1,15 @@
+import type { ScheduleOnboardingDayHours } from './onboarding-types';
+export declare const MAX_OPERATIONAL_SESSIONS = 2;
+export declare function useScheduleOnboardingHours(): {
+    hours: import("vue").Reactive<ScheduleOnboardingDayHours[]>;
+    profileSnapshot: import("vue").Ref<string, string>;
+    hoursSnapshot: () => string;
+    hoursMatchProfile: import("vue").ComputedRef<boolean>;
+    openDayCount: import("vue").ComputedRef<number>;
+    resetHours: () => void;
+    toggleDay: (dayIdx: number) => void;
+    addSession: (dayIdx: number) => void;
+    removeSession: (dayIdx: number, sessionIdx: number) => void;
+    setSessionTime: (dayIdx: number, sessionIdx: number, field: "from" | "to", value: string) => void;
+};
+export type ScheduleOnboardingHoursApi = ReturnType<typeof useScheduleOnboardingHours>;

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

@@ -0,0 +1,11 @@
+import type { ScheduleOnboardingStep } from './onboarding-types';
+export declare function useScheduleOnboardingNavigation(): {
+    step: import("vue").Ref<ScheduleOnboardingStep, ScheduleOnboardingStep>;
+    stepIndex: import("vue").ComputedRef<number>;
+    isFirstStep: import("vue").ComputedRef<boolean>;
+    isLastStep: import("vue").ComputedRef<boolean>;
+    totalSteps: number;
+    steps: ScheduleOnboardingStep[];
+    isSkippable: import("vue").ComputedRef<boolean>;
+};
+export type ScheduleOnboardingNavigationApi = ReturnType<typeof useScheduleOnboardingNavigation>;