@feedmepos/mf-hrm-portal 2.1.1-dev.3 → 2.1.1-dev.4

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

@@ -9,6 +9,9 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
+        search?: string;
+        searchUserIds?: string[];
+        searchSubjects?: string[];
     }): Promise<number>;
     read(params?: {
         limit?: number;
@@ -21,6 +24,9 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
+        search?: string;
+        searchUserIds?: string[];
+        searchSubjects?: string[];
     }): Promise<AuditLogEntry[]>;
     /**
      * FeedMe-admin options for the User filter. `actors` is the named admin list (internal

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

@@ -64,6 +64,19 @@ export interface IFdtoCreateApprovalCodeReq {
  * rule has no adjustment ceiling.
  */
 export declare function getRuleAdjustmentCeilingPercentage(rule: IFdtoApprovalCodeRule): number | undefined;
+/**
+ * Human-readable labels for a code's permission rules, e.g. `["Refund",
+ * "Apply discount ≤20%"]`. `translate` is the caller's i18n `t` — labels
+ * live under `approvalCode.permissions.<key>`.
+ */
+export declare function formatPermissionLabels(permissions: IFdtoApprovalCodeRule[], translate: (key: string) => string): string[];
+/**
+ * Clipboard text for sharing a code — passcode plus its actions and
+ * restaurant (e.g. "Code 3843 · Refund · Gulu-gulu Main") so the recipient
+ * can tell what the code unlocks and where without opening the portal.
+ * Missing parts are skipped rather than leaving dangling separators.
+ */
+export declare function buildCodeClipboardText(code: Pick<IFdtoApprovalCode, 'passcode' | 'permissions'>, restaurantName: string | undefined, translate: (key: string) => string): string;
 /**
  * Validate the optional discount max-percentage input. Undefined, empty, or
  * whitespace-only means "no ceiling" and is valid; otherwise the value must
@@ -78,15 +91,17 @@ export declare function validateMaxPercentage(value: number | string | undefined
 export declare function resolveMaxPercentage(value: number | string | undefined): number | undefined;
 /**
  * A selectable action option in the create form / list filter (KDI-4982 UI
- * redesign). The 8 options mirror the POS v7 passcode prompts exactly:
- * `changePrice`, `claimDeposit`, `payment` are not offered (the latter two
- * have no passcode prompt on POS v7 at all), and open/close counter share one
- * option because POS guards both with the same `counterRecord` permission.
- * The 12-key `APPROVAL_CODE_PERMISSIONS` enum is untouched — stored rules and
- * the wire format still use the full key set, so legacy codes keep rendering.
+ * redesign). The 9 options mirror the POS v7 passcode prompts exactly:
+ * `claimDeposit` and `payment` are not offered (neither has a passcode prompt
+ * on POS v7), and open/close counter share one option because POS guards both
+ * with the same `counterRecord` permission. `changePrice` is offered as
+ * "Input Custom Price" — POS prompts for a passcode when a custom price is
+ * keyed in. The 12-key `APPROVAL_CODE_PERMISSIONS` enum is untouched — stored
+ * rules and the wire format still use the full key set, so legacy codes keep
+ * rendering.
  */
 export interface AccessCodeActionOption {
-    key: 'printReceipt' | 'resend' | 'openDrawer' | 'counter' | 'discount' | 'void' | 'changePaymentType' | 'refund';
+    key: 'printReceipt' | 'resend' | 'openDrawer' | 'counter' | 'discount' | 'changePrice' | 'void' | 'changePaymentType' | 'refund';
     ruleKeys: ApprovalCodePermission[];
 }
 export type AccessCodeActionOptionKey = AccessCodeActionOption['key'];

package/dist/src/types/audit-log.d.ts

@@ -1 +1 @@
-export type { AuditLogEntry, AuditLogMetadata, AuditLogOutcome, AuditLogResolvedFrom } from '@feedmepos/hrm-permission';
+export type { AuditLogEntry, AuditLogMetadata, AuditLogOperation, AuditLogOutcome, AuditLogResolvedFrom, } from '@feedmepos/hrm-permission';

package/dist/src/views/approval-code/components/ApprovalCodeCreatedDialog.vue.d.ts

@@ -0,0 +1,9 @@
+import { type IFdtoApprovalCode } from '@/types/approval-code';
+declare const _default: import("vue").DefineComponent<{}, {
+    open: (created: IFdtoApprovalCode[]) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    createAnother: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onCreateAnother?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/views/approval-code/components/ApprovalCodeForm.vue.d.ts

@@ -1,3 +1,4 @@
+import { type IFdtoApprovalCode } from '@/types/approval-code';
 declare var __VLS_1: {
     trigger: () => void;
 };
@@ -7,7 +8,11 @@ type __VLS_Slots = {} & {
 declare const __VLS_component: import("vue").DefineComponent<{}, {
     show: import("vue").Ref<boolean, boolean>;
     trigger: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    created: (codes: IFdtoApprovalCode[]) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onCreated?: ((codes: IFdtoApprovalCode[]) => any) | undefined;
+}>, {}, {}, {}, {}, 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 & {

package/dist/src/views/approval-code/locales/index.d.ts

@@ -57,6 +57,16 @@ export declare const i18nMessages: {
                 successMessage: string;
                 successMessageBulk: string;
             };
+            created: {
+                title: string;
+                titleBulk: string;
+                subtitle: string;
+                subtitleBulk: string;
+                copy: string;
+                copyAll: string;
+                createAnother: string;
+                done: string;
+            };
             revoke: {
                 title: string;
                 message: string;
@@ -136,6 +146,16 @@ export declare const i18nMessages: {
                 successMessage: string;
                 successMessageBulk: string;
             };
+            created: {
+                title: string;
+                titleBulk: string;
+                subtitle: string;
+                subtitleBulk: string;
+                copy: string;
+                copyAll: string;
+                createAnother: string;
+                done: string;
+            };
             revoke: {
                 title: string;
                 message: string;
@@ -215,6 +235,16 @@ export declare const i18nMessages: {
                 successMessage: string;
                 successMessageBulk: string;
             };
+            created: {
+                title: string;
+                titleBulk: string;
+                subtitle: string;
+                subtitleBulk: string;
+                copy: string;
+                copyAll: string;
+                createAnother: string;
+                done: string;
+            };
             revoke: {
                 title: string;
                 message: string;
@@ -294,6 +324,16 @@ export declare const i18nMessages: {
                 successMessage: string;
                 successMessageBulk: string;
             };
+            created: {
+                title: string;
+                titleBulk: string;
+                subtitle: string;
+                subtitleBulk: string;
+                copy: string;
+                copyAll: string;
+                createAnother: string;
+                done: string;
+            };
             revoke: {
                 title: string;
                 message: string;

package/dist/src/views/audit-log/event-line.d.ts

@@ -0,0 +1,13 @@
+export interface EventLineSource {
+    eventKey?: string;
+    params?: Record<string, string | number>;
+    operationLabel?: string;
+}
+type Translate = (key: string, params?: Record<string, unknown>) => string;
+export declare function splitEventKey(key: string): {
+    entity: string;
+    verb: string;
+} | null;
+export declare function humanizeSegment(segment: string): string;
+export declare function renderEventLine(t: Translate, source: EventLineSource): string;
+export {};