@acorex/modules 20.2.0-next.3 → 20.2.0

package/fesm2022/acorex-modules-workflow-management.mjs

@@ -1,2 +1,2 @@
-export { b as AXMMenuProvider, c as AXMWorkflowManagementModule, a as AXPTaskBoardModule, A as AXPTaskBoardService } from './acorex-modules-workflow-management-acorex-modules-workflow-management-DC7jdoqZ.mjs';
+export { b as AXMMenuProvider, c as AXMWorkflowManagementModule, a as AXPTaskBoardModule, A as AXPTaskBoardService } from './acorex-modules-workflow-management-acorex-modules-workflow-management-BfE17ZXY.mjs';
 //# sourceMappingURL=acorex-modules-workflow-management.mjs.map

package/identifier-management/README.md

@@ -0,0 +1,269 @@
+# @acorex/modules/identifier-management
+
+Pattern-based **Identifier** infrastructure for ACoreX (UI-first).  
+Supports **dynamic, DI-driven tokens**, mockable in **IndexedDB**, and ready to switch to **API** later.
+
+> ℹ️ Backend services are **not** implemented here. Where needed, this README points to the backend contracts that should be implemented later.
+
+---
+
+## ✅ Scope (UI-first)
+
+- Provide **UI-layer services** to define, preview, and generate identifiers from **patterns**.
+- Tokens are **DI services** (async-capable) and can be added like **plugins**.
+- Works in **Mock mode** (IndexedDB/Dexie). Can switch to **API mode** via connectivity.
+- Admin can define **Rules** (pattern + scopes + reset policy) and reuse them anywhere.
+
+---
+
+## 🧱 High-level Architecture
+
+```
+[UI Forms] ──▶ AXPIdentifierService (Port)
+                ├─ adapter: ApiIdentifierProvider (@acorex/connectivity/api in future)
+                └─ adapter: MockIdentifierProvider (@acorex/connectivity/mock)
+
+ Token Registry (DI, multi-provider)
+   ├─ Built-in tokens (date, seq, field, const, tenant, entity, check)
+   ├─ Custom tokens via plugins (slug, base36, lookup:*, etc.)
+   └─ Priority/override
+
+ Pattern Engine
+   ├─ compile(pattern) -> tokens
+   └─ evaluate(tokens, ctx) -> string  (async, ordered)
+
+ Sequence Provider
+   ├─ mock in IndexedDB (Hi/Lo optional)
+   └─ future: backend authoritative
+
+ Rule Store (UI)
+   ├─ mock store in IndexedDB
+   └─ future: CRUD via backend API
+```
+
+---
+
+## 📦 Public API (UI)
+
+### 1) Requests & Results
+
+```ts
+export interface AXPIdentifierRequest {
+  entity: string; // e.g., 'AXPInvoice'
+  tenantId?: string;
+  appId?: string;
+  mode: 'preview' | 'commit'; // preview = no sequence consumption
+  payload?: Record<string, any>; // fields for tokens (e.g. { worksite: 'HQ' })
+}
+
+export interface AXPIdentifierResult {
+  code: string;
+  ruleId: string;
+  scopeHash: string;
+  consumed: boolean; // true if commit consumed sequence
+  meta?: Record<string, any>;
+}
+```
+
+### 2) Rule Definition (UI)
+
+```ts
+export interface AXPIdentifierRule {
+  id: string;
+  name: string;
+  entity: string; // e.g., 'AXPInvoice'
+  pattern: string; // e.g., 'INV-{date:YYYYMM}-{tenant}-{seq:6}'
+  enabled: boolean;
+  priority: number;
+  scopeConfig: {
+    byTenant?: boolean;
+    byApp?: boolean;
+    period?: 'none' | 'daily' | 'monthly' | 'yearly' | { format: string };
+    customKeys?: string[]; // keys read from request.payload
+    resetPolicy?: 'never' | 'daily' | 'monthly' | 'yearly' | { format: string };
+    minValue?: number; // sequence min (usually 0)
+    blockSize?: number; // Hi/Lo block size (0 to disable)
+  };
+}
+```
+
+### 3) Main Port (UI)
+
+```ts
+export abstract class AXPIdentifierService {
+  abstract generate(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+  abstract peek(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+  abstract validate(code: string, entity: string, tenantId?: string): Promise<boolean>;
+}
+```
+
+---
+
+## 🔌 Connectivity Adapters (UI)
+
+Two providers implement `AXPIdentifierService`:
+
+```ts
+export interface AXPIdentifierProvider {
+  generate(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+  peek(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+  validate(code: string, entity: string, tenantId?: string): Promise<boolean>;
+}
+```
+
+- **MockIdentifierProvider** (included): Uses IndexedDB/Dexie for rules, sequences, and logs.
+- **ApiIdentifierProvider** (placeholder): Calls backend endpoints (to be implemented later).
+
+A simple **facade** chooses provider by connectivity mode:
+
+---
+
+## 🧩 Token System (DI + async)
+
+### Token Handler
+
+```ts
+export interface AXPatternToken {
+  name: string; // "date", "seq", "field", ...
+  args: string[]; // token args split by ':'
+  raw: string; // "{...}"
+  index: number; // position inside pattern
+}
+
+export interface AXEvalContext {
+  pattern: string;
+  request: AXPIdentifierRequest;
+  cache: Map<string, any>; // per-request memoization
+  now: Date;
+  services: AXEvalServices;
+}
+
+export interface AXEvalServices {
+  sequence: AXSequenceProvider; // required by seq-like tokens
+  checksum: AXChecksumProvider; // checksum helpers
+  lookup?: AXLookupProvider; // optional
+  policy?: AXPolicyProvider; // optional
+  clock?: AXClockProvider; // optional
+}
+
+export interface AXTokenHandler {
+  readonly name: string; // token name
+  readonly priority?: number; // higher wins on conflict
+  validate?(token: AXPatternToken): void | never;
+  eval(token: AXPatternToken, ctx: AXEvalContext): Promise<string> | string;
+  meta?: {
+    title?: string;
+    description?: string;
+    category?: string;
+    examples?: string[];
+    argHints?: string[];
+    version?: string;
+  };
+}
+```
+
+### Token Registry (multi-provider friendly)
+
+```ts
+export interface AXTokenRegistry {
+  register(handler: AXTokenHandler): void;
+  unregister(name: string): void;
+  get(name: string): AXTokenHandler | undefined;
+  list(): AXTokenHandler[];
+}
+```
+
+> You can expose the registry via an Angular `InjectionToken<AXTokenRegistry>` and register handlers using multi-providers, so plugins can add tokens without touching core.
+
+---
+
+## 🧠 Pattern Engine
+
+```ts
+export interface AXCompiledPattern {
+  pattern: string;
+  tokens: AXPatternToken[];
+}
+
+export interface AXPatternEngine {
+  compile(pattern: string): AXCompiledPattern; // parse + validate via registry
+  evaluate(compiled: AXCompiledPattern, ctx: AXEvalContext): Promise<string>; // async ordered eval
+}
+```
+
+**Behavior:**
+
+- Ordered evaluation (left → right) so tokens like `{check:*}` can compute based on “string so far”.
+- The engine updates `ctx.cache.set('__acc__', builtSoFar)` before each token to support checksum tokens.
+
+---
+
+## 🔁 Sequence & Utilities (UI contracts)
+
+```ts
+export interface AXSequenceProvider {
+  next(scopeHash: string, options?: { pad?: number; consume?: boolean }): Promise<number>;
+}
+
+export interface AXChecksumProvider {
+  compute(algo: 'luhn' | 'mod11', input: string): string;
+}
+
+export interface AXLookupProvider {
+  get(key: string, params?: Record<string, any>): Promise<string | undefined>;
+}
+
+export interface AXPolicyProvider {
+  isAllowed(tokenName: string, request: AXPIdentifierRequest): boolean;
+}
+
+export interface AXClockProvider {
+  now(): Date;
+}
+```
+
+> In UI, we provide **mock implementations**. Later, when the backend is ready, the API provider will **delegate** these to the server.
+
+---
+
+## 💾 Mock Storage (IndexedDB)
+
+Dexie schema for UI mock mode:
+
+```ts
+import Dexie, { Table } from 'dexie';
+
+export interface AXRuleRow extends AXPIdentifierRule {}
+export interface AXSeqRow {
+  id: string; // `${ruleId}:${scopeHash}`
+  ruleId: string;
+  scopeHash: string;
+  currentValue: number; // last consumed value
+  hi?: number; // Hi/Lo
+  next?: number;
+  lastResetKey?: string; // e.g. '202508' for monthly
+}
+export interface AXLogRow {
+  id: string; // uuid
+  entity: string;
+  tenantId?: string;
+  code: string;
+  createdAt: string; // ISO
+}
+
+export class AXPIdentifierDB extends Dexie {
+  rules!: Table<AXRuleRow, string>;
+  sequences!: Table<AXSeqRow, string>;
+  logs!: Table<AXLogRow, string>;
+  constructor() {
+    super('AXPIdentifierDB');
+    this.version(1).stores({
+      rules: 'id, entity, enabled, priority',
+      sequences: 'id, ruleId, scopeHash',
+      logs: 'id, code, entity, tenantId',
+    });
+  }
+}
+```
+
+---

