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

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

@@ -141,8 +141,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
 }>> & Readonly<{
     "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
 }>, {
-    max: number;
     min: number;
+    max: number;
     disable: boolean;
     showAllToggle: string | boolean;
     includeDisabledOptionsWhenSelectAll: boolean;

package/dist/src/components/button/ResponsiveFabButton.vue.d.ts

@@ -1,3 +1,9 @@
 import { type FmButtonProps } from '@feedmepos/ui-library';
-declare const _default: import("vue").DefineComponent<FmButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FmButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+interface Props extends FmButtonProps {
+    /** Whether the page has a fixed bottom footer (e.g. a pagination bar) the mobile FAB should raise above. */
+    hasFooterBelow?: boolean;
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    hasFooterBelow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/table/TableEmptyState.vue.d.ts

@@ -5,30 +5,22 @@ interface Props {
     isEmpty: boolean;
     isLoading?: boolean;
     /**
-     * At what width do the column titles disappear? The table's column labels are gone at/below
-     * this breakpoint, so the empty state should move outside instead of overlaying the table
-     * body. Must mirror the wrapped FmTable's own `shrink-at` prop (both default to "sm"); pass
-     * `false` if the table never collapses.
+     * At what width do the column titles disappear? Below/at this breakpoint the message is
+     * styled as a standalone bordered card instead of blending flat under the table header. Must
+     * mirror the wrapped FmTable's own `shrink-at` prop (both default to "sm"); pass `false` if
+     * the table never collapses.
      */
     collapseAt?: Breakpoints | false;
-    /**
-     * At what width do we hide the table completely because there's a separate mobile view taking
-     * over? For callers that render their own alternate view (e.g. a mobile FmList) at/below this
-     * breakpoint. Pass `false` if the table has no alternate view and should stay visible at every
-     * breakpoint.
-     */
-    hideTableBelow?: Breakpoints | false;
 }
-declare var __VLS_5: {
-    isTableCollapsed: boolean;
+declare var __VLS_1: {
+    isEmpty: boolean;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_5) => any;
+    default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     isLoading: boolean;
     collapseAt: Breakpoints | false;
-    hideTableBelow: Breakpoints | false;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

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

@@ -7,6 +7,7 @@ export type CategoryGroup = {
     options: {
         label: string;
         value: string;
+        optionKey: string;
     }[];
     selectedSubjects: string[];
     isMultiAction: boolean;
@@ -25,7 +26,7 @@ export declare function useBasePermission(modelValue: Readonly<Ref<FdoPermission
     toggleAllManage: (group: CategoryGroup) => void;
     isManageChecked: (group: CategoryGroup, subject: string) => boolean;
     isManageIndeterminate: (group: CategoryGroup, subject: string) => boolean;
-    toggleManage: (_group: CategoryGroup, subject: string, checked: boolean) => void;
+    toggleManage: (group: CategoryGroup, subject: string, checked: boolean) => void;
     hasNonManageActions: (group: CategoryGroup, subject: string) => boolean;
     isActionChecked: (group: CategoryGroup, subject: string, action: string) => boolean;
     isRowFullyCoveredByCover: (group: CategoryGroup, subject: string) => boolean;

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

@@ -0,0 +1,40 @@
+import { type Ref } from 'vue';
+/**
+ * Local draft state for condition editing — tracks form field edits and
+ * inherit/custom mode changes for each builder, keyed by `${subject}::${builderKey}`.
+ *
+ * Drafts remain local until explicitly committed via `applyDrafts`. Closing
+ * a popover/menu without applying discards uncommitted changes.
+ */
+export interface DraftKey {
+    subject: string;
+    builderKey: string;
+}
+export interface ConditionDraft {
+    /** The local draft form value for this builder. */
+    formValue: unknown;
+    /** Local draft inherit/custom mode for builders under a cover subject. */
+    inheritMode?: 'inherit' | 'custom';
+}
+/**
+ * Creates a composable to manage local draft state for condition editing.
+ *
+ * @param committedSource - Ref to the committed state (e.g., modelValue, reportExtraConditions)
+ *   used to detect external changes and reset drafts accordingly
+ */
+export declare function useConditionDraft<T>(committedSource?: Ref<T>): {
+    drafts: Ref<Map<string, {
+        formValue: unknown;
+        inheritMode?: "inherit" | "custom" | undefined;
+    }> & Omit<Map<string, ConditionDraft>, keyof Map<any, any>>, Map<string, ConditionDraft> | (Map<string, {
+        formValue: unknown;
+        inheritMode?: "inherit" | "custom" | undefined;
+    }> & Omit<Map<string, ConditionDraft>, keyof Map<any, any>>)>;
+    setDraft: (key: DraftKey, draft: ConditionDraft) => void;
+    getDraft: (key: DraftKey) => ConditionDraft | undefined;
+    hasDraftsForSubject: (subject: string) => boolean;
+    getDraftsForSubject: (subject: string) => Map<string, ConditionDraft>;
+    clearDraftsForSubject: (subject: string) => void;
+    clearAllDrafts: () => void;
+    clearDraft: (key: DraftKey) => void;
+};

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

@@ -0,0 +1,61 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { FdoPermissionRule } from '@feedmepos/core/entity';
+import { type IFdtoPortalPermissionsWithVisibilityCondition } from '@feedmepos/hrm-permission';
+import { type ConditionBuilder, type ConditionSummary } from '@feedmepos/hrm-permission/condition-builder';
+/**
+ * Generic "category cover" machinery for the portal permission editor: any
+ * subject whose permission-definition category declares a cover (see
+ * `getCoverSubjectFor`) can have its condition-builder settings either
+ * inherit the cover subject's condition or hold a custom override — and the
+ * cover subject itself can push its condition down onto every individual
+ * override in the category.
+ *
+ * Zero knowledge of any specific subject, category, or builder lives here —
+ * everything is driven by the `defs` list (permission definitions carrying
+ * `category`/`isCategoryCover`) and the `ConditionBuilder` contract
+ * (`ownedFields`, `appliesToActions`, `summarizeForm`).
+ */
+/** The minimum shape the editor's per-row entry needs to expose for cover/inherit resolution. */
+export interface CoverConditionEntry {
+    /** Index of this subject's raw rule in the model, or null when no direct rule exists yet. */
+    index: number | null;
+    subject: string;
+    label: string;
+    actions: readonly string[];
+}
+/** Resolution handles passed to `onOverridesConflict` — the caller (UI) decides which to invoke. */
+export interface CoverOverrideResolution {
+    /** Strip this builder's fragment from every covered override rule (dropping a rule once it carries no more conditions and its actions are covered). */
+    override: () => void;
+    /** Leave every covered override rule untouched. */
+    keep: () => void;
+}
+export interface UpdateBuilderConditionOptions {
+    /** Create a direct rule even if the resulting condition is empty (used when explicitly switching to "custom"). */
+    forceCreateRule?: boolean;
+    afterCommit?: () => void;
+    /**
+     * Invoked instead of auto-resolving when this write touches a cover
+     * subject's row and other subjects in the same category hold a
+     * conditioned override on this builder. Omit only for callers that don't
+     * need a confirmation step — the write then defaults to keeping the
+     * overrides untouched (the non-destructive choice).
+     */
+    onOverridesConflict?: (resolution: CoverOverrideResolution) => void;
+}
+export interface BuilderConditionDraft {
+    builder: ConditionBuilder;
+    form: unknown;
+    mode: 'inherit' | 'custom';
+}
+export declare function useCoverConditionOverride(rules: Ref<FdoPermissionRule[]>, defs: ComputedRef<IFdtoPortalPermissionsWithVisibilityCondition[]>, updateRules: (next: FdoPermissionRule[]) => void): {
+    getCoverSubject: (subject: string) => string | undefined;
+    coverLabel: (subject: string) => string | undefined;
+    shouldShowInheritToggle: (entry: CoverConditionEntry, builder: ConditionBuilder) => boolean;
+    inheritMode: (entry: CoverConditionEntry, builder: ConditionBuilder) => "inherit" | "custom";
+    setInheritMode: (entry: CoverConditionEntry, builder: ConditionBuilder, mode: "inherit" | "custom") => void;
+    inheritedSummary: (entry: CoverConditionEntry, builder: ConditionBuilder, timeZone: string) => ConditionSummary | undefined;
+    getEffectiveActions: (subject: string) => readonly string[];
+    updateBuilderCondition: (entry: CoverConditionEntry, builder: ConditionBuilder, form: unknown, options?: UpdateBuilderConditionOptions) => void;
+    applyConditionDrafts: (entry: CoverConditionEntry, updates: BuilderConditionDraft[], options?: UpdateBuilderConditionOptions) => void;
+};

package/dist/src/helpers/business-timezone.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Business timezone resolution — a pure mapping from country code to IANA
+ * timezone, used as a fallback when a business has no explicit timezone
+ * configured. Kept independent of any store so it's testable in isolation;
+ * callers resolve the business/country from their own store and pass the
+ * plain values in.
+ */
+/** IANA timezone for a country code; falls back to the runtime's local zone for unknown/missing codes. */
+export declare function getCountryTimezone(country?: string): string;
+/** Minimal shape a business needs for timezone resolution. */
+export interface BusinessTimezoneSource {
+    timezone?: string;
+    timeZone?: string;
+    country?: string;
+}
+/**
+ * Resolve the effective IANA timezone for a business: an explicit business
+ * timezone field wins (`timezone`, then legacy `timeZone`), otherwise falls
+ * back to the country's default timezone (business's own country first, then
+ * `fallbackCountry`).
+ */
+export declare function resolveBusinessTimezone(business: BusinessTimezoneSource | undefined, fallbackCountry?: string): string;

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

@@ -0,0 +1,15 @@
+/**
+ * Sentinel value used in multi-select list filters (assigned role, restaurant, etc.) to
+ * represent "this field is empty/unassigned for the record". Must match the backend's
+ * `UNASSIGNED_FILTER_VALUE` in src/common/helpers/filter.ts.
+ *
+ * When sending a filter that includes this value to the backend, it must be the first element
+ * of the array -- the backend only checks index 0 to detect it (cheap even for filters with
+ * large option sets), it does not scan the whole list.
+ */
+export declare const UNASSIGNED_FILTER_VALUE = "__unassigned__";
+/**
+ * Reorders a multi-select filter's selected values so the "unassigned" sentinel (if present)
+ * is always first, matching what the backend's `splitUnassignedFilter` expects.
+ */
+export declare function withUnassignedFirst(values?: string[]): string[] | undefined;

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

@@ -0,0 +1,15 @@
+import type { FdoPermissionRule } from '@feedmepos/core/entity';
+import type { IFdtoPortalPermissionsWithVisibilityCondition } from '@feedmepos/hrm-permission';
+/**
+ * Reconcile a BasePermission update (which works with the expanded view) back to the raw modelValue.
+ *
+ * - Subject removed that was directly in raw → remove it
+ * - Subject removed that was system-expanded (not in raw) → add inverted rule to block re-expansion
+ * - Subject removed that was stored directly AND still reachable via expansion from remaining
+ *   rules (e.g. previously materialized by an earlier save) → remove direct rule AND add inverted,
+ *   otherwise materializeSystemPermissionSetOverrides re-injects it during save
+ * - Subject added that had an inverted rule → remove the inverted rule (expansion re-enables it)
+ * - Subject added that is genuinely new → add it to raw
+ * - Subject unchanged but actions changed → update actions in raw (multi-action permissions)
+ */
+export declare function reconcileBasePermissionUpdate(prevExpandedRules: FdoPermissionRule[], newExpandedRules: FdoPermissionRule[], rawRules: FdoPermissionRule[], findPermissionDef: (subject: string) => IFdtoPortalPermissionsWithVisibilityCondition | undefined): FdoPermissionRule[];

package/dist/src/helpers/permission-reconcile.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -71,10 +71,14 @@ export declare function filterStalePermissions(permissions: FdoPermissionRule[],
  * `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.
- * - Otherwise, only covered non-manage actions are stripped from individual rules.
- *   If `manage` was present and any non-manage action is stripped (breaking the
- *   "manage = all non-manage selected" invariant), `manage` is also stripped.
+ *   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.

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

@@ -20,7 +20,8 @@ export declare function getMaxDiscount(rules: FdoPermissionRule[]): number;
 export declare function getManagableRestaurantIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function hasAdminRule(rules: FdoPermissionRule[]): boolean;
 export declare function usableRoleIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
-export declare function fromValue(values: string[], maxDiscountPercentage: number): {
+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;
     actions: ("delete" | "create" | "update" | "read" | "manage")[];
     conditions: object;

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

@@ -1,5 +1,6 @@
 import type { IFdtoPermissionSet, IFdtoCreatePermissionSetReq, IFdtoUpdatePermissionSetReq } from '@/types/permission-set';
 export declare const usePermissionSetStore: () => {
+    isLoading: import("vue").Ref<boolean, boolean>;
     permissionSets: import("vue").Ref<{
         id: string;
         permissions: {
@@ -30,6 +31,7 @@ export declare const usePermissionSetStore: () => {
         name: string;
     }[]>;
     $state: {
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -75,12 +77,14 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">>;
+    }, "isLoading" | "permissionSets">>;
     $patch(partialState: import("pinia")._DeepPartial<{
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -98,6 +102,7 @@ export declare const usePermissionSetStore: () => {
         }[];
     }>): void;
     $patch<F extends (state: {
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -145,11 +150,12 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">>, options?: {
+    }, "isLoading" | "permissionSets">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
     $onAction(callback: import("pinia").StoreOnActionListener<"permissionSet", Pick<{
@@ -182,11 +188,12 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">, Pick<{
+    }, "isLoading" | "permissionSets">, Pick<{
         permissionSets: import("vue").Ref<{
             id: string;
             permissions: {
@@ -216,6 +223,7 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
@@ -250,6 +258,7 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;

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

@@ -5,7 +5,8 @@ export type ApprovalCodePermission = (typeof APPROVAL_CODE_PERMISSIONS)[number];
  * stored/returned by the backend. Mirrors `FdoApprovalCodeRule` from
  * `apps/hrm-backend/src/grant-user/grant-user.entity.ts`. `conditions` is
  * `null` (not just absent) for keys whose full-POS counterpart carries no
- * conditions at all (see `APPROVAL_CODE_RULE_TEMPLATES`).
+ * conditions at all (see `APPROVAL_CODE_RULE_TEMPLATES` at
+ * `apps/hrm-backend/src/grant-user/approval-code-rules.ts`).
  */
 export interface IFdtoApprovalCodeRule {
     key: ApprovalCodePermission;
@@ -13,41 +14,6 @@ export interface IFdtoApprovalCodeRule {
     actions: string[];
     conditions?: Record<string, unknown> | null;
 }
-/**
- * The rule template (subject/actions/conditions, minus `key`) for every
- * approval-code permission the portal can grant. The portal is now the
- * owner of these shapes (KDI-4982 Task A2) — the backend only validates the
- * shape of whatever rule it receives, it no longer composes rules itself.
- * These shapes are not arbitrary: they mirror `FullPosPermissions`
- * (`packages/permission/src/common/full-pos-permissions.ts`) exactly, entry
- * for entry, so a code granting one of these keys evaluates identically to
- * the corresponding rule a full-POS-permission staff member already has.
- * That's why `refund`/`openDrawer`/`counter` carry `conditions: null` — full
- * POS has no `operation` condition on those subjects — and why `discount`
- * always carries an `adjustment` condition (full POS's unbounded discount
- * rule is `adjustment: { $lte: 1 }`, i.e. "up to 100%", not "no adjustment
- * condition at all"). `counter` is a single key (not separate open/close
- * keys) because POS guards both opening and closing a counter with the same
- * `counterRecord`/`manage` permission — two identical rules would just be
- * redundant.
- */
-export declare const APPROVAL_CODE_RULE_TEMPLATES: Record<ApprovalCodePermission, {
-    subject: string;
-    actions: string[];
-    conditions: Record<string, unknown> | null;
-}>;
-/**
- * Compose the full CASL-shaped rule for `key`, ready to send to the backend
- * as-is, saved shape-identical to the corresponding `FullPosPermissions`
- * entry. Keys whose template has `conditions: null` always return `null` —
- * there's nothing to clone. Only `discount` honors `params.maxPercentage`,
- * setting the `adjustment.$lte` fraction (defaulting to `1`, i.e. no
- * effective ceiling, matching full POS's unbounded discount rule) — every
- * other object-conditions key ignores `params` if passed.
- */
-export declare function buildApprovalCodeRule(key: ApprovalCodePermission, params?: {
-    maxPercentage?: number;
-}): IFdtoApprovalCodeRule;
 export interface IFdtoApprovalCode {
     _id: string;
     businessId: string;
@@ -64,20 +30,15 @@ export interface IFdtoApprovalCode {
     createdAt: string;
     updatedAt: string;
 }
-export interface IFdtoCreateApprovalCodeReq {
-    name: string;
-    restaurantId: string;
-    permissions: IFdtoApprovalCodeRule[];
-    count: number;
-}
 /**
  * Read the discount ceiling back out of a rule's `conditions.adjustment.$lte`
  * fraction (0-1) as a whole percentage (1-100). Returns `undefined` when the
  * rule has no adjustment ceiling, when `conditions` is `null` (full-POS-style
  * null-condition rules never carry an adjustment), or when the ceiling is
  * 100% — `$lte: 1` is the unbounded/default form (see
- * `APPROVAL_CODE_RULE_TEMPLATES.discount`), so showing "≤100%" would be
- * meaningless noise on every plain discount grant.
+ * `APPROVAL_CODE_RULE_TEMPLATES.discount` at
+ * `apps/hrm-backend/src/grant-user/approval-code-rules.ts`), so showing
+ * "≤100%" would be meaningless noise on every plain discount grant.
  */
 export declare function getRuleAdjustmentCeilingPercentage(rule: IFdtoApprovalCodeRule): number | undefined;
 /**
@@ -110,15 +71,29 @@ export declare function validateMaxPercentage(value: number | string | undefined
  * Assumes the value has already passed `validateMaxPercentage`.
  */
 export declare function resolveMaxPercentage(value: number | string | undefined): number | undefined;
+/** One requested permission on a new access code, matching the backend's
+ * `FdtoApprovalCodePermissionReq`: a rule key plus, for `discount` only, a
+ * whole-percentage ceiling (1-100). The backend composes the stored CASL rule
+ * from the key — the portal no longer sends rule shapes. */
+export interface IFdtoApprovalCodePermissionReq {
+    key: ApprovalCodePermission;
+    maxPercentage?: number;
+}
+export interface IFdtoCreateApprovalCodeReq {
+    name: string;
+    restaurantId: string;
+    permissions: IFdtoApprovalCodePermissionReq[];
+    count: number;
+}
 /**
  * A selectable action option in the create form / list filter (KDI-4982 UI
  * redesign). The 8 options mirror the POS v7 passcode prompts exactly:
  * `claimDeposit` and `payment` are not offered (neither has a passcode prompt
- * on POS v7) even though both have `APPROVAL_CODE_RULE_TEMPLATES` entries
- * matching full POS. `changePrice` is offered as "Input Custom Price" — POS
+ * on POS v7) even though both are valid `ApprovalCodePermission` keys the
+ * backend accepts. `changePrice` is offered as "Input Custom Price" — POS
  * prompts for a passcode when a custom price is keyed in. `counter` covers
- * both opening and closing a counter (one `counterRecord`/`manage` rule, see
- * `APPROVAL_CODE_RULE_TEMPLATES.counter`). `printReceipt` was dropped
+ * both opening and closing a counter (one `counterRecord`/`manage` rule on
+ * the backend). `printReceipt` was dropped
  * entirely (no full-POS counterpart, and this feature has no pre-existing
  * stored data to keep rendering) — there is a 1:1 mapping between every
  * option and its single `ApprovalCodePermission` rule key, so each option
@@ -131,6 +106,12 @@ export interface AccessCodeActionOption {
 }
 export type AccessCodeActionOptionKey = AccessCodeActionOption['key'];
 export declare const ACCESS_CODE_ACTION_OPTIONS: AccessCodeActionOption[];
+/**
+ * Map the form's selected action options to permission-key requests.
+ * `maxPercentage` is the raw form input (see `resolveMaxPercentage`) and is
+ * attached to the `discount` key only — the backend rejects it elsewhere.
+ */
+export declare function buildPermissionRequests(selected: AccessCodeActionOptionKey[], maxPercentage: number | string | undefined): IFdtoApprovalCodePermissionReq[];
 /** When a code stopped being usable: used wins over revoked (a code can only
  * be one or the other, but usedAt is the historically-populated field). */
 export declare function getResolvedAt(code: Pick<IFdtoApprovalCode, 'usedAt' | 'revokedAt'>): string | undefined;

package/dist/src/views/hr/employee/EmployeeList.vue.d.ts

@@ -41,5 +41,6 @@ declare const _default: import("vue").DefineComponent<{}, {
         since: string;
     })[]>;
     exportEmployees: typeof exportEmployees;
+    getHasPaginationFooter: () => boolean;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/views/team/components/BasePermission.vue.d.ts

@@ -5,10 +5,23 @@ declare var __VLS_21: `checkbox-${string}-append`, __VLS_22: {
     option: {
         label: string;
         value: string;
+        optionKey: string;
     };
+    isEffectiveSelected: boolean;
+    isCoveredByCover: boolean;
+}, __VLS_25: `checkbox-${string}-icon`, __VLS_26: {
+    option: {
+        label: string;
+        value: string;
+        optionKey: string;
+    };
+    isEffectiveSelected: boolean;
+    isCoveredByCover: boolean;
 };
 type __VLS_Slots = {} & {
     [K in NonNullable<typeof __VLS_21>]?: (props: typeof __VLS_22) => any;
+} & {
+    [K in NonNullable<typeof __VLS_25>]?: (props: typeof __VLS_26) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     modelValue: {

package/dist/src/views/team/condition-builders/ConditionFormHost.vue.d.ts

@@ -0,0 +1,22 @@
+import type { ConditionBuilder } from '@feedmepos/hrm-permission/condition-builder';
+type __VLS_Props = {
+    builder: ConditionBuilder;
+    modelValue: unknown;
+    disable?: boolean;
+    optionProviders?: Record<string, Array<{
+        value: string;
+        label: string;
+    }>>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+}>, {
+    optionProviders: Record<string, Array<{
+        value: string;
+        label: string;
+    }>>;
+    disable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/team/condition-builders/ConditionFormRenderer.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ConditionFormConfig, ConditionFormState } from '@feedmepos/hrm-permission/condition-builder';
+type __VLS_Props = {
+    config: ConditionFormConfig;
+    modelValue: ConditionFormState;
+    disabled?: boolean;
+    /** name → option list, for fields whose options use `{ provider }`. */
+    optionProviders?: Record<string, Array<{
+        value: string;
+        label: string;
+    }>>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: ConditionFormState) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ConditionFormState) => any) | undefined;
+}>, {
+    disabled: boolean;
+    optionProviders: Record<string, Array<{
+        value: string;
+        label: string;
+    }>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/views/team/condition-builders/component-map.d.ts

@@ -0,0 +1,4 @@
+import { type Component } from 'vue';
+/** Resolve a form component key to a cached async component, or undefined when no
+ *  component is registered for that key (the host then renders nothing). */
+export declare function resolveBuilderComponent(key: string): Component | undefined;

package/dist/src/views/team/condition-builders/condition-form-dedupe.d.ts

@@ -0,0 +1,23 @@
+import type { ConditionFormState } from '@feedmepos/hrm-permission/condition-builder';
+/**
+ * Pure decision extracted from `ConditionFormRenderer.vue`'s `setField`, so
+ * it can be unit-tested without mounting the component (this repo's vitest
+ * setup has no `@vue/test-utils` / jsdom-environment component-mounting
+ * infrastructure yet — see the composable spec's notes on jsdom gaps).
+ *
+ * Some `FmRadio` / `FmCheckbox` fields (ui-library) fire their change
+ * handler twice per click — the click handler lives on a `<label>` wrapping
+ * the native input, so one click fires the handler once directly and once
+ * via the browser's synthetic click bubbling back through the label — which
+ * would otherwise make `setField` emit `update:modelValue` twice with an
+ * identical value. Comparing the freshly-computed next state against the
+ * last emitted (or last committed) state collapses that into a single
+ * emission, while still emitting for any genuinely new value.
+ *
+ * Uses lodash `isEqual` (already this app's idiom for comparing plain
+ * records — see `AddMemberForm.vue`, `PermissionSetForm.vue`, `RoleForm.vue`)
+ * rather than a `JSON.stringify` comparison, since these flat
+ * `{ key: value }` form records can hold arrays (multiselect) and key order
+ * is not guaranteed to be stable across the spread in `setField`.
+ */
+export declare function shouldEmitConditionFormUpdate(next: ConditionFormState, lastEmitted: ConditionFormState): boolean;