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

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

@@ -6,7 +6,7 @@ export interface ScheduleDemandSuggestion {
     periods: DemandPeriod[];
 }
 export interface ScheduleDemandSheetOptions {
-    onToast?: (message: string) => void;
+    onToast?: (message: string, type?: 'info' | 'success' | 'error') => void;
     /** Positions the breakdown can name — the same list the shift editor offers. */
     positionOptions: () => string[];
     /** Called instead of a toast when "+ Position breakdown" is pressed and there is no position
@@ -14,8 +14,7 @@ export interface ScheduleDemandSheetOptions {
     onNeedPosition?: (periodIdx: number, roleIdx: number) => void;
 }
 /** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
- * real cancel. The sheet also carries the recurrence choice, because "every Tuesday" is a
- * property of the statement being made rather than a second screen. */
+ * real cancel. Apply scopes are expanded into explicit dates in the visible week. */
 export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand: ScheduleDemandApi, opts: ScheduleDemandSheetOptions): {
     open: import("vue").Ref<boolean, boolean>;
     dayIdx: import("vue").Ref<number | null, number | null>;
@@ -25,6 +24,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         n: number;
         roles?: {
             position: string;
+            positionId?: string | undefined;
             n: number;
         }[] | undefined;
     }[], DemandPeriod[] | {
@@ -33,6 +33,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         n: number;
         roles?: {
             position: string;
+            positionId?: string | undefined;
             n: number;
         }[] | undefined;
     }[]>;
@@ -65,10 +66,27 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     }[]>;
     toggleCustomDay: (i: number) => void;
     applyNote: import("vue").ComputedRef<string>;
+    replaceConfirmOpen: import("vue").ComputedRef<boolean>;
+    replaceConfirmTitle: import("vue").ComputedRef<"Replace existing demand?" | "Clear existing demand?">;
+    replaceConfirmActionLabel: import("vue").ComputedRef<"Confirm" | "Clear demand">;
+    replaceConfirmMessage: import("vue").ComputedRef<"Demand already exists on the dates below. Applying this demand will replace it on all selected dates." | "Demand exists on the dates below. Saving an empty time range will clear it on all selected dates.">;
+    replaceConfirmDates: import("vue").ComputedRef<string[]>;
+    confirmReplace: () => Promise<void>;
+    cancelReplace: () => void;
     overlapWarning: import("vue").ComputedRef<string>;
     whenLabel: import("vue").ComputedRef<string>;
     openFor: (idx: number) => void;
-    close: () => void;
+    close: (preserveDraft?: boolean) => void;
+    hasUnsavedChanges: import("vue").ComputedRef<boolean>;
+    diffSummary: import("vue").ComputedRef<{
+        changed: number;
+        added: number;
+        removed: number;
+        modified: number;
+    }>;
+    isPeriodChanged: (index: number) => boolean;
+    isPeriodFieldChanged: (index: number, field: "from" | "to" | "n") => boolean;
+    revert: () => void;
     addPeriod: () => void;
     removePeriod: (i: number) => void;
     setHeads: (i: number, value: number | string) => void;
@@ -105,6 +123,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
             n: number;
             roles?: {
                 position: string;
+                positionId?: string | undefined;
                 n: number;
             }[] | undefined;
         }[];
@@ -116,6 +135,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
             n: number;
             roles?: {
                 position: string;
+                positionId?: string | undefined;
                 n: number;
             }[] | undefined;
         }[];
@@ -126,6 +146,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         word: string;
     }[]>;
     suggest: () => void;
+    askRemy: () => Promise<void>;
     acceptSuggestion: () => void;
     dismissSuggestion: () => void;
     canCopy: import("vue").ComputedRef<boolean>;
@@ -140,6 +161,6 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     openCopy: () => void;
     closeCopy: () => void;
     confirmCopy: () => Promise<void>;
-    setApply: (k: DemandApplyMode) => DemandApplyMode;
+    setApply: (mode: DemandApplyMode) => void;
 };
 export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

package/dist/src/views/scheduling/composables/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 | Promise<void>;
+    onPrefillPosRoles: (employeeId: string) => void | Promise<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>;