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

package/dist/src/api/audit-log/index.d.ts

@@ -12,6 +12,9 @@ declare const AuditLogAPI: {
         search?: string;
         searchUserIds?: string[];
         searchSubjects?: string[];
+        sources?: string[];
+        restaurantIds?: string[];
+        traceId?: string;
     }): Promise<number>;
     read(params?: {
         limit?: number;
@@ -27,6 +30,9 @@ declare const AuditLogAPI: {
         search?: string;
         searchUserIds?: string[];
         searchSubjects?: string[];
+        sources?: string[];
+        restaurantIds?: string[];
+        traceId?: string;
     }): Promise<AuditLogEntry[]>;
     /**
      * FeedMe-admin options for the User filter. `actors` is the named admin list (internal

package/dist/src/api/employee/index.d.ts

@@ -1,14 +1,13 @@
 import { FdtoUpdatePosUserReq, FdtoUpdatePosMasterUserReq } from '@feedmepos/core/entity';
-import type { Employee, IFdtoEmployeePage, IFdtoPosUser, IReadEmployeesPageReq } from '@/types/employee';
+import type { Employee, IFdtoEmployeePage, IReadEmployeesPageReq } from '@/types/employee';
 export interface IGeneratePasscodeParams {
     restaurantIds: string[];
     excludePosUserId?: string;
 }
 declare const EmployeeAPI: {
-    readEmployees(): Promise<IFdtoPosUser[]>;
     readEmployeesPage(query: IReadEmployeesPageReq): Promise<IFdtoEmployeePage>;
-    createEmployee(dto: FdtoUpdatePosUserReq): Promise<void>;
-    createMasterEmployee(dto: FdtoUpdatePosMasterUserReq): Promise<void>;
+    createEmployee(dto: FdtoUpdatePosUserReq): Promise<string>;
+    createMasterEmployee(dto: FdtoUpdatePosMasterUserReq): Promise<string>;
     migrateToMasterEmployee(employeeId: string, dto: FdtoUpdatePosMasterUserReq): Promise<void>;
     updateEmployee(employeeId: string, dto: FdtoUpdatePosUserReq): Promise<void>;
     updateMasterEmployee(employeeId: string, dto: FdtoUpdatePosMasterUserReq): Promise<void>;

package/dist/src/api/my-pos-profile/index.d.ts

@@ -1,5 +1,3 @@
-import type { FdtoMyPosPasscode, FdtoMyPosProfile, FdtoRegenerateMyPosPasscodeRes } from '@/types/my-pos-profile';
+import type { FdtoMyPosProfile, FdtoRegenerateMyPosPasscodeRes } from '@/types/my-pos-profile';
 export declare const readMyPosProfile: () => Promise<FdtoMyPosProfile>;
-/** D50: the signed-in user's own current passcode. */
-export declare const readMyPosPasscode: () => Promise<FdtoMyPosPasscode>;
 export declare const regenerateMyPosPasscode: () => Promise<FdtoRegenerateMyPosPasscodeRes>;

package/dist/src/api/restaurant/index.d.ts

@@ -1,5 +1,7 @@
 import type { HrmRestaurant } from '@/types/restaurant';
+import type { FdtoScheduleDayOperatingHours } from '@feedmepos/hrm-schedule-contract';
 declare const RestaurantAPI: {
     readRestaurants(): Promise<HrmRestaurant[]>;
+    saveOperationalHours(restaurantId: string, operatingHours: FdtoScheduleDayOperatingHours[]): Promise<void>;
 };
 export default RestaurantAPI;

package/dist/src/api/schedule/index.d.ts

@@ -0,0 +1,68 @@
+import type { FdtoScheduleAssignment, FdtoScheduleAutoScheduleApplyReq, FdtoScheduleAutoScheduleApplyResult, FdtoScheduleAutoScheduleCapabilities, FdtoScheduleAutoScheduleGenerateReq, FdtoScheduleAutoScheduleResult, FdtoScheduleBoard, FdtoScheduleBulkUpdateAssignmentStatusReq, FdtoScheduleBulkSaveAssignmentsReq, FdtoScheduleBulkSaveAssignmentsResult, FdtoScheduleBulkReplaceDemandReq, FdtoScheduleClearScheduleReq, FdtoScheduleCopyScheduleReq, FdtoScheduleCreateEmployeeProfileReq, FdtoScheduleEmployeeConfig, FdtoScheduleDemand, FdtoScheduleEmployee, FdtoSchedulePosition, FdtoScheduleSaveAssignmentReq, FdtoScheduleSaveDemandReq, FdtoScheduleSaveEmployeeConfigsReq, FdtoScheduleSavePositionReq, FdtoScheduleSaveScheduleDayReq, FdtoScheduleSaveSettingsReq, FdtoScheduleReplaceDemandReq, FdtoScheduleSettings, FdtoScheduleScheduleDay, FdtoScheduleUpdateEmployeeProfileReq, FdtoScheduleCompleteOnboardingReq, FdtoScheduleValidatePosAccessReq, FdtoScheduleCreateTimeOffReq, FdtoScheduleTimeOff, FdtoScheduleUpdateTimeOffStatusReq } from '@/types/schedule';
+declare const ScheduleAPI: {
+    completeOnboarding(restaurantId: string, req: FdtoScheduleCompleteOnboardingReq): Promise<any>;
+    listEmployeeProfiles(employeeIds?: string[]): Promise<FdtoScheduleEmployee[]>;
+    listEmployeeConfigs(restaurantId: string): Promise<FdtoScheduleEmployeeConfig[]>;
+    saveEmployeeConfigs(restaurantId: string, req: FdtoScheduleSaveEmployeeConfigsReq): Promise<FdtoScheduleEmployeeConfig[]>;
+    getSettings(restaurantId: string): Promise<FdtoScheduleSettings>;
+    saveSettings(restaurantId: string, req: FdtoScheduleSaveSettingsReq): Promise<FdtoScheduleSettings>;
+    generateAutoSchedule(restaurantId: string, req: FdtoScheduleAutoScheduleGenerateReq): Promise<FdtoScheduleAutoScheduleResult>;
+    getAutoScheduleCapabilities(restaurantId: string): Promise<FdtoScheduleAutoScheduleCapabilities>;
+    applyAutoSchedule(restaurantId: string, req: FdtoScheduleAutoScheduleApplyReq): Promise<FdtoScheduleAutoScheduleApplyResult>;
+    /** One outlet's whole board over `[from, to]` (inclusive, 'YYYY-MM-DD'). */
+    readBoard(restaurantId: string, from: string, to: string): Promise<FdtoScheduleBoard>;
+    createTimeOff(restaurantId: string, req: FdtoScheduleCreateTimeOffReq): Promise<FdtoScheduleTimeOff>;
+    updateTimeOffStatus(restaurantId: string, id: string, req: FdtoScheduleUpdateTimeOffStatusReq): Promise<FdtoScheduleTimeOff | null>;
+    deleteTimeOff(restaurantId: string, id: string): Promise<void>;
+    /** Creates or updates the employee's shared business-level scheduling profile. */
+    createEmployeeProfile(_restaurantId: string, req: FdtoScheduleCreateEmployeeProfileReq): Promise<FdtoScheduleEmployee>;
+    /** Edits the employee's shared business-level scheduling profile. */
+    updateEmployeeProfile(_restaurantId: string, employeeId: string, req: FdtoScheduleUpdateEmployeeProfileReq): Promise<FdtoScheduleEmployee>;
+    validatePosAccess(req: FdtoScheduleValidatePosAccessReq): Promise<void>;
+    /** Positions are shared across the business. */
+    createPosition(req: FdtoScheduleSavePositionReq): Promise<FdtoSchedulePosition>;
+    updatePosition(id: string, req: FdtoScheduleSavePositionReq): Promise<FdtoSchedulePosition>;
+    /** Deleting one position is `deletePositions` with a single-id array — the backend's
+     * `DELETE positions/:id` route is gone; this is now `DELETE positions?ids=`. */
+    deletePosition(id: string): Promise<void>;
+    /** Creates one flat demand interval. */
+    createDemand(restaurantId: string, req: FdtoScheduleSaveDemandReq): Promise<FdtoScheduleDemand>;
+    /** Deletes a batch of demands in one request — e.g. `saveDemand` replacing a whole
+     * day/weekday's demand rows wholesale. Deleting one demand is just this with a single-id
+     * array. */
+    deleteDemands(restaurantId: string, ids: string[]): Promise<{
+        ok: true;
+        deletedCount: number;
+    }>;
+    /** Atomically replaces one date/weekday's flattened demand rows. */
+    replaceDemands(restaurantId: string, req: FdtoScheduleReplaceDemandReq): Promise<FdtoScheduleDemand[]>;
+    /** Atomically replaces several date/weekday demand generations. */
+    bulkReplaceDemands(restaurantId: string, req: FdtoScheduleBulkReplaceDemandReq): Promise<FdtoScheduleDemand[]>;
+    /** Replaces one date's note/holiday-mark. All three fields back to empty/false clears it. */
+    saveScheduleDay(restaurantId: string, date: string, req: FdtoScheduleSaveScheduleDayReq): Promise<FdtoScheduleScheduleDay | null>;
+    /** A one-off shift assignment. */
+    createAssignment(restaurantId: string, req: FdtoScheduleSaveAssignmentReq): Promise<FdtoScheduleAssignment>;
+    updateAssignment(restaurantId: string, id: string, req: FdtoScheduleSaveAssignmentReq): Promise<FdtoScheduleAssignment | null>;
+    /** Atomically applies assignment updates, creates, and deletes used by moves and swaps. */
+    bulkSaveAssignments(restaurantId: string, req: FdtoScheduleBulkSaveAssignmentsReq): Promise<FdtoScheduleBulkSaveAssignmentsResult>;
+    /** Replaces demand and/or assignments in one backend transaction. */
+    copySchedule(restaurantId: string, req: FdtoScheduleCopyScheduleReq): Promise<any>;
+    /** Clears demand and/or assignments in one backend transaction. */
+    clearSchedule(restaurantId: string, req: FdtoScheduleClearScheduleReq): Promise<any>;
+    /** Deletes a batch of assignments in one request — e.g. a shift split into several segments
+     * getting replaced wholesale. Deleting one assignment is just this with a single-id
+     * array. */
+    deleteAssignments(restaurantId: string, ids: string[]): Promise<{
+        ok: true;
+        deletedCount: number;
+    }>;
+    /** Removes all assignments for an employee from the inclusive removal date onward. */
+    deleteEmployeeFutureAssignments(restaurantId: string, employeeId: string, from: string): Promise<{
+        ok: true;
+        deletedCount: number;
+    }>;
+    /** Flips a batch of assignments to one status in a single request — e.g. Publish sending
+     * every DRAFT shift on the board to PUBLISHED at once. */
+    bulkUpdateAssignmentStatus(restaurantId: string, req: FdtoScheduleBulkUpdateAssignmentStatusReq): Promise<FdtoScheduleAssignment[]>;
+};
+export default ScheduleAPI;

package/dist/src/api/sso-provider/index.d.ts

@@ -0,0 +1,5 @@
+import type { IFdtoSsoProvider } from '@/types/sso-provider';
+declare const SsoProviderAPI: {
+    readProviders(): Promise<IFdtoSsoProvider[]>;
+};
+export default SsoProviderAPI;

package/dist/src/api/staff-invite/index.d.ts

@@ -1,6 +1,5 @@
-import type { IFdtoCreateStaffInviteReq, IFdtoCreateStaffInviteRes, IFdtoResendStaffInviteRes, IFdtoStaffInvite, IFdtoStaffInviteLookup, IFdtoStaffInviteProvider, IFdtoUpdateStaffInviteReq } from '@/types/staff-invite';
+import type { IFdtoCreateStaffInviteReq, IFdtoCreateStaffInviteRes, IFdtoResendStaffInviteRes, IFdtoStaffInvite, IFdtoStaffInviteLookup, IFdtoUpdateStaffInviteReq } from '@/types/staff-invite';
 declare const StaffInviteAPI: {
-    readProviders(): Promise<IFdtoStaffInviteProvider[]>;
     readInvites(status?: IFdtoStaffInvite["status"]): Promise<IFdtoStaffInvite[]>;
     lookup(key: {
         mobile: string;

package/dist/src/api/timesheet/index.d.ts

@@ -1,6 +1,6 @@
 import type { IFdtoTimesheet, UpdateTimesheetDTO } from '@/types/timesheet';
 declare const TimesheetAPI: {
-    readTimesheets(startIso: string, endIso: string): Promise<IFdtoTimesheet[]>;
+    readTimesheets(startIso: string, endIso: string, restaurantIds?: string[]): Promise<IFdtoTimesheet[]>;
     updateTimesheet(restaurantId: string, dto: UpdateTimesheetDTO): Promise<void>;
 };
 export default TimesheetAPI;

package/dist/src/components/AppForm.vue.d.ts

@@ -12,7 +12,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         default: undefined;
     };
     required: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
         default: boolean;
     };
     inline: {
@@ -25,7 +25,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         default: undefined;
     };
     required: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
         default: boolean;
     };
     inline: {

package/dist/src/components/CheckboxInput.vue.d.ts

@@ -44,7 +44,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         required: true;
     };
     showAllToggle: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
         default: boolean;
     };
     includeDisabledOptionsWhenSelectAll: {
@@ -99,7 +99,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         required: true;
     };
     showAllToggle: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
         default: boolean;
     };
     includeDisabledOptionsWhenSelectAll: {

package/dist/src/components/layout/PortalShell.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/layout/SchedulePromoBanner.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/layout/withScheduleShell.d.ts

@@ -0,0 +1,10 @@
+import { type Component } from 'vue';
+/** Wrap a scheduling route in the layout needed by the scheduling board's full-bleed CSS. */
+export declare function withScheduleShell(Comp: Component): {
+    inheritAttrs: boolean;
+    setup(_: unknown, { attrs }: {
+        attrs: Record<string, unknown>;
+    }): () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+};

package/dist/src/composables/useDiscardConfirm.d.ts

@@ -1 +1,3 @@
-export declare function useDiscardConfirm(isModified: () => boolean, onConfirm: () => void): () => void;
+export declare function useDiscardConfirm(isModified: () => boolean, onConfirm: () => void, options?: {
+    zIndex?: number;
+}): () => void;

package/dist/src/composables/useMessage.d.ts

@@ -1,4 +1,10 @@
+import { SnackbarPosition } from '@feedmepos/ui-library';
+export interface MessageOptions {
+    /** Where the snackbar is anchored. Defaults to the library's own default (top-right). */
+    position?: SnackbarPosition;
+}
 export declare function useMessage(): {
-    success: (message: string) => void;
-    error: (message: string) => void;
+    success: (message: string, options?: MessageOptions) => void;
+    error: (message: string, options?: MessageOptions) => void;
 };
+export { SnackbarPosition };

package/dist/src/composables/useSsoProviders.d.ts

@@ -0,0 +1,19 @@
+import type { IFdtoSsoProvider } from '@/types/sso-provider';
+export declare function useSsoProviders(): {
+    providers: import("vue").Ref<{
+        slug: string;
+        label: string;
+        type: string;
+        enabled: boolean;
+        inviteMatch: import("../types/staff-invite").StaffInviteMatch | "none";
+    }[], IFdtoSsoProvider[] | {
+        slug: string;
+        label: string;
+        type: string;
+        enabled: boolean;
+        inviteMatch: import("../types/staff-invite").StaffInviteMatch | "none";
+    }[]>;
+    isLoaded: import("vue").ComputedRef<boolean>;
+    loadProviders: () => Promise<void>;
+    providerLabel: (slug: string) => string;
+};

package/dist/src/composables/useStaffInviteProviders.d.ts

@@ -1,16 +1,5 @@
-import type { IFdtoStaffInviteProvider } from '@/types/staff-invite';
 export declare function useStaffInviteProviders(): {
-    providers: import("vue").Ref<{
-        slug: string;
-        label: string;
-        type: string;
-        inviteMatch: import("@/types/staff-invite").StaffInviteMatch;
-    }[], IFdtoStaffInviteProvider[] | {
-        slug: string;
-        label: string;
-        type: string;
-        inviteMatch: import("@/types/staff-invite").StaffInviteMatch;
-    }[]>;
+    providers: import("vue").ComputedRef<import("../types/staff-invite").IFdtoStaffInviteProvider[]>;
     isLoaded: import("vue").ComputedRef<boolean>;
     hasProviders: import("vue").ComputedRef<boolean>;
     canInvite: import("vue").ComputedRef<boolean>;

package/dist/src/helpers/permission-set.d.ts

@@ -1,21 +1,5 @@
 import type { InheritedPermission, IFdtoPermissionSet } from '@/types/permission-set';
-import type { FdoPermissionRule } from '@feedmepos/core/entity';
-/**
- * Recursively collect all permission sets following permissionSetIds links.
- * Returns a flat, deduplicated list in depth-first order (parent before children).
- * Cycle-safe via the visited set.
- */
-export declare function collectAllPermissionSets(setIds: string[], allSets: IFdtoPermissionSet[], visited?: Set<string>): IFdtoPermissionSet[];
-/**
- * Compute the effective permissions from a list of permission sets.
- *
- * Unlike a raw `mergePermissionSet().map(...)`, this correctly handles sets that store
- * override diffs (inverted rules): it first merges all grants and denials from the sets,
- * then applies the denials on top of the grants via `getEffectivePermissions`, producing a
- * clean list of effective grants only. This ensures that subjects removed by a child set's
- * inversion are not incorrectly shown as granted.
- */
-export declare function mergeToEffectivePermissions(sets: IFdtoPermissionSet[]): FdoPermissionRule[];
+export { collectAllPermissionSets, mergeToEffectivePermissions, getOverridePermissions, materializeSystemPermissionSetOverrides, stripSystemExpandedPositives, REPORT_SUBJECT_PREFIX, filterStalePermissions, filterRedundantReportPermissions, getEffectivePermissions, getEditorPermissions, } from '@feedmepos/hrm-permission/utils';
 /**
  * Transform permission sets by grouping role names by collection IDs for a specific field
  * @param permissionSets - Array of permission sets with their permissions
@@ -24,88 +8,3 @@ export declare function mergeToEffectivePermissions(sets: IFdtoPermissionSet[]):
  * @returns Array of objects containing collection ID and associated role names
  */
 export declare function transformByCollection(permissionSets: IFdtoPermissionSet[], field: string, resourceIds: string[]): InheritedPermission[];
-/**
- * Combine base permissions (permissions set) with user permissions
- * @param basePermissions - Base permissions
- * @param overridePermissions - User permissions
- * @returns Combined permissions
- * Return combined result with below criteria:
- * - If base has it and user doesn't, return base permission with { inverted: true }
- * - If user has it and base doesn't, return user permission
- * - If base and user has it, nothing return
- * For permission with conditions (collection: warehouses, roles, restaurants)
- * - If base conditions different from user conditions, return rule with { inverted: true } and conditions on collection ids to be denied
- * - If base has conditions and user doesn't, return base with { inverted: true } without conditions, essentially denied all access
- * - If user has conditions and base doesn't, return user's rule (user added)
- */
-export declare function getOverridePermissions(basePermissions: FdoPermissionRule[], overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];
-export declare function materializeSystemPermissionSetOverrides(overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];
-/**
- * Strip positive rules whose subject would be re-injected by system permission set expansion.
- * These need not be persisted to DB — expansion re-adds them at runtime.
- *
- * Also strips inverted rules for subjects that are ONLY reachable as non-manage via permissions[]
- * leaf injection. Such inverted rules cannot block permissions[] injection (only visitedSetIds/
- * permissionSets[] expansion is blockable), are useless, and cause a CASL side-effect where an
- * inverted `manage` rule inadvertently blocks `read` access.
- *
- * Inverted rules targeting subjects reachable as `manage` (via permissionSets[] chaining) are
- * always preserved — they seed visitedSetIds to block system set re-expansion.
- */
-export declare function stripSystemExpandedPositives(permissions: FdoPermissionRule[]): FdoPermissionRule[];
-export declare const REPORT_SUBJECT_PREFIX = "business::report::";
-/**
- * Filter out stale report permission rules.
- *
- * Only rules whose subject starts with `business::report::` are candidates for removal —
- * any other subject (restaurant, role, warehouse, etc.) passes through untouched.
- * A report-prefixed subject is kept only if it exists in `knownReportSubjects`.
- *
- * This handles:
- * - Deprecated/renamed subjects (e.g. `business::report::closeup` → `business::report::reports::closeup`)
- * - Deleted dynamic reports that no longer exist
- */
-export declare function filterStalePermissions(permissions: FdoPermissionRule[], knownReportSubjects: Set<string>): FdoPermissionRule[];
-/**
- * Strip individual-report actions already covered by an `allDefaultReports` or
- * `allCustomReports` positive grant, preventing redundant data from being saved.
- *
- * - If the cover rule has `manage` selected → every individual rule in that bucket is
- *   fully covered and dropped entirely only when the cover condition also covers the
- *   individual rule.
- * - Otherwise, only covered non-manage actions are stripped from individual rules when
- *   the cover condition also covers the individual rule.
- *   `manage` is a real CASL wildcard grant that implies every action, not merely a
- *   shorthand for "all non-manage actions selected" — a rule carrying `manage` is
- *   pushed through UNCHANGED (a cover lacking `manage` cannot cover it). Stripping its
- *   constituent actions and then dropping `manage` would destroy the user's grant.
- *   Rules that end up with no remaining actions are dropped.
- *
- * Inverted rules and the cover subjects themselves pass through untouched.
- *
- * @param defaultReportSubjects  Full set of subjects in the "Default Report" UI category —
- *   includes static hardcoded subjects AND dynamic reports with `isDefault: true`.
- *   Built by the caller from `portalTeamPermissions` + `customReportPermissions`.
- */
-export declare function filterRedundantReportPermissions(permissions: FdoPermissionRule[], defaultReportSubjects: Set<string>): FdoPermissionRule[];
-/**
- * Combine base permissions with override permissions to get effective permissions
- * @param basePermissions - Base permissions from permission sets
- * @param overridePermissions - Override permissions from permission user
- * @returns - Combined effective permissions
- */
-export declare function getEffectivePermissions(basePermissions: FdoPermissionRule[], overridePermissions: FdoPermissionRule[]): FdoPermissionRule[];
-/**
- * Compute the initial permissions for the permission editor.
- *
- * Like `getEffectivePermissions`, but also preserves "orphaned" inverted rules — denials whose
- * subject is NOT present in any base permission set (i.e. they target system-expanded subjects,
- * not permission-set-inherited subjects). These denials seed `visitedSetIds` in
- * `expandWithSystemPermissionSets` to block runtime re-expansion of system sets that the user
- * explicitly unchecked. Without them the editor would initialize without the denial guard and
- * those subjects would reappear as checked the next time the form opens.
- *
- * Inverted rules whose subject IS in base are handled correctly by `getEffectivePermissions`
- * already (they cancel the inherited grant) and do not need special treatment here.
- */
-export declare function getEditorPermissions(basePermissions: FdoPermissionRule[], customPermissions: FdoPermissionRule[]): FdoPermissionRule[];

package/dist/src/helpers/pos-assignment-rows.d.ts

@@ -17,6 +17,8 @@ export declare function toRows(roles: IFdtoPermissionPosUserRole[]): PosAssignme
 export declare function toRoles(rows: PosAssignmentRow[]): IFdtoPermissionPosUserRole[];
 export declare function sameRoles(a: IFdtoPermissionPosUserRole[], b: IFdtoPermissionPosUserRole[]): boolean;
 export declare function restaurantLabel(restaurant: HrmRestaurant): string;
+/** The row's outlets as one line for its select field, in the order the list shows them. */
+export declare function rowRestaurantSummary(restaurants: HrmRestaurant[], row: PosAssignmentRow): string;
 /** Outlets for a row; one already in another row can't be picked twice. */
 export declare function rowRestaurantOptions(restaurants: HrmRestaurant[], rows: PosAssignmentRow[], index: number): SelectOption[];
 /** Roles that exist at every outlet of the row; unusable ones stay visible but disabled. */

package/dist/src/helpers/rule.d.ts

@@ -1,5 +1,6 @@
 import type { RawRule } from '@casl/ability';
 import { F_RULE_SUBJECT, type FdoPermissionRule } from '@feedmepos/core/entity';
+import { getManagableRestaurantIds, usableRoleIds } from '@feedmepos/hrm-permission/utils';
 import type { Rule } from '../types/role';
 export declare function filterPermissions(permissions: FdoPermissionRule[], subject: F_RULE_SUBJECT, availablePermissions?: FdoPermissionRule[]): string;
 export declare function ruleExtension(rule: FdoPermissionRule): {
@@ -19,7 +20,7 @@ export declare function ruleExtension(rule: FdoPermissionRule): {
     actions: ("update" | "create" | "read" | "delete" | "manage")[];
 };
 export declare function getMaxDiscount(rules: FdoPermissionRule[]): number;
-export declare function getManagableRestaurantIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
+export { getManagableRestaurantIds, usableRoleIds };
 export interface MasterUserAccess {
     /** null = every restaurant, [] = none */
     restaurantIds: string[] | null;
@@ -36,7 +37,6 @@ export declare function resolveMasterUserAccess(rules: (FdoPermissionRule | RawR
     isOwner: boolean;
 }): MasterUserAccess;
 export declare function hasAdminRule(rules: FdoPermissionRule[]): boolean;
-export declare function usableRoleIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function extractReportExtraCondition(rule: FdoPermissionRule): Record<string, unknown> | undefined;
 export declare function fromValue(values: string[], maxDiscountPercentage: number, periodConditions?: Map<string, Record<string, unknown>>): {
     subject: string;

package/dist/src/helpers/staff-invite.d.ts

@@ -1,11 +1,14 @@
 import type { RawRule } from '@casl/ability';
 import { type IFdtoCreateStaffInviteReq, type IFdtoCreateStaffInviteRes, type IFdtoStaffInvite, type IFdtoStaffInviteProvider, type IFdtoUpdateStaffInviteReq, type StaffInviteMatch, type StaffInviteWarning } from '@/types/staff-invite';
+import type { IFdtoSsoProvider } from '@/types/sso-provider';
 type Translate = (key: string, params?: Record<string, unknown>) => string;
 /**
  * Same check the backend makes for POST /portal-users: create on hrm::portalUsers, which the
  * Team member toggle (hrm_teamMember:manage) grants through its system permission set.
  */
 export declare function canCreatePortalUsers(permissions: RawRule[]): boolean;
+/** The providers invites can go through: switched on, with a key to match people on. */
+export declare function invitableProviders(providers: IFdtoSsoProvider[]): IFdtoStaffInviteProvider[];
 export declare function canInviteStaff(providers: IFdtoStaffInviteProvider[], permissions: RawRule[]): boolean;
 /** E.164 form of a valid phone number, or null. */
 export declare function toE164(phone: string): string | null;

package/dist/src/router/shared.d.ts

@@ -12,6 +12,9 @@ export declare enum RouteName {
     POS_ACCESS = "pos-access",
     POS_GRANT = "pos-grant",
     APPROVAL_CODE = "approval-code",
+    SCHEDULE = "schedule",
+    SCHEDULE_POSITION = "schedule-position",
+    SCHEDULE_GENERAL = "schedule-general",
     MY_POS_PROFILE = "my-pos-profile"
 }
 declare const routes: RouteRecordRaw[];

package/dist/src/stores/approval-code.d.ts

@@ -1,5 +1,5 @@
 import type { IFdtoApprovalCode, IFdtoCreateApprovalCodeReq } from '@/types/approval-code';
-export declare const useApprovalCodeStore: import("pinia").StoreDefinition<"approvalCode", Pick<{
+export declare const useApprovalCodeStore: import("pinia").StoreDefinition<"hrm-approval-code", Pick<{
     approvalCodes: import("vue").Ref<{
         _id: string;
         businessId: string;

package/dist/src/stores/employee.d.ts

@@ -374,13 +374,12 @@ export declare const useEmployeeStore: () => {
         })[]>;
         totalEmployees: import("vue").Ref<number, number>;
         isLoading: import("vue").Ref<boolean, boolean>;
-        readEmployees: () => Promise<void>;
         readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
         readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
         updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
         deleteEmployee: (employee: Employee) => Promise<void>;
-        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
         updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         deleteMasterEmployee: (employee: Employee) => Promise<void>;
         migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
@@ -692,13 +691,12 @@ export declare const useEmployeeStore: () => {
         })[]>;
         totalEmployees: import("vue").Ref<number, number>;
         isLoading: import("vue").Ref<boolean, boolean>;
-        readEmployees: () => Promise<void>;
         readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
         readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
         updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
         deleteEmployee: (employee: Employee) => Promise<void>;
-        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
         updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         deleteMasterEmployee: (employee: Employee) => Promise<void>;
         migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
@@ -706,7 +704,7 @@ export declare const useEmployeeStore: () => {
     }, "isLoading" | "employees" | "listEmployees" | "totalEmployees">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
-    $onAction(callback: import("pinia").StoreOnActionListener<"employee", Pick<{
+    $onAction(callback: import("pinia").StoreOnActionListener<"hrm-employee", Pick<{
         employees: import("vue").Ref<({
             faceId?: unknown;
             name: string;
@@ -855,13 +853,12 @@ export declare const useEmployeeStore: () => {
         })[]>;
         totalEmployees: import("vue").Ref<number, number>;
         isLoading: import("vue").Ref<boolean, boolean>;
-        readEmployees: () => Promise<void>;
         readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
         readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
         updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
         deleteEmployee: (employee: Employee) => Promise<void>;
-        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
         updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         deleteMasterEmployee: (employee: Employee) => Promise<void>;
         migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
@@ -1015,13 +1012,12 @@ export declare const useEmployeeStore: () => {
         })[]>;
         totalEmployees: import("vue").Ref<number, number>;
         isLoading: import("vue").Ref<boolean, boolean>;
-        readEmployees: () => Promise<void>;
         readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
         readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
         updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
         deleteEmployee: (employee: Employee) => Promise<void>;
-        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
         updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         deleteMasterEmployee: (employee: Employee) => Promise<void>;
         migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
@@ -1175,28 +1171,26 @@ export declare const useEmployeeStore: () => {
         })[]>;
         totalEmployees: import("vue").Ref<number, number>;
         isLoading: import("vue").Ref<boolean, boolean>;
-        readEmployees: () => Promise<void>;
         readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
         readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+        createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
         updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
         deleteEmployee: (employee: Employee) => Promise<void>;
-        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+        createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
         updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         deleteMasterEmployee: (employee: Employee) => Promise<void>;
         migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
         syncUsersMeta: () => Promise<void>;
-    }, "readEmployees" | "readEmployeesPage" | "readAllEmployeesPage" | "createEmployee" | "updateEmployee" | "deleteEmployee" | "createMasterEmployee" | "updateMasterEmployee" | "deleteMasterEmployee" | "migrateToMasterUser" | "syncUsersMeta">>, detached?: boolean): () => void;
+    }, "readEmployeesPage" | "readAllEmployeesPage" | "createEmployee" | "updateEmployee" | "deleteEmployee" | "createMasterEmployee" | "updateMasterEmployee" | "deleteMasterEmployee" | "migrateToMasterUser" | "syncUsersMeta">>, detached?: boolean): () => void;
     $dispose(): void;
-    $id: "employee";
+    $id: "hrm-employee";
     _customProperties: Set<string>;
-    readEmployees: () => Promise<void>;
     readEmployeesPage: (query: IReadEmployeesPageReq) => Promise<void>;
     readAllEmployeesPage: (query: Omit<IReadEmployeesPageReq, "limit" | "offset">, knownTotal?: number) => Promise<Employee[]>;
-    createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<void>;
+    createEmployee: (dto: FdtoUpdatePosUserReq) => Promise<string>;
     updateEmployee: (userId: string, dto: FdtoUpdatePosUserReq) => Promise<void>;
     deleteEmployee: (employee: Employee) => Promise<void>;
-    createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
+    createMasterEmployee: (dto: FdtoUpdatePosMasterUserReq) => Promise<string>;
     updateMasterEmployee: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;
     deleteMasterEmployee: (employee: Employee) => Promise<void>;
     migrateToMasterUser: (userId: string, dto: FdtoUpdatePosMasterUserReq) => Promise<void>;

package/dist/src/stores/grant-user.d.ts

@@ -1,5 +1,5 @@
 import type { IFdtoGrantUser, IFdtoCreateGrantUserReq } from '@/types/grant-user';
-export declare const useGrantUserStore: import("pinia").StoreDefinition<"grantUser", Pick<{
+export declare const useGrantUserStore: import("pinia").StoreDefinition<"hrm-grant-user", Pick<{
     grantUsers: import("vue").Ref<{
         _id: string;
         passcode: string;

package/dist/src/stores/permission-assignment.d.ts

@@ -156,7 +156,7 @@ export declare const usePermissionAssignmentStore: () => {
     }, "permissionAssignments">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
-    $onAction(callback: import("pinia").StoreOnActionListener<"permissionAssignment", Pick<{
+    $onAction(callback: import("pinia").StoreOnActionListener<"hrm-permission-assignment", Pick<{
         permissionAssignments: import("vue").Ref<{
             id: string;
             customPermissions: {
@@ -266,7 +266,7 @@ export declare const usePermissionAssignmentStore: () => {
         getPermissionAssignmentByUserId: (userId: string) => IFdtoPermissionAssignment | undefined;
     }, "readPermissionAssignments" | "readPermissionAssignmentByUserId" | "createPermissionAssignment" | "updatePermissionAssignment" | "deletePermissionAssignment" | "getPermissionAssignmentByUserId">>, detached?: boolean): () => void;
     $dispose(): void;
-    $id: "permissionAssignment";
+    $id: "hrm-permission-assignment";
     _customProperties: Set<string>;
     readPermissionAssignments: () => Promise<void>;
     readPermissionAssignmentByUserId: (userId: string) => Promise<IFdtoPermissionAssignment | null>;

package/dist/src/stores/permission-set.d.ts

@@ -158,7 +158,7 @@ export declare const usePermissionSetStore: () => {
     }, "isLoading" | "permissionSets">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
-    $onAction(callback: import("pinia").StoreOnActionListener<"permissionSet", Pick<{
+    $onAction(callback: import("pinia").StoreOnActionListener<"hrm-permission-set", Pick<{
         permissionSets: import("vue").Ref<{
             id: string;
             permissions: {
@@ -265,7 +265,7 @@ export declare const usePermissionSetStore: () => {
         deletePermissionSet: (id: string) => Promise<void>;
     }, "readPermissionSets" | "createPermissionSet" | "updatePermissionSet" | "deletePermissionSet">>, detached?: boolean): () => void;
     $dispose(): void;
-    $id: "permissionSet";
+    $id: "hrm-permission-set";
     _customProperties: Set<string>;
     readPermissionSets: () => Promise<void>;
     createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;