package/identifier-management/index.d.ts

@@ -0,0 +1,271 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import { AXPEntity, AXPMenuProvider, AXPMenuProviderContext, AXPSearchCommandProvider, AXPSearchResult, AXPSettingDefinitionProvider, AXPSettingDefinitionProviderContext } from '@acorex/platform/common';
+import { AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader, AXPEntityPreloadEntity } from '@acorex/platform/layout/entity';
+
+declare class AXMIdentifierManagementModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMIdentifierManagementModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMIdentifierManagementModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXMIdentifierManagementModule>;
+}
+
+declare const RootConfig: {
+    config: {
+        i18n: string;
+    };
+    module: {
+        module: string;
+        name: string;
+        title: string;
+        icon: string;
+    };
+    entities: {};
+};
+
+declare class AXMEntityProvider implements AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader {
+    private injector;
+    preload(): AXPEntityPreloadEntity[];
+    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMEntityProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMEntityProvider>;
+}
+
+declare class AXMMenuProvider implements AXPMenuProvider {
+    private entityService;
+    provide(context: AXPMenuProviderContext): Promise<void>;
+}
+
+declare class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    commands: AXPSearchResult[];
+}
+
+declare class AXMSettingProvider implements AXPSettingDefinitionProvider {
+    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
+}
+
+interface AXPIdentifierRequest {
+    /** Business entity code, e.g. 'AXPInvoice' */
+    entity: string;
+    /** Optional tenant partition */
+    tenantId?: string;
+    /** Optional application partition */
+    appId?: string;
+    /** Preview will not consume sequence */
+    mode: 'preview' | 'commit';
+    /** Arbitrary payload for tokens to read from */
+    payload?: Record<string, unknown>;
+}
+interface AXPIdentifierResult {
+    code: string;
+    ruleId: string;
+    scopeHash: string;
+    consumed: boolean;
+    meta?: Record<string, unknown>;
+}
+interface AXPIdentifierRule {
+    id: string;
+    name: string;
+    entity: string;
+    pattern: string;
+    enabled: boolean;
+    priority: number;
+    scopeConfig: {
+        byTenant?: boolean;
+        byApp?: boolean;
+        period?: 'none' | 'daily' | 'monthly' | 'yearly' | {
+            format: string;
+        };
+        customKeys?: string[];
+        resetPolicy?: 'never' | 'daily' | 'monthly' | 'yearly' | {
+            format: string;
+        };
+        minValue?: number;
+        blockSize?: number;
+    };
+}
+declare abstract class AXPIdentifierService {
+    abstract generate(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+    abstract peek(req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+    abstract validate(code: string, entity: string, tenantId?: string): Promise<boolean>;
+}
+declare const AXP_IDENTIFIER_RULES: InjectionToken<AXPIdentifierRule[]>;
+
+interface AXPPatternToken {
+    name: string;
+    args: string[];
+    raw: string;
+    index: number;
+}
+interface AXPEvalServices {
+    sequence: AXPSequenceProvider;
+    checksum: AXPChecksumProvider;
+    lookup?: AXPLookupProvider;
+    policy?: AXPPolicyProvider;
+    clock?: AXPClockProvider;
+}
+interface AXPEvalContext {
+    pattern: string;
+    request: AXPIdentifierRequest;
+    cache: Map<string, unknown>;
+    now: Date;
+    services: AXPEvalServices;
+}
+interface AXPTokenHandler {
+    readonly name: string;
+    readonly priority?: number;
+    validate?(token: AXPPatternToken): void | never;
+    eval(token: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    meta?: {
+        title?: string;
+        description?: string;
+        category?: string;
+        examples?: string[];
+        argHints?: string[];
+        version?: string;
+    };
+}
+interface AXPTokenRegistry {
+    register(handler: AXPTokenHandler): void;
+    unregister(name: string): void;
+    get(name: string): AXPTokenHandler | undefined;
+    list(): AXPTokenHandler[];
+}
+interface AXPSequenceProvider {
+    next(scopeHash: string, options?: {
+        pad?: number;
+        consume?: boolean;
+    }): Promise<number>;
+}
+interface AXPChecksumProvider {
+    compute(algo: 'luhn' | 'mod11', input: string): string;
+}
+interface AXPLookupProvider {
+    get(key: string, params?: Record<string, unknown>): Promise<string | undefined>;
+}
+interface AXPPolicyProvider {
+    isAllowed(tokenName: string, request: AXPIdentifierRequest): boolean;
+}
+interface AXPClockProvider {
+    now(): Date;
+}
+declare const AXP_TOKEN_HANDLERS: InjectionToken<AXPTokenHandler[]>;
+
+type AXPCompiledFragment = AXPPatternToken | {
+    type: 'literal';
+    text: string;
+};
+interface AXPCompiledPattern {
+    pattern: string;
+    tokens: AXPCompiledFragment[];
+}
+interface AXPPatternEngine {
+    compile(pattern: string): AXPCompiledPattern;
+    evaluate(compiled: AXPCompiledPattern, ctx: AXPEvalContext): Promise<string>;
+}
+declare class AXPSimplePatternEngine implements AXPPatternEngine {
+    private readonly registry;
+    compile(pattern: string): AXPCompiledPattern;
+    evaluate(compiled: AXPCompiledPattern, ctx: AXPEvalContext): Promise<string>;
+}
+
+declare class AXPTokenRegistryService implements AXPTokenRegistry {
+    private readonly handlers;
+    private readonly providerHandlers;
+    register(handler: AXPTokenHandler): void;
+    unregister(name: string): void;
+    get(name: string): AXPTokenHandler | undefined;
+    list(): AXPTokenHandler[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTokenRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTokenRegistryService>;
+}
+
+declare class DateToken implements AXPTokenHandler {
+    readonly name = "date";
+    readonly meta: {
+        title: string;
+        description: string;
+        argHints: string[];
+    };
+    eval(token: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateToken>;
+}
+declare class ConstToken implements AXPTokenHandler {
+    readonly name = "const";
+    readonly meta: {
+        title: string;
+        description: string;
+    };
+    eval(token: AXPPatternToken): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConstToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConstToken>;
+}
+declare class FieldToken implements AXPTokenHandler {
+    readonly name = "field";
+    readonly meta: {
+        title: string;
+        description: string;
+    };
+    eval(token: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldToken>;
+}
+declare class TenantToken implements AXPTokenHandler {
+    readonly name = "tenant";
+    readonly meta: {
+        title: string;
+        description: string;
+    };
+    eval(_t: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TenantToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TenantToken>;
+}
+declare class AppToken implements AXPTokenHandler {
+    readonly name = "app";
+    readonly meta: {
+        title: string;
+        description: string;
+    };
+    eval(_t: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppToken>;
+}
+declare class SeqToken implements AXPTokenHandler {
+    readonly name = "seq";
+    readonly meta: {
+        title: string;
+        description: string;
+        argHints: string[];
+    };
+    eval(token: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeqToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SeqToken>;
+}
+declare class CheckToken implements AXPTokenHandler {
+    readonly name = "check";
+    readonly meta: {
+        title: string;
+        description: string;
+        argHints: string[];
+    };
+    eval(token: AXPPatternToken, ctx: AXPEvalContext): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckToken, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckToken>;
+}
+
+declare const AXP_DEFAULT_TOKEN_PROVIDERS: Provider[];
+
+declare class AXPMockIdentifierService extends AXPIdentifierService {
+    generate(_req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+    peek(_req: AXPIdentifierRequest): Promise<AXPIdentifierResult>;
+    validate(_code: string, _entity: string, _tenantId?: string): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMockIdentifierService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMockIdentifierService>;
+}
+
+declare function buildScopeHash(parts: Array<string | undefined>): string;
+declare function padNumber(num: number, size: number): string;
+declare function uuid(): string;
+
+export { AXMEntityProvider, AXMIdentifierManagementModule, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, AXPIdentifierService, AXPMockIdentifierService, AXPSimplePatternEngine, AXPTokenRegistryService, AXP_DEFAULT_TOKEN_PROVIDERS, AXP_IDENTIFIER_RULES, AXP_TOKEN_HANDLERS, AppToken, CheckToken, ConstToken, DateToken, FieldToken, RootConfig, SeqToken, TenantToken, buildScopeHash, padNumber, uuid };
+export type { AXPChecksumProvider, AXPClockProvider, AXPCompiledFragment, AXPCompiledPattern, AXPEvalContext, AXPEvalServices, AXPIdentifierRequest, AXPIdentifierResult, AXPIdentifierRule, AXPLookupProvider, AXPPatternEngine, AXPPatternToken, AXPPolicyProvider, AXPSequenceProvider, AXPTokenHandler, AXPTokenRegistry };

package/locale-management/index.d.ts

@@ -178,5 +178,26 @@ declare class AXMLocaleManagementService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXMLocaleManagementService>;
 }
 
-export { AXMCurrenciesService, AXMCurrenciesServiceImpl, AXMLanguagesService, AXMLanguagesServiceImpl, AXMLocaleManagementEntityProvider, AXMLocaleManagementMenuProvider, AXMLocaleManagementModule, AXMLocaleManagementPermissionDefinitionProvider, AXMLocaleManagementSearchCommandProvider, AXMLocaleManagementService, AXMLocalesService, AXMLocalesServiceImpl, AXMTimezonesService, AXMTimezonesServiceImpl, RootConfig, currenciesFactory, languagesFactory, localesFactory, timezonesFactory };
+declare enum AXPRegionalSetting {
+    LocaleProfile = "regional:locale-profile",
+    TimeZone = "regional:timezone",
+    Language = "regional:language",
+    Country = "regional:country",
+    Calendar = "regional:calendar",
+    FirstDayOfWeek = "regional:first-day-of-week",
+    WeekendDays = "regional:weekend-days",
+    ShortDate = "regional:short-date",
+    LongDate = "regional:long-date",
+    ShortTime = "regional:short-time",
+    LongTime = "regional:long-time",
+    MeasurementUnits = "regional:measurement-units",
+    TemperatureUnits = "regional:temperature-units",
+    DistanceUnits = "regional:distance-units",
+    WeightUnits = "regional:weight-units",
+    VolumeUnits = "regional:volume-units",
+    SpeedUnits = "regional:speed-units",
+    AreaUnits = "regional:area-units"
+}
+
+export { AXMCurrenciesService, AXMCurrenciesServiceImpl, AXMLanguagesService, AXMLanguagesServiceImpl, AXMLocaleManagementEntityProvider, AXMLocaleManagementMenuProvider, AXMLocaleManagementModule, AXMLocaleManagementPermissionDefinitionProvider, AXMLocaleManagementSearchCommandProvider, AXMLocaleManagementService, AXMLocalesService, AXMLocalesServiceImpl, AXMTimezonesService, AXMTimezonesServiceImpl, AXPRegionalSetting, RootConfig, currenciesFactory, languagesFactory, localesFactory, timezonesFactory };
 export type { AXMLocaleManagementCurrenciesEntityModel, AXMLocaleManagementLanguagesEntityModel, AXMLocaleManagementLocalesEntityModel, AXMLocaleManagementTimezonesEntityModel };

package/location-management/index.d.ts

@@ -46,6 +46,10 @@ declare function locationFactory(injector: Injector): Promise<AXPEntity | null>;
 interface AXMLocationManagementLocationEntityModel extends AXPEntityModel<string> {
     title: string;
     code?: string;
+    reference?: {
+        id: string;
+        type: string;
+    };
     locationTypeId?: string;
     locationType?: {
         id: string;
@@ -69,7 +73,6 @@ interface AXMLocationManagementLocationEntityModel extends AXPEntityModel<string
     validFrom?: Date;
     validTo?: Date;
     timezone?: string;
-    externalId?: string;
 }
 
 declare abstract class AXMLocationService extends AXMEntityCrudServiceImpl<string, AXMLocationManagementLocationEntityModel> {

package/notification-management/index.d.ts

@@ -260,9 +260,9 @@ declare class AXMNotificationConnectorService {
      */
     getList(): Promise<AXMNotificationResponse>;
     /**
-     * Mark notifications as read or toggle read status
-     * If no specific IDs are provided, mark all as read
-     * If specific IDs are provided, toggle their read status (mark as read if unread, mark as unread if read)
+     * Mark notifications as read
+     * If no specific IDs are provided, mark all unread notifications as read
+     * If specific IDs are provided, set readAt only when it is currently null (no toggling)
      */
     markAsRead(payload?: AXMNotificationMarkAsReadRequest): Promise<void>;
     markAllAsRead(): Promise<void>;
@@ -305,7 +305,7 @@ declare class AXPNotificationWidgetViewComponent extends AXPValueWidgetComponent
     private readonly datePipe;
     private readonly notificationConnector;
     private readonly toastService;
-    protected activeTab: i0.WritableSignal<"all" | "new">;
+    protected activeTab: i0.WritableSignal<"all" | "unread">;
     private refreshTimerId;
     protected readonly maxItems: i0.Signal<any>;
     protected readonly showAvatar: i0.Signal<any>;
@@ -351,11 +351,15 @@ declare class AXPNotificationWidgetViewComponent extends AXPValueWidgetComponent
     /**
      * Change the active tab
      */
-    protected onTabChange(tabName: 'new' | 'all'): void;
+    protected onTabChange(tabName: 'unread' | 'all'): void;
     /**
      * Handle notification click event
      */
     protected onNotificationClick(notification: AXMNotificationItem): void;
+    /**
+     * Bridge click from admin item (emits notification id)
+     */
+    protected onAdminItemClick: (id: string) => void;
     /**
      * Format the timestamp in a user-friendly way
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acorex/modules",
-  "version": "20.2.0-next.3",
+  "version": "20.2.0",
   "peerDependencies": {
     "@angular/common": ">=19.0.0",
     "@angular/core": ">=19.0.0",
@@ -66,6 +66,10 @@
       "types": "./form-template-management/index.d.ts",
       "default": "./fesm2022/acorex-modules-form-template-management.mjs"
     },
+    "./identifier-management": {
+      "types": "./identifier-management/index.d.ts",
+      "default": "./fesm2022/acorex-modules-identifier-management.mjs"
+    },
     "./issue-management": {
       "types": "./issue-management/index.d.ts",
       "default": "./fesm2022/acorex-modules-issue-management.mjs"
@@ -90,6 +94,10 @@
       "types": "./organization-management/index.d.ts",
       "default": "./fesm2022/acorex-modules-organization-management.mjs"
     },
+    "./party-management": {
+      "types": "./party-management/index.d.ts",
+      "default": "./fesm2022/acorex-modules-party-management.mjs"
+    },
     "./platform-management": {
       "types": "./platform-management/index.d.ts",
       "default": "./fesm2022/acorex-modules-platform-management.mjs"