@acorex/modules 21.0.0-next.70 → 21.0.0-next.72

package/fesm2022/acorex-modules-notification-management-acorex-modules-notification-management-BSf1wd6j.mjs

@@ -0,0 +1,3836 @@
+import { createAllQueryView, AXPEntityQueryType, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_PROTECTED_ROUTE_GUARDS, AXP_MENU_PROVIDER, AXPEntityCommandScope } from '@acorex/platform/common';
+import { AXPWidgetsCatalog, AXPValueWidgetComponent, cloneProperty, AXPWidgetGroupEnum, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex/platform/layout/widget-core';
+import { AXMEntityCrudServiceImpl, entityMasterCrudActions, entityMasterRecordActions, AXPEntityDataSelectorService, AXPEntityDefinitionRegistryService, AXP_ENTITY_DEFINITION_LOADER, AXPEntityStorageService, AXPEntityDataProviderImpl } from '@acorex/platform/layout/entity';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, inject, signal, DestroyRef, computed, Injector, InjectionToken, viewChild, ViewContainerRef, input, output, afterNextRender, inputBinding, outputBinding, ChangeDetectionStrategy, Component, effect, ViewEncapsulation, ChangeDetectorRef } from '@angular/core';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { firstValueFrom, Subject, debounceTime } from 'rxjs';
+import { AXPUserAvatarComponent, AXPStateMessageComponent, AXP_TASK_BADGE_PROVIDERS } from '@acorex/platform/layout/components';
+import * as i1$2 from '@acorex/platform/core';
+import { AXPComponentSlotModule, AXP_MODULE_MANIFEST_PROVIDER, AXPDataGenerator } from '@acorex/platform/core';
+import { AXPRootLayoutComponent } from '@acorex/platform/themes/default';
+import { Router, ROUTES } from '@angular/router';
+import { AXPCommandService, provideCommandSetups } from '@acorex/platform/runtime';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i4 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import * as i3$1 from '@acorex/components/badge';
+import { AXBadgeModule } from '@acorex/components/badge';
+import * as i1$1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i1 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i4$1 from '@acorex/components/popover';
+import { AXPopoverModule, AXPopoverComponent } from '@acorex/components/popover';
+import * as i2$1 from '@acorex/components/tabs';
+import { AXTabsModule } from '@acorex/components/tabs';
+import { AXToastService } from '@acorex/components/toast';
+import * as i3 from '@acorex/core/format';
+import { AXFormatModule } from '@acorex/core/format';
+import * as i2 from '@angular/common';
+import { CommonModule, DatePipe } from '@angular/common';
+import { AXImageModule } from '@acorex/components/image';
+import { AXP_WIDGETS_UTILITY_CATEGORY } from '@acorex/modules/dashboard-management';
+import { AXP_APPEARANCE_PROPERTY_GROUP, AXP_STYLING_PROPERTY_GROUP, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/layout/widgets';
+import { AXC_TEXT_TEMPLATE_RENDER_COMMAND_KEY } from '@acorex/modules/content-management';
+import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
+import { RootConfig as RootConfig$1 } from '@acorex/modules/form-template-management';
+import { AXPWidgetsList } from '@acorex/modules/common';
+
+const config = {
+    i18n: 'notification-management',
+    route: 'notifications',
+    module: 'NotificationManagement',
+};
+/** Dashboard widget type ids for notification-management-hosted widgets (`{module}:Widget:Dashboard:{Segment}`). */
+const dashboardWidgetId = (segment) => `${config.module}:Widget:Dashboard:${segment}`;
+const RootConfig = {
+    config,
+    module: {
+        route: 'notification-management',
+        name: config.module,
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-bell',
+    },
+    entities: {
+        channel: {
+            name: 'Channels',
+            title: `t("channel", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-list',
+        },
+        template: {
+            name: 'Templates',
+            title: `t("template",{scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-file-code',
+        },
+        notification: {
+            name: 'Notifications',
+            title: `t("notification",{scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-file-code',
+        },
+    },
+    widgets: {
+        myNotificationDashboard: dashboardWidgetId('MyNotificationDashboard'),
+    },
+};
+
+class AXMNotificationEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMNotificationEntityServiceImpl extends AXMNotificationEntityService {
+    getList() {
+        throw new Error('Method not implemented.');
+    }
+    markAsRead(payload) {
+        throw new Error('Method not implemented.');
+    }
+    markAllAsRead() {
+        throw new Error('Method not implemented.');
+    }
+    create(payload) {
+        throw new Error('Method not implemented.');
+    }
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.notification.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function notificationEntityFactory(injector) {
+    const dataService = injector.get(AXMNotificationEntityService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.notification.name,
+        title: RootConfig.entities.notification.title,
+        icon: RootConfig.entities.notification.icon,
+        formats: {
+            individual: '@notification-management:entities.notification.title',
+            plural: '@notification-management:entities.notification.plural',
+        },
+        relatedEntities: [
+            {
+                entity: 'notification-management.notificationLog',
+                columns: ['title', 'status'],
+            },
+        ],
+        groups: [
+            {
+                id: 'notification',
+                title: 'Notification',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@notification-management:entities.notification.fields.name.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@notification-management:entities.notification.fields.title.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'body',
+                title: '@notification-management:entities.notification.fields.body.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'channel',
+                title: '@notification-management:entities.notification.fields.channel.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'user.name',
+                title: '@notification-management:entities.notification.fields.user-name.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query(e);
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'notification',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'user.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView()],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var notification_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    notificationEntityFactory: notificationEntityFactory
+});
+
+async function notificationTemplateEntityFactory(injector) {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.template.name,
+        title: RootConfig.entities.template.title,
+        icon: RootConfig.entities.template.icon,
+        formats: {
+            individual: 't("template",{scope: "notification-management"})',
+            plural: 't("template",{scope: "notification-management"})',
+        },
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.channel.name}`,
+                columns: ['title', 'body', 'channel'],
+                conditions: [
+                    {
+                        name: 'notificationId',
+                        operator: {
+                            type: 'equal',
+                        },
+                        value: 'id',
+                    },
+                ],
+            },
+        ],
+        groups: [
+            {
+                id: 'notification',
+                title: '@general:terms.common.title',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'notification',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'notification',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'notification',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView()],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var template_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    notificationTemplateEntityFactory: notificationTemplateEntityFactory
+});
+
+class AXMNotificationManagementTemplateEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMNotificationManagementTemplateEntityServiceImpl extends AXMNotificationManagementTemplateEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.template.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMNotificationTemplateEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationTemplateEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationTemplateEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationTemplateEntityModule, providers: [
+            {
+                provide: AXMNotificationManagementTemplateEntityService,
+                useClass: AXMNotificationManagementTemplateEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationTemplateEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMNotificationManagementTemplateEntityService,
+                            useClass: AXMNotificationManagementTemplateEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+async function notificationChannelEntityFactory(injector) {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.channel.name,
+        title: RootConfig.entities.channel.title,
+        icon: RootConfig.entities.channel.icon,
+        formats: {
+            individual: `@${i18n}:channel`,
+            plural: `@${i18n}:channels`,
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'notificationChannel',
+                title: 'Notification Channel',
+            },
+            {
+                id: 'in-app',
+                title: 'In App',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'template',
+                title: `@${i18n}:template`,
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+            {
+                name: 'body',
+                title: `@${i18n}:body`,
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'imageId',
+                title: `@${i18n}:body`,
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.attachments,
+                        options: {
+                            multiple: false,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'channel',
+                title: `@${i18n}:channel`,
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'SMS', name: 'sms' },
+                                { title: 'Email', name: 'email' },
+                                { title: 'In App', name: 'inApp' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'type',
+                title: `@${i18n}:type`,
+                groupId: 'in-app',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'Notification', name: 'notification' },
+                                { title: 'Promotion', name: 'promotion' },
+                                { title: 'PopUp', name: 'popup' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'contentType',
+                title: `@${i18n}:contentType`,
+                groupId: 'in-app',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'Media', name: 'media' },
+                                { title: 'Text', name: 'text' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'shape',
+                title: `@${i18n}:shape`,
+                groupId: 'in-app',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'Circle', name: 'circle' },
+                                { title: 'Square', name: 'square' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'placement',
+                title: `t("placement", { scope: "${i18n}" })`,
+                groupId: 'in-app',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'Side Menu Footer', name: 'side-menu-footer' },
+                                { title: 'Side Menu Header', name: 'side-menu-header' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'pin',
+                title: `t("pin", { scope: "${i18n}" })`,
+                groupId: 'in-app',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'trigger',
+                title: `t("trigger", { scope: "${i18n}" })`,
+                groupId: 'notificationChannel',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.cronJob,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'body' }, { name: 'channel' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'notificationChannel',
+                        },
+                        {
+                            id: 'in-app',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'imageId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'template',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'trigger',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'contentType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'shape',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'placement',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'pin',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'notificationChannel',
+                        },
+                        {
+                            id: 'in-app',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'imageId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'template',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'trigger',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'contentType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'shape',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'placement',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'pin',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'notificationChannel',
+                        },
+                        {
+                            id: 'in-app',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'imageId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'template',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'trigger',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'contentType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'shape',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'placement',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'pin',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        {
+                            name: 'all',
+                            title: '@general:terms.interface.selection.all-items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var channel_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    notificationChannelEntityFactory: notificationChannelEntityFactory
+});
+
+class AXMNotificationManagementChannelEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMNotificationManagementChannelEntityServiceImpl extends AXMNotificationManagementChannelEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.channel.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMNotificationEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityModule, providers: [
+            {
+                provide: AXMNotificationEntityService,
+                useClass: AXMNotificationEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMNotificationEntityService,
+                            useClass: AXMNotificationEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMNotificationChannelEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationChannelEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationChannelEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationChannelEntityModule, providers: [
+            {
+                provide: AXMNotificationManagementChannelEntityService,
+                useClass: AXMNotificationManagementChannelEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationChannelEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMNotificationManagementChannelEntityService,
+                            useClass: AXMNotificationManagementChannelEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+// Entity Services
+
+class AXMMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+    }
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Notification Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const NotificationManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
+/** Default notification list sort: pinned first, then newest first within each group. */
+const NOTIFICATION_LIST_SORT = [
+    { field: 'template.isPinned', dir: 'desc' },
+    { field: 'createAt', dir: 'desc' },
+];
+/**
+ * Sorts notifications with pinned items first, then by `createAt` descending.
+ */
+function sortNotificationsByPinnedThenDate(items) {
+    return [...items].sort(compareNotificationsByPinnedThenDate);
+}
+function compareNotificationsByPinnedThenDate(a, b) {
+    const aPinned = a.template.isPinned ? 1 : 0;
+    const bPinned = b.template.isPinned ? 1 : 0;
+    if (aPinned !== bPinned) {
+        return bPinned - aPinned;
+    }
+    return new Date(b.createAt).getTime() - new Date(a.createAt).getTime();
+}
+
+const UNREAD_NOTIFICATION_FILTER = {
+    logic: 'or',
+    filters: [
+        {
+            field: 'readAt',
+            operator: { type: 'isNull' },
+            value: null,
+        },
+        {
+            field: 'readAt',
+            operator: { type: 'equal' },
+            value: false,
+        },
+    ],
+};
+/**
+ * Maps notification page filter chips to an entity query request (filter, sort, paging).
+ */
+function buildNotificationPageQuery(filters, skip, take) {
+    const conditions = [];
+    const readFilter = filters.find((f) => f.field === 'readStatus');
+    if (readFilter?.value === 'unread') {
+        conditions.push(UNREAD_NOTIFICATION_FILTER);
+    }
+    const typeFilter = filters.find((f) => f.field === 'type');
+    if (typeFilter?.value) {
+        conditions.push({
+            field: 'type',
+            operator: { type: 'equal' },
+            value: typeFilter.value,
+        });
+    }
+    const priorityFilter = filters.find((f) => f.field === 'priority');
+    if (priorityFilter?.value) {
+        conditions.push({
+            field: 'template.prority',
+            operator: { type: 'equal' },
+            value: priorityFilter.value,
+        });
+    }
+    const channelFilter = filters.find((f) => f.field === 'channel');
+    if (channelFilter?.value) {
+        conditions.push({
+            field: 'channel',
+            operator: { type: 'equal' },
+            value: channelFilter.value,
+        });
+    }
+    const categoryFilter = filters.find((f) => f.field === 'category');
+    if (categoryFilter?.value) {
+        conditions.push({
+            field: 'template.category',
+            operator: { type: 'equal' },
+            value: categoryFilter.value,
+        });
+    }
+    const searchFilter = filters.find((f) => f.field === 'all');
+    const searchText = searchFilter?.value != null ? String(searchFilter.value).trim() : '';
+    if (searchText) {
+        conditions.push({
+            logic: 'or',
+            filters: [
+                { field: 'title', operator: { type: 'contains' }, value: searchText },
+                { field: 'body', operator: { type: 'contains' }, value: searchText },
+                { field: 'sender.fullName', operator: { type: 'contains' }, value: searchText },
+            ],
+        });
+    }
+    return {
+        skip,
+        take,
+        sort: NOTIFICATION_LIST_SORT,
+        filter: conditions.length > 0 ? { logic: 'and', filters: conditions } : undefined,
+    };
+}
+
+class AXMNotificationRealtimeService {
+    constructor() {
+        this.changedSubject = new Subject();
+        this.changed$ = this.changedSubject.asObservable();
+    }
+    notifyChanged(event) {
+        this.changedSubject.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationRealtimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationRealtimeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationRealtimeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----   Core Imports   ----
+/**
+ * Service to display OS-level notifications using the browser's Notification API.
+ */
+class AXMOsNotificationService {
+    constructor() {
+        this.isSupported = signal(false, ...(ngDevMode ? [{ debugName: "isSupported" }] : /* istanbul ignore next */ []));
+        this.permission = signal(false, ...(ngDevMode ? [{ debugName: "permission" }] : /* istanbul ignore next */ []));
+        this.isSupported.set('Notification' in window);
+    }
+    /**
+     * Requests permission from the user to display desktop notifications.
+     * @returns A promise that resolves to true if permission is granted, false otherwise.
+     */
+    async requestPermission() {
+        if (!this.isSupported()) {
+            console.warn('This browser does not support desktop notifications.');
+            return false;
+        }
+        switch (Notification.permission) {
+            case 'granted':
+                this.permission.set(true);
+                return true;
+            case 'default':
+                const permission = await Notification.requestPermission();
+                this.permission.set(permission === 'granted');
+                return this.permission();
+            default:
+                this.permission.set(false);
+                return false;
+        }
+    }
+    /**
+     * Shows a desktop notification.
+     * This method should be called after ensuring permission has been granted via requestPermission().
+     *
+     * @param title The title of the notification.
+     * @param options Optional notification options including an onClick handler and window focusing.
+     * @returns The Notification object if displayed, otherwise null.
+     */
+    show(title, options) {
+        if (!this.isSupported()) {
+            console.warn('This browser does not support desktop notifications.');
+            return null;
+        }
+        if (!this.permission()) {
+            console.warn(`Notification permission is ${Notification.permission}. Call requestPermission() first.`);
+            return null;
+        }
+        const notification = new Notification(title, options);
+        if (options?.onClick) {
+            notification.onclick = () => {
+                if (options.activeWindow) {
+                    window.focus();
+                }
+                options.onClick();
+            };
+        }
+        return notification;
+    }
+    /**
+     * Dismisses all active notifications or a specific one.
+     * @param notification Optional. Pass a specific notification to close it; otherwise closes all.
+     */
+    dismiss(notification) {
+        if (notification) {
+            notification.close();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMOsNotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMOsNotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMOsNotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Signal store that provides a reactive interface for notification-related operations
+ * Acts as a layer between notification components and the entity service
+ */
+class AXMNotificationConnectorService {
+    constructor() {
+        this.notificationService = inject(AXMNotificationEntityService);
+        this.osNotificationService = inject(AXMOsNotificationService);
+        this.notificationRealtime = inject(AXMNotificationRealtimeService);
+        this.destroyRef = inject(DestroyRef);
+        this.osNotifiedIds = new Set();
+        // State signals
+        this.isLoading = signal(false, ...(ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []));
+        this.pageLoading = signal(false, ...(ngDevMode ? [{ debugName: "pageLoading" }] : /* istanbul ignore next */ []));
+        this.error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+        this.notifications = signal([], ...(ngDevMode ? [{ debugName: "notifications" }] : /* istanbul ignore next */ []));
+        this.totalCount = signal(0, ...(ngDevMode ? [{ debugName: "totalCount" }] : /* istanbul ignore next */ []));
+        this.pageItems = signal([], ...(ngDevMode ? [{ debugName: "pageItems" }] : /* istanbul ignore next */ []));
+        this.pageTotalCount = signal(0, ...(ngDevMode ? [{ debugName: "pageTotalCount" }] : /* istanbul ignore next */ []));
+        // Public computed signals
+        this.loading = computed(() => this.isLoading(), ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+        this.pageLoadingState = computed(() => this.pageLoading(), ...(ngDevMode ? [{ debugName: "pageLoadingState" }] : /* istanbul ignore next */ []));
+        this.errorMessage = computed(() => this.error(), ...(ngDevMode ? [{ debugName: "errorMessage" }] : /* istanbul ignore next */ []));
+        this.notificationList = computed(() => this.notifications(), ...(ngDevMode ? [{ debugName: "notificationList" }] : /* istanbul ignore next */ []));
+        this.total = computed(() => this.totalCount(), ...(ngDevMode ? [{ debugName: "total" }] : /* istanbul ignore next */ []));
+        this.pagedNotificationList = computed(() => this.pageItems(), ...(ngDevMode ? [{ debugName: "pagedNotificationList" }] : /* istanbul ignore next */ []));
+        this.pagedTotal = computed(() => this.pageTotalCount(), ...(ngDevMode ? [{ debugName: "pagedTotal" }] : /* istanbul ignore next */ []));
+        this.unreadCount = computed(() => this.notifications().filter((notification) => notification.readAt === null).length, ...(ngDevMode ? [{ debugName: "unreadCount" }] : /* istanbul ignore next */ []));
+        void this.getList();
+        this.notificationRealtime.changed$
+            .pipe(debounceTime(100), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            if (event.type === 'created' && event.notification) {
+                void this.showOsNotificationForItem(event.notification);
+            }
+            // Read paths already sync `notifications` in markAsRead / markAllAsRead; refetch would duplicate work.
+            if (event.type === 'read') {
+                return;
+            }
+            if (!this.isLoading()) {
+                void this.getList();
+            }
+        });
+    }
+    // Methods from entity service with additional state management
+    /**
+     * Get list of notifications
+     */
+    async getList() {
+        try {
+            this.isLoading.set(true);
+            this.error.set(null);
+            const response = await this.notificationService.getList();
+            const sortedItems = sortNotificationsByPinnedThenDate(response.items);
+            this.notifications.set(sortedItems);
+            this.totalCount.set(response.total);
+            return {
+                ...response,
+                items: sortedItems,
+            };
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to fetch notifications');
+            return { total: 0, items: [] };
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    /**
+     * Loads a single page for the notifications list view without replacing the global notification cache.
+     */
+    async loadPage(filters, skip, take) {
+        try {
+            this.pageLoading.set(true);
+            this.error.set(null);
+            const request = buildNotificationPageQuery(filters, skip, take);
+            const result = await this.notificationService.query(request);
+            const items = sortNotificationsByPinnedThenDate(result.items);
+            this.pageItems.set(items);
+            this.pageTotalCount.set(result.total);
+            return { items, total: result.total };
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to load notifications');
+            this.pageItems.set([]);
+            this.pageTotalCount.set(0);
+            return { items: [], total: 0 };
+        }
+        finally {
+            this.pageLoading.set(false);
+        }
+    }
+    /**
+     * Toggle pinned state for a notification.
+     */
+    async togglePin(id) {
+        try {
+            this.error.set(null);
+            const notification = this.notifications().find((item) => item.id === id) ??
+                this.pageItems().find((item) => item.id === id);
+            if (!notification) {
+                return;
+            }
+            const isPinned = !notification.template.isPinned;
+            const updated = {
+                ...notification,
+                template: { ...notification.template, isPinned },
+            };
+            await this.notificationService.updateOne(id, {
+                template: { ...notification.template, isPinned },
+            });
+            const patchList = (items) => sortNotificationsByPinnedThenDate(items.map((item) => (item.id === id ? updated : item)));
+            this.notifications.update(patchList);
+            this.pageItems.update(patchList);
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to update notification pin');
+            throw err;
+        }
+    }
+    /**
+     * 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)
+     */
+    async markAsRead(payload = { id: [] }) {
+        try {
+            // this.isLoading.set(true);
+            this.error.set(null);
+            await this.notificationService.markAsRead(payload);
+            // Update local state to reflect read status without toggling
+            if (payload?.id?.length) {
+                const patchRead = (notifications) => notifications.map((notification) => {
+                    if (payload.id.includes(notification.id)) {
+                        return notification.readAt === null ? { ...notification, readAt: new Date() } : notification;
+                    }
+                    return notification;
+                });
+                this.notifications.update(patchRead);
+                this.pageItems.update(patchRead);
+            }
+            else {
+                const patchAllRead = (notifications) => notifications.map((notification) => notification.readAt ? notification : { ...notification, readAt: new Date() });
+                this.notifications.update(patchAllRead);
+                this.pageItems.update(patchAllRead);
+            }
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to mark notifications as read');
+        }
+        finally {
+            // this.isLoading.set(false);
+        }
+    }
+    async markAllAsRead() {
+        try {
+            this.error.set(null);
+            await this.notificationService.markAllAsRead();
+            const readAt = new Date();
+            const patchAllRead = (notifications) => notifications.map((notification) => notification.readAt ? notification : { ...notification, readAt });
+            this.notifications.update(patchAllRead);
+            this.pageItems.update(patchAllRead);
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to mark all notifications as read');
+        }
+    }
+    /**
+     * Create a new notification
+     */
+    async create(payload, options) {
+        this.isLoading.set(true);
+        this.error.set(null);
+        //send os notification
+        const isPermissionGranted = await this.osNotificationService.requestPermission();
+        if (payload && isPermissionGranted) {
+            this.osNotificationService.show(payload.title || 'Notification', {
+                body: payload.body || 'No body',
+                ...options,
+            });
+            this.osNotifiedIds.add(payload.id);
+        }
+        const createdNotification = await this.notificationService.create(payload);
+        // Refresh list after creating a notification
+        this.notifications.update((notifications) => sortNotificationsByPinnedThenDate([createdNotification, ...notifications]));
+        this.totalCount.update((count) => count + 1);
+        await this.getList();
+        this.isLoading.set(false);
+    }
+    async showOsNotificationForItem(notification, options) {
+        if (!notification.id || this.osNotifiedIds.has(notification.id)) {
+            return;
+        }
+        const isPermissionGranted = await this.osNotificationService.requestPermission();
+        if (!isPermissionGranted) {
+            return;
+        }
+        this.osNotificationService.show(notification.title || 'Notification', {
+            body: notification.body || 'No body',
+            ...options,
+        });
+        this.osNotifiedIds.add(notification.id);
+    }
+    // Methods from AXMEntityCrudServiceImpl
+    /**
+     * Insert one notification
+     */
+    async insertOne(request) {
+        try {
+            this.isLoading.set(true);
+            this.error.set(null);
+            const id = await this.notificationService.insertOne(request);
+            // Refresh list after inserting
+            await this.getList();
+            return id;
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to insert notification');
+            throw err;
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    /**
+     * Get one notification by id
+     */
+    async getOne(id) {
+        try {
+            this.isLoading.set(true);
+            this.error.set(null);
+            return await this.notificationService.getOne(id);
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : `Failed to get notification with id ${id}`);
+            throw err;
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    /**
+     * Delete one notification
+     */
+    async deleteOne(id) {
+        try {
+            // this.isLoading.set(true);
+            this.error.set(null);
+            await this.notificationService.deleteOne(id);
+            // Update local state to remove deleted notification
+            this.notifications.update((notifications) => notifications.filter((notification) => notification.id !== id));
+            this.pageItems.update((notifications) => notifications.filter((notification) => notification.id !== id));
+            this.totalCount.update((count) => count - 1);
+            this.pageTotalCount.update((count) => Math.max(0, count - 1));
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : `Failed to delete notification with id ${id}`);
+            throw err;
+        }
+        finally {
+            // this.isLoading.set(false);
+        }
+    }
+    /**
+     * Update one notification
+     */
+    async updateOne(id, values) {
+        try {
+            this.isLoading.set(true);
+            this.error.set(null);
+            const updated = await this.notificationService.updateOne(id, values);
+            // Update local state to reflect changes
+            this.notifications.update((notifications) => notifications.map((notification) => notification.id === id ? { ...notification, ...values } : notification));
+            return updated;
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : `Failed to update notification with id ${id}`);
+            throw err;
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    /**
+     * Query notifications
+     */
+    async query(request = { skip: 0, take: 100 }) {
+        try {
+            this.isLoading.set(true);
+            this.error.set(null);
+            const result = await this.notificationService.query(request);
+            // Update local state with query results
+            this.notifications.set(result.items);
+            this.totalCount.set(result.total);
+            return result;
+        }
+        catch (err) {
+            this.error.set(err instanceof Error ? err.message : 'Failed to query notifications');
+            throw err;
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationConnectorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationConnectorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationConnectorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+// Provides a live unread notifications count for header/task badges
+class AXMNotificationBadgeProvider {
+    constructor() {
+        this.notificationService = inject(AXMNotificationConnectorService);
+        this.key = 'badge-notification';
+        this.count = computed(() => this.notificationService.unreadCount(), ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationBadgeProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationBadgeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationBadgeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Permission Keys   ----
+const AXPNotificationManagementPermissionKeys = {
+    NotificationManagement: {
+        Management: 'NotificationManagement:Permission:Management',
+        Email: {
+            ShowDialog: 'NotificationManagement:Permission:Email.ShowDialog',
+            Send: 'NotificationManagement:Permission:Email.Send',
+        },
+    },
+};
+//#endregion
+
+class AXMPermissionDefinitionProvider {
+    constructor() {
+        this.translateService = inject(AXTranslationService);
+    }
+    async define(context) {
+        const trans = async (key) => await this.translateService.translateAsync(`@notification-management:permissions.${key}`);
+        const keys = AXPNotificationManagementPermissionKeys.NotificationManagement;
+        context
+            .addGroup(RootConfig.module.name, await trans('manage.title'), await trans('manage.description'))
+            .addPermission(keys.Management, await trans('manage.permission.title'), await trans('manage.permission.description'))
+            .endPermission()
+            .addPermission(keys.Email.ShowDialog, await trans('email.show-dialog.title'), await trans('email.show-dialog.description'))
+            .endPermission()
+            .addPermission(keys.Email.Send, await trans('email.send.title'), await trans('email.send.description'))
+            .endPermission()
+            .endGroup();
+    }
+}
+
+class AXMEntityLoader {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            return new Promise(async (resolve) => {
+                switch (entityName) {
+                    case RootConfig.entities.template.name: {
+                        const entity = (await Promise.resolve().then(function () { return template_entity; })).notificationTemplateEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.channel.name: {
+                        const entity = (await Promise.resolve().then(function () { return channel_entity; })).notificationChannelEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    //TODO: Add your custom entity here
+                    case 'my-notification': {
+                        const entity = (await Promise.resolve().then(function () { return myNotification; })).myNotificationEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.notification.name: {
+                        const entity = (await Promise.resolve().then(function () { return notification_entity; })).notificationEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    default:
+                        resolve(null);
+                }
+            });
+        }
+        return null;
+    }
+    async list() {
+        const m = RootConfig.module.name;
+        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMEntityLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMEntityLoader, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPNotificationDefinitionProvider {
+}
+const DEFAULT_NOTIFICATION_DEFINITION = [
+// {
+//   name: 'File',
+//   title: 'Email',
+//   icon: 'fa-solid fa-envelope',
+//   async execute(command: AXPExecuteCommand, item: AXMNotificationItem): Promise<void> {
+//     console.log('Execute for email', item);
+//     // In a real implementation, you would perform an action
+//     return Promise.resolve();
+//   },
+// },
+// {
+//   name: 'Chat',
+//   title: 'SMS',
+//   icon: 'fa-solid fa-comment-sms',
+//   async execute(command: AXPExecuteCommand, item: AXMNotificationItem): Promise<void> {
+//     console.log('Execute for sms', item);
+//     // In a real implementation, you would perform an action
+//     return Promise.resolve();
+//   },
+// },
+// {
+//   name: 'Comment',
+//   title: 'Comment',
+//   icon: 'fa-solid fa-comment'
+//   async execute(command: AXPExecuteCommand, item: AXMNotificationItem): Promise<void> {
+//     console.log('Execute for comment', item);
+//     // In a real implementation, you would perform an action
+//     return Promise.resolve();
+//   },
+// },
+// {
+//   name: 'Log',
+//   title: 'Log',
+//   icon: 'fa-solid fa-file-lines',
+//   async execute(command: AXPExecuteCommand, item: AXMNotificationItem): Promise<void> {
+//     console.log('Execute for log', item);
+//     // In a real implementation, you would perform an action
+//     return Promise.resolve();
+//   },
+// },
+];
+class AXPNotificationDefinitionProviderDefault extends AXPNotificationDefinitionProvider {
+    async provide() {
+        return DEFAULT_NOTIFICATION_DEFINITION;
+    }
+}
+const AXP_NOTIFICATION_DEFINITION_PROVIDER = new InjectionToken('AXP_NOTIFICATION_DEFINITION_PROVIDER');
+class AXPNotificationDefinitionService {
+    constructor() {
+        this.providers = inject(AXP_NOTIFICATION_DEFINITION_PROVIDER, { optional: true });
+    }
+    getProviders() {
+        return this.providers?.flat() ?? [];
+    }
+    resolve(name) {
+        return this.getProviders()?.find((p) => p.name === name) ?? null;
+    }
+    execute(command, item) {
+        const provider = this.getProviders()?.find((p) => p.name === item.type);
+        if (!provider) {
+            throw new Error('Notification provider not found');
+        }
+        provider.execute(command, item);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNotificationDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNotificationDefinitionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNotificationDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMAdminNotificationItemComponent {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.notificationDefinitionService = inject(AXPNotificationDefinitionService);
+        //#endregion
+        //#region ----   View Queries   ----
+        this.div = viewChild('component', { ...(ngDevMode ? { debugName: "div" } : /* istanbul ignore next */ {}), read: ViewContainerRef });
+        //#endregion
+        //#region ----   Inputs & Outputs   ----
+        this.data = input.required(...(ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []));
+        this.showAvatar = input(true, ...(ngDevMode ? [{ debugName: "showAvatar" }] : /* istanbul ignore next */ []));
+        this.showDate = input(true, ...(ngDevMode ? [{ debugName: "showDate" }] : /* istanbul ignore next */ []));
+        this.selectionMode = input(false, ...(ngDevMode ? [{ debugName: "selectionMode" }] : /* istanbul ignore next */ []));
+        this.onPressNotificationItem = output();
+        /** Emits when the popover should be closed (e.g., after clicking an item or action) */
+        this.onClosePopover = output();
+        /** Emits when the user toggles pin on the notification row */
+        this.onTogglePin = output();
+        this.#af = afterNextRender(() => this.renderComponent());
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    pressNotificationItem(id) {
+        this.onPressNotificationItem.emit(id);
+        if (this.selectionMode()) {
+            return;
+        }
+        this.getNotificationProvider()?.execute({ name: 'click' }, this.data());
+        this.onClosePopover.emit();
+    }
+    onAction(command) {
+        this.getNotificationProvider()?.execute(command, this.data());
+        this.onClosePopover.emit();
+    }
+    togglePin(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.onTogglePin.emit(this.data().id);
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    getNotificationProvider() {
+        return this.notificationDefinitionService.resolve(this.data().type);
+    }
+    getNotificationContent() {
+        const provider = this.getNotificationProvider();
+        return provider?.content?.();
+    }
+    async renderComponent() {
+        if (this.getNotificationContent() && this.getNotificationProvider()) {
+            const component = await this.getNotificationContent();
+            if (component) {
+                this.div()?.createComponent(component, {
+                    bindings: [
+                        inputBinding('item', this.data),
+                        outputBinding('execute', (e) => this.onAction(e)),
+                    ],
+                });
+            }
+        }
+    }
+    #af;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXMAdminNotificationItemComponent, isStandalone: true, selector: "axp-master-notification-item", inputs: { data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: true, transformFunction: null }, showAvatar: { classPropertyName: "showAvatar", publicName: "showAvatar", isSignal: true, isRequired: false, transformFunction: null }, showDate: { classPropertyName: "showDate", publicName: "showDate", isSignal: true, isRequired: false, transformFunction: null }, selectionMode: { classPropertyName: "selectionMode", publicName: "selectionMode", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onPressNotificationItem: "onPressNotificationItem", onClosePopover: "onClosePopover", onTogglePin: "onTogglePin" }, viewQueries: [{ propertyName: "div", first: true, predicate: ["component"], descendants: true, read: ViewContainerRef, isSignal: true }], ngImport: i0, template: "<div\n  class=\"notification-item ax-text-start\"\n  [id]=\"data().id\"\n  (click)=\"pressNotificationItem(data().id)\"\n  [class]=\"[data().template.prority, data().readAt ? 'read' : 'unread']\"\n>\n  @if (showAvatar()) {\n    <div class=\"notification-avatar\">\n      <axp-user-avatar [size]=\"48\" [userId]=\"data().sender.id\"></axp-user-avatar>\n      @if (!data().readAt) {\n        <div class=\"unread-badge\"></div>\n      }\n    </div>\n  }\n\n  <div class=\"notification-content\">\n    <div class=\"notification-header\">\n      <div class=\"notification-title\" [class.--unread]=\"!data().readAt\">\n        {{ data().sender.fullName || data().title }}\n      </div>\n      <div class=\"notification-meta\">\n        @if (data().template.isPinned) {\n          <button\n            type=\"button\"\n            class=\"pin-notification\"\n            [attr.aria-label]=\"'@notification-management:actions.unpin' | translate | async\"\n            (click)=\"togglePin($event)\"\n          >\n            <ax-icon>\n              <i class=\"fa-solid fa-thumbtack\"></i>\n            </ax-icon>\n          </button>\n        } @else {\n          <button\n            type=\"button\"\n            class=\"pin-notification pin-notification--muted\"\n            [attr.aria-label]=\"'@notification-management:actions.pin' | translate | async\"\n            (click)=\"togglePin($event)\"\n          >\n            <ax-icon>\n              <i class=\"fa-regular fa-thumbtack\"></i>\n            </ax-icon>\n          </button>\n        }\n        @if (showDate()) {\n          <div class=\"notification-time\">{{ data().createAt | format: 'timeleft' | async }}</div>\n        }\n      </div>\n    </div>\n    @if (this.getNotificationContent() && this.getNotificationProvider()) {\n      <div #component></div>\n    } @else {\n      <div class=\"notification-body\">{{ data().body }}</div>\n    }\n  </div>\n</div>\n", styles: [".notification-item{position:relative;display:flex;cursor:pointer;gap:.75rem;border-radius:.375rem;padding:.75rem;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;animation-duration:.15s}.notification-item.read{background:transparent}.notification-item.unread{background:rgb(var(--ax-sys-color-lighter-surface))}@media(hover:hover){.notification-item:hover .pin-notification--muted{visibility:visible;pointer-events:auto}}.notification-item.Notice:before,.notification-item.Danger:before,.notification-item.Warning:before{content:\"\";position:absolute;top:.75rem;bottom:.75rem;inset-inline-start:0px;width:.125rem;border-radius:9999px}.notification-item.Notice:before{background:rgb(var(--ax-sys-color-success-500))}.notification-item.Danger:before{background:rgb(var(--ax-sys-color-danger-500))}.notification-item.Warning:before{background:rgb(var(--ax-sys-color-warning-500))}.notification-item .notification-avatar{position:relative;height:3rem;flex-shrink:0}.notification-item .notification-avatar .unread-badge{position:absolute;bottom:0;inset-inline-end:0px;width:10px;height:10px;background:rgb(var(--ax-sys-color-primary-500));border:2px solid rgb(var(--ax-sys-color-surface));border-radius:50%}.notification-item .notification-content{min-width:0px;flex:1 1 0%}.notification-item .notification-content .notification-header{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.notification-item .notification-content .notification-header .notification-title{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.notification-item .notification-content .notification-header .notification-title.--unread{font-weight:600}.notification-item .notification-content .notification-header .notification-meta{display:flex;flex-shrink:0;align-items:center;gap:.375rem}.notification-item .notification-content .notification-header .notification-meta .notification-time{white-space:nowrap;font-size:.75rem;line-height:1rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .notification-content .notification-body{margin-top:.125rem;overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;text-align:start;font-size:.875rem;line-height:1.25rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .pin-notification{display:inline-flex;align-items:center;justify-content:center;border-radius:9999px;border-width:0px;background-color:transparent;padding:.125rem;color:rgb(var(--ax-sys-color-primary))}.notification-item .pin-notification--muted{color:rgb(var(--ax-sys-color-on-surface-variant))}@media(hover:hover){.notification-item .pin-notification--muted{visibility:hidden;pointer-events:none}}.notification-item .pin-notification--muted:focus-visible{visibility:visible;pointer-events:auto}.notification-item .pin-notification--muted:hover{color:rgb(var(--ax-sys-color-primary))}.notification-item .pin-notification i{--tw-rotate: 45deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));font-size:.75rem;line-height:1rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: AXPUserAvatarComponent, selector: "axp-user-avatar", inputs: ["size", "userId"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "ngmodule", type: AXFormatModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i3.AXFormatPipe, name: "format" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-master-notification-item', changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                        CommonModule,
+                        AXButtonModule,
+                        AXDecoratorModule,
+                        AXPUserAvatarComponent,
+                        AXImageModule,
+                        AXBadgeModule,
+                        AXFormatModule,
+                        AXTranslationModule,
+                    ], template: "<div\n  class=\"notification-item ax-text-start\"\n  [id]=\"data().id\"\n  (click)=\"pressNotificationItem(data().id)\"\n  [class]=\"[data().template.prority, data().readAt ? 'read' : 'unread']\"\n>\n  @if (showAvatar()) {\n    <div class=\"notification-avatar\">\n      <axp-user-avatar [size]=\"48\" [userId]=\"data().sender.id\"></axp-user-avatar>\n      @if (!data().readAt) {\n        <div class=\"unread-badge\"></div>\n      }\n    </div>\n  }\n\n  <div class=\"notification-content\">\n    <div class=\"notification-header\">\n      <div class=\"notification-title\" [class.--unread]=\"!data().readAt\">\n        {{ data().sender.fullName || data().title }}\n      </div>\n      <div class=\"notification-meta\">\n        @if (data().template.isPinned) {\n          <button\n            type=\"button\"\n            class=\"pin-notification\"\n            [attr.aria-label]=\"'@notification-management:actions.unpin' | translate | async\"\n            (click)=\"togglePin($event)\"\n          >\n            <ax-icon>\n              <i class=\"fa-solid fa-thumbtack\"></i>\n            </ax-icon>\n          </button>\n        } @else {\n          <button\n            type=\"button\"\n            class=\"pin-notification pin-notification--muted\"\n            [attr.aria-label]=\"'@notification-management:actions.pin' | translate | async\"\n            (click)=\"togglePin($event)\"\n          >\n            <ax-icon>\n              <i class=\"fa-regular fa-thumbtack\"></i>\n            </ax-icon>\n          </button>\n        }\n        @if (showDate()) {\n          <div class=\"notification-time\">{{ data().createAt | format: 'timeleft' | async }}</div>\n        }\n      </div>\n    </div>\n    @if (this.getNotificationContent() && this.getNotificationProvider()) {\n      <div #component></div>\n    } @else {\n      <div class=\"notification-body\">{{ data().body }}</div>\n    }\n  </div>\n</div>\n", styles: [".notification-item{position:relative;display:flex;cursor:pointer;gap:.75rem;border-radius:.375rem;padding:.75rem;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;animation-duration:.15s}.notification-item.read{background:transparent}.notification-item.unread{background:rgb(var(--ax-sys-color-lighter-surface))}@media(hover:hover){.notification-item:hover .pin-notification--muted{visibility:visible;pointer-events:auto}}.notification-item.Notice:before,.notification-item.Danger:before,.notification-item.Warning:before{content:\"\";position:absolute;top:.75rem;bottom:.75rem;inset-inline-start:0px;width:.125rem;border-radius:9999px}.notification-item.Notice:before{background:rgb(var(--ax-sys-color-success-500))}.notification-item.Danger:before{background:rgb(var(--ax-sys-color-danger-500))}.notification-item.Warning:before{background:rgb(var(--ax-sys-color-warning-500))}.notification-item .notification-avatar{position:relative;height:3rem;flex-shrink:0}.notification-item .notification-avatar .unread-badge{position:absolute;bottom:0;inset-inline-end:0px;width:10px;height:10px;background:rgb(var(--ax-sys-color-primary-500));border:2px solid rgb(var(--ax-sys-color-surface));border-radius:50%}.notification-item .notification-content{min-width:0px;flex:1 1 0%}.notification-item .notification-content .notification-header{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.notification-item .notification-content .notification-header .notification-title{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.notification-item .notification-content .notification-header .notification-title.--unread{font-weight:600}.notification-item .notification-content .notification-header .notification-meta{display:flex;flex-shrink:0;align-items:center;gap:.375rem}.notification-item .notification-content .notification-header .notification-meta .notification-time{white-space:nowrap;font-size:.75rem;line-height:1rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .notification-content .notification-body{margin-top:.125rem;overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;text-align:start;font-size:.875rem;line-height:1.25rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .pin-notification{display:inline-flex;align-items:center;justify-content:center;border-radius:9999px;border-width:0px;background-color:transparent;padding:.125rem;color:rgb(var(--ax-sys-color-primary))}.notification-item .pin-notification--muted{color:rgb(var(--ax-sys-color-on-surface-variant))}@media(hover:hover){.notification-item .pin-notification--muted{visibility:hidden;pointer-events:none}}.notification-item .pin-notification--muted:focus-visible{visibility:visible;pointer-events:auto}.notification-item .pin-notification--muted:hover{color:rgb(var(--ax-sys-color-primary))}.notification-item .pin-notification i{--tw-rotate: 45deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));font-size:.75rem;line-height:1rem}\n"] }]
+        }], propDecorators: { div: [{ type: i0.ViewChild, args: ['component', { ...{ read: ViewContainerRef }, isSignal: true }] }], data: [{ type: i0.Input, args: [{ isSignal: true, alias: "data", required: true }] }], showAvatar: [{ type: i0.Input, args: [{ isSignal: true, alias: "showAvatar", required: false }] }], showDate: [{ type: i0.Input, args: [{ isSignal: true, alias: "showDate", required: false }] }], selectionMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectionMode", required: false }] }], onPressNotificationItem: [{ type: i0.Output, args: ["onPressNotificationItem"] }], onClosePopover: [{ type: i0.Output, args: ["onClosePopover"] }], onTogglePin: [{ type: i0.Output, args: ["onTogglePin"] }] } });
+
+class AXMAdminNotificationPanelComponent {
+    constructor() {
+        //#region ----   Outputs   ----
+        this.onNewNotification = output();
+        /** Emits when the popover should be closed (bubbled from item components) */
+        this.onClosePopover = output();
+        //#endregion
+        //#region ----   Services & Dependencies   ----
+        this.notificationConnector = inject(AXMNotificationConnectorService);
+        this.toastService = inject(AXToastService);
+        this.router = inject(Router);
+        this.sessionService = inject(AXPSessionService);
+        //#endregion
+        //#region ----   Signals & Inputs   ----
+        /**
+         * Tabs provided by the parent (custom categories). The component will prepend
+         * "Unread" and "All" before these tabs.
+         */
+        this.providedTabs = input([], ...(ngDevMode ? [{ debugName: "providedTabs" }] : /* istanbul ignore next */ []));
+        // Use store's signals directly
+        this.notifications = this.notificationConnector.notificationList;
+        this.totalNotifications = this.notificationConnector.total;
+        this.isLoading = this.notificationConnector.loading;
+        this.errorMessage = this.notificationConnector.errorMessage;
+        // Default active tab is Unread
+        this.activeTab = signal('Unread', ...(ngDevMode ? [{ debugName: "activeTab" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Computed Properties   ----
+        this.tabItems = computed(() => this.getTabItems(this.notifications(), this.providedTabs()), { ...(ngDevMode ? { debugName: "tabItems" } : /* istanbul ignore next */ {}), equal: (a, b) => JSON.stringify(a) === JSON.stringify(b) });
+        this.NewNotification = computed(() => this.getNewNotification(this.tabItems()), ...(ngDevMode ? [{ debugName: "NewNotification" }] : /* istanbul ignore next */ []));
+        this.NewNotificationEffect = effect(() => this.onNewNotification.emit(this.NewNotification()), ...(ngDevMode ? [{ debugName: "NewNotificationEffect" }] : /* istanbul ignore next */ []));
+    }
+    changeActiveTab(tab) {
+        this.activeTab.set(tab);
+    }
+    //#endregion
+    ngOnInit() {
+        this.loadNotification();
+    }
+    async loadNotification() {
+        try {
+            await this.notificationConnector.getList();
+        }
+        catch (error) {
+            this.toastService.show({
+                content: typeof error === 'string' ? error : 'Failed to load notifications!',
+                color: 'danger',
+                location: 'bottom-center',
+                closeButton: true,
+                timeOut: 3000,
+                timeOutProgress: true,
+            });
+        }
+    }
+    //#region ----   Utility Methods   ----
+    getTabItems(notifications, userTabs) {
+        // Base when no notifications loaded yet
+        if (!notifications) {
+            const base = [
+                { key: 'Unread', labelKey: '@notification-management:unread', count: 0 },
+                { key: 'All', labelKey: '@notification-management:all', count: 0 },
+            ];
+            return base.concat((userTabs ?? []).map((t) => ({ key: t, labelKey: t, count: 0 })));
+        }
+        // Count unread by category
+        const unreadCountByCategory = new Map();
+        for (const notification of notifications) {
+            const category = notification.template.category;
+            if (!unreadCountByCategory.has(category)) {
+                unreadCountByCategory.set(category, 0);
+            }
+            if (!notification.readAt) {
+                unreadCountByCategory.set(category, (unreadCountByCategory.get(category) ?? 0) + 1);
+            }
+        }
+        const unreadTotal = Array.from(unreadCountByCategory.values()).reduce((a, b) => a + b, 0);
+        // Keep previous behavior: 'All' badge shows total UNREAD across all categories
+        const allTotal = unreadTotal;
+        // Determine which tabs to show after Unread and All
+        let finalUserTabs = userTabs ?? [];
+        if (finalUserTabs.length === 0) {
+            // Fallback to discovered categories if parent has not provided tabs
+            finalUserTabs = Array.from(unreadCountByCategory.keys());
+        }
+        // Ensure uniqueness and preserve provided order
+        const seen = new Set(['Unread', 'All']);
+        const userCategoryTabs = finalUserTabs.filter((t) => {
+            if (seen.has(t))
+                return false;
+            seen.add(t);
+            return true;
+        });
+        const result = [
+            { key: 'Unread', labelKey: '@notification-management:unread', count: unreadTotal },
+            { key: 'All', labelKey: '@notification-management:all', count: allTotal },
+            ...userCategoryTabs.map((category) => ({
+                key: category,
+                labelKey: category,
+                count: unreadCountByCategory.get(category) ?? 0,
+            })),
+        ];
+        return result;
+    }
+    getNewNotification(data) {
+        // Use the Unread tab as the single source of truth for new notifications
+        return data.find((tab) => tab.key === 'Unread')?.count ?? 0;
+    }
+    getNotificationItems(category) {
+        const list = this.notifications();
+        if (!list)
+            return [];
+        if (category === 'All') {
+            return list;
+        }
+        if (category === 'Unread') {
+            return list.filter((item) => !item.readAt);
+        }
+        return list.filter((item) => item.template.category === category);
+    }
+    /**
+     * Mark a notification as read or unread (toggle read status)
+     */
+    async markAsRead(id) {
+        try {
+            await this.notificationConnector.markAsRead({ id: [id] });
+        }
+        catch (error) {
+            console.error('Failed to toggle notification read status:', error);
+        }
+    }
+    async togglePin(id) {
+        try {
+            await this.notificationConnector.togglePin(id);
+        }
+        catch (error) {
+            console.error('Failed to toggle notification pin:', error);
+        }
+    }
+    /**
+     * Mark all unread notifications as read
+     */
+    async markAllAsRead() {
+        try {
+            await this.notificationConnector.markAllAsRead();
+        }
+        catch (error) {
+            console.error('Failed to mark all notifications as read:', error);
+        }
+    }
+    viewAllNotifications() {
+        this.onClosePopover.emit();
+        this.router.navigate([`${this.sessionService.application?.name}/notifications`]);
+    }
+    openSettings() {
+        this.onClosePopover.emit();
+        this.router.navigate([
+            this.sessionService.application?.name,
+            'settings',
+            'tenant',
+            'notification-settings',
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXMAdminNotificationPanelComponent, isStandalone: true, selector: "axm-admin-notification-panel", inputs: { providedTabs: { classPropertyName: "providedTabs", publicName: "providedTabs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onNewNotification: "onNewNotification", onClosePopover: "onClosePopover" }, ngImport: i0, template: "<div class=\"notification-panel__header\">\n  <span class=\"notification-panel__title\">\n    {{ '@notification-management:notifications' | translate | async }}\n  </span>\n  <ax-button color=\"default\" look=\"blank\" (onClick)=\"openSettings()\">\n    <ax-icon>\n      <i class=\"fa-regular fa-gear fa-lg\"></i>\n    </ax-icon>\n  </ax-button>\n</div>\n<ax-tabs [content]=\"cons\" look=\"with-line\" location=\"bottom\">\n  @for (tab of tabItems(); track tab.key) {\n    <ax-tab-item\n      [text]=\"(tab.labelKey | translate | async) ?? ''\"\n      [active]=\"activeTab() === tab.key\"\n      (activeChange)=\"changeActiveTab(tab.key)\"\n    >\n      <ax-suffix>\n        @if (tab.count && tab.key === 'Unread') {\n          <ax-badge [color]=\"activeTab() === tab.key ? 'primary' : 'ghost'\" [text]=\"tab.count.toString()\"></ax-badge>\n        }\n      </ax-suffix>\n      <ax-content>\n        <div class=\"notification-panel__list\">\n          @if (isLoading()) {\n            <div class=\"notification-panel__loading\">\n              @for (_ of [1, 2, 3]; track $index) {\n                <div class=\"notification-panel__skeleton\">\n                  <div class=\"notification-panel__skeleton-avatar\"></div>\n                  <div class=\"notification-panel__skeleton-lines\">\n                    <div class=\"notification-panel__skeleton-line --wide\"></div>\n                    <div class=\"notification-panel__skeleton-line\"></div>\n                  </div>\n                </div>\n              }\n            </div>\n          } @else if (getNotificationItems(tab.key).length === 0) {\n            <axp-state-message\n              icon=\"fa-regular fa-bell-slash\"\n              [title]=\"'@notification-management:state-message.no-notifications.title'\"\n              [description]=\"'@notification-management:state-message.no-notifications.description'\"\n            />\n          } @else {\n            @for (notif of getNotificationItems(tab.key); track notif.id) {\n              <axp-master-notification-item\n                [data]=\"notif\"\n                (onPressNotificationItem)=\"markAsRead($event)\"\n                (onTogglePin)=\"togglePin($event)\"\n                (onClosePopover)=\"onClosePopover.emit()\"\n              />\n            }\n          }\n        </div>\n        <div class=\"notification-panel__footer\">\n          <ax-button\n            [disabled]=\"NewNotification() === 0\"\n            color=\"default\"\n            [text]=\"('@notification-management:actions.mark-all-as-read' | translate | async) ?? ''\"\n            (onClick)=\"markAllAsRead()\"\n          />\n          <ax-button\n            color=\"primary\"\n            [text]=\"('@notification-management:actions.view-all' | translate | async) ?? ''\"\n            (onClick)=\"viewAllNotifications()\"\n          />\n        </div>\n      </ax-content>\n    </ax-tab-item>\n  }\n</ax-tabs>\n\n<ng-template [axTabContent] #cons=\"axTabContent\"></ng-template>\n", styles: [".notification-panel__header{display:flex;align-items:center;justify-content:space-between;padding:1rem}.notification-panel__title{font-size:1.25rem;line-height:1.75rem;font-weight:600;color:rgb(var(--ax-sys-color-on-surface))}.notification-panel__list{max-height:50vh;overflow-y:auto}@media(min-width:768px){.notification-panel__list{width:32rem}}.notification-panel__footer{display:flex;justify-content:space-between;gap:1rem;border-top-width:1px;padding:1rem;border-color:rgb(var(--ax-sys-color-border-surface))}.notification-panel__loading>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.notification-panel__loading{padding:.5rem}.notification-panel__skeleton{display:flex}@keyframes ax-pulse{50%{transform:scale3d(1.05,1.05,1.05)}}.notification-panel__skeleton{animation:1s ease-in-out both ax-pulse;gap:1rem;padding:1rem}.notification-panel__skeleton-avatar{height:3rem;width:3rem;flex-shrink:0;border-radius:9999px;background:rgb(var(--ax-sys-color-lighter-surface))}.notification-panel__skeleton-lines{flex:1 1 0%}.notification-panel__skeleton-lines>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.notification-panel__skeleton-lines{padding-top:.25rem;padding-bottom:.25rem}.notification-panel__skeleton-line{height:.75rem;border-radius:.375rem;background:rgb(var(--ax-sys-color-lighter-surface))}.notification-panel__skeleton-line.--wide{width:75%}.notification-panel__skeleton-line:not(.--wide){width:50%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXTabsModule }, { kind: "component", type: i2$1.AXTabsComponent, selector: "ax-tabs", inputs: ["look", "location", "fitParent", "minWidth", "content"], outputs: ["onActiveTabChanged"] }, { kind: "component", type: i2$1.AXTabItemComponent, selector: "ax-tab-item", inputs: ["disabled", "text", "key", "headerTemplate", "active"], outputs: ["disabledChange", "onClick", "onBlur", "onFocus", "activeChange"] }, { kind: "directive", type: i2$1.AXTabContentDirective, selector: "[axTabContent]", inputs: ["axTabContent"], exportAs: ["axTabContent"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i3$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: AXMAdminNotificationItemComponent, selector: "axp-master-notification-item", inputs: ["data", "showAvatar", "showDate", "selectionMode"], outputs: ["onPressNotificationItem", "onClosePopover", "onTogglePin"] }, { kind: "ngmodule", type: AXFormatModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "look"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-admin-notification-panel', changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                        CommonModule,
+                        AXButtonModule,
+                        AXTabsModule,
+                        AXDecoratorModule,
+                        AXBadgeModule,
+                        AXPopoverModule,
+                        AXMAdminNotificationItemComponent,
+                        AXFormatModule,
+                        AXTranslationModule,
+                        AXPStateMessageComponent,
+                    ], template: "<div class=\"notification-panel__header\">\n  <span class=\"notification-panel__title\">\n    {{ '@notification-management:notifications' | translate | async }}\n  </span>\n  <ax-button color=\"default\" look=\"blank\" (onClick)=\"openSettings()\">\n    <ax-icon>\n      <i class=\"fa-regular fa-gear fa-lg\"></i>\n    </ax-icon>\n  </ax-button>\n</div>\n<ax-tabs [content]=\"cons\" look=\"with-line\" location=\"bottom\">\n  @for (tab of tabItems(); track tab.key) {\n    <ax-tab-item\n      [text]=\"(tab.labelKey | translate | async) ?? ''\"\n      [active]=\"activeTab() === tab.key\"\n      (activeChange)=\"changeActiveTab(tab.key)\"\n    >\n      <ax-suffix>\n        @if (tab.count && tab.key === 'Unread') {\n          <ax-badge [color]=\"activeTab() === tab.key ? 'primary' : 'ghost'\" [text]=\"tab.count.toString()\"></ax-badge>\n        }\n      </ax-suffix>\n      <ax-content>\n        <div class=\"notification-panel__list\">\n          @if (isLoading()) {\n            <div class=\"notification-panel__loading\">\n              @for (_ of [1, 2, 3]; track $index) {\n                <div class=\"notification-panel__skeleton\">\n                  <div class=\"notification-panel__skeleton-avatar\"></div>\n                  <div class=\"notification-panel__skeleton-lines\">\n                    <div class=\"notification-panel__skeleton-line --wide\"></div>\n                    <div class=\"notification-panel__skeleton-line\"></div>\n                  </div>\n                </div>\n              }\n            </div>\n          } @else if (getNotificationItems(tab.key).length === 0) {\n            <axp-state-message\n              icon=\"fa-regular fa-bell-slash\"\n              [title]=\"'@notification-management:state-message.no-notifications.title'\"\n              [description]=\"'@notification-management:state-message.no-notifications.description'\"\n            />\n          } @else {\n            @for (notif of getNotificationItems(tab.key); track notif.id) {\n              <axp-master-notification-item\n                [data]=\"notif\"\n                (onPressNotificationItem)=\"markAsRead($event)\"\n                (onTogglePin)=\"togglePin($event)\"\n                (onClosePopover)=\"onClosePopover.emit()\"\n              />\n            }\n          }\n        </div>\n        <div class=\"notification-panel__footer\">\n          <ax-button\n            [disabled]=\"NewNotification() === 0\"\n            color=\"default\"\n            [text]=\"('@notification-management:actions.mark-all-as-read' | translate | async) ?? ''\"\n            (onClick)=\"markAllAsRead()\"\n          />\n          <ax-button\n            color=\"primary\"\n            [text]=\"('@notification-management:actions.view-all' | translate | async) ?? ''\"\n            (onClick)=\"viewAllNotifications()\"\n          />\n        </div>\n      </ax-content>\n    </ax-tab-item>\n  }\n</ax-tabs>\n\n<ng-template [axTabContent] #cons=\"axTabContent\"></ng-template>\n", styles: [".notification-panel__header{display:flex;align-items:center;justify-content:space-between;padding:1rem}.notification-panel__title{font-size:1.25rem;line-height:1.75rem;font-weight:600;color:rgb(var(--ax-sys-color-on-surface))}.notification-panel__list{max-height:50vh;overflow-y:auto}@media(min-width:768px){.notification-panel__list{width:32rem}}.notification-panel__footer{display:flex;justify-content:space-between;gap:1rem;border-top-width:1px;padding:1rem;border-color:rgb(var(--ax-sys-color-border-surface))}.notification-panel__loading>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.notification-panel__loading{padding:.5rem}.notification-panel__skeleton{display:flex}@keyframes ax-pulse{50%{transform:scale3d(1.05,1.05,1.05)}}.notification-panel__skeleton{animation:1s ease-in-out both ax-pulse;gap:1rem;padding:1rem}.notification-panel__skeleton-avatar{height:3rem;width:3rem;flex-shrink:0;border-radius:9999px;background:rgb(var(--ax-sys-color-lighter-surface))}.notification-panel__skeleton-lines{flex:1 1 0%}.notification-panel__skeleton-lines>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.notification-panel__skeleton-lines{padding-top:.25rem;padding-bottom:.25rem}.notification-panel__skeleton-line{height:.75rem;border-radius:.375rem;background:rgb(var(--ax-sys-color-lighter-surface))}.notification-panel__skeleton-line.--wide{width:75%}.notification-panel__skeleton-line:not(.--wide){width:50%}\n"] }]
+        }], propDecorators: { onNewNotification: [{ type: i0.Output, args: ["onNewNotification"] }], onClosePopover: [{ type: i0.Output, args: ["onClosePopover"] }], providedTabs: [{ type: i0.Input, args: [{ isSignal: true, alias: "providedTabs", required: false }] }] } });
+
+class AXMAdminNotificationSlotComponent {
+    constructor() {
+        //#region ----   Signals   ----
+        this.totalNewNotification = signal(0, ...(ngDevMode ? [{ debugName: "totalNewNotification" }] : /* istanbul ignore next */ []));
+        this.badgeDisplay = computed(() => {
+            const total = this.totalNewNotification();
+            if (total <= 0) {
+                return '';
+            }
+            return total > 50 ? '50+' : total.toString();
+        }, ...(ngDevMode ? [{ debugName: "badgeDisplay" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   View Queries   ----
+        this.popover = viewChild(AXPopoverComponent, ...(ngDevMode ? [{ debugName: "popover" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    setTotalNewNotification(value) {
+        this.totalNewNotification.set(value);
+    }
+    closePopover() {
+        this.popover()?.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXMAdminNotificationSlotComponent, isStandalone: true, selector: "axm-admin-notification-slot", viewQueries: [{ propertyName: "popover", first: true, predicate: AXPopoverComponent, descendants: true, isSignal: true }], ngImport: i0, template: "<ax-button class=\"ax-relative\" color=\"primary\" #notification>\n  <ax-icon>\n    <i class=\"fa-regular fa-bell\"></i>\n  </ax-icon>\n\n</ax-button>\n<div class=\"__badge\" [class.--xs]=\"badgeDisplay().length > 2\">\n  @if (badgeDisplay()) {\n  <ax-badge color=\"danger\" [text]=\"badgeDisplay()\"></ax-badge>\n  }\n</div>\n<ax-popover [target]=\"notification\" [openOn]=\"'toggle'\" [closeOn]=\"'clickOut'\" [adaptivityEnabled]=\"true\">\n  <div class=\"ax-bg-lightest ax-rounded-md ax-w-full\">\n    <axm-admin-notification-panel (onNewNotification)=\"setTotalNewNotification($event)\"\n      (onClosePopover)=\"closePopover()\">\n    </axm-admin-notification-panel>\n  </div>\n</ax-popover>", styles: ["axm-admin-notification-slot{position:relative}axm-admin-notification-slot .__badge{position:absolute;top:-.25rem;inset-inline-end:-.25rem;pointer-events:none}\n"], dependencies: [{ kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i3$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i4$1.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "disablePanelClass", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "closeOnScroll", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "component", type: AXMAdminNotificationPanelComponent, selector: "axm-admin-notification-panel", inputs: ["providedTabs"], outputs: ["onNewNotification", "onClosePopover"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMAdminNotificationSlotComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-admin-notification-slot', changeDetection: ChangeDetectionStrategy.OnPush, imports: [AXButtonModule, AXDecoratorModule, AXBadgeModule, AXPopoverModule, AXMAdminNotificationPanelComponent], encapsulation: ViewEncapsulation.None, template: "<ax-button class=\"ax-relative\" color=\"primary\" #notification>\n  <ax-icon>\n    <i class=\"fa-regular fa-bell\"></i>\n  </ax-icon>\n\n</ax-button>\n<div class=\"__badge\" [class.--xs]=\"badgeDisplay().length > 2\">\n  @if (badgeDisplay()) {\n  <ax-badge color=\"danger\" [text]=\"badgeDisplay()\"></ax-badge>\n  }\n</div>\n<ax-popover [target]=\"notification\" [openOn]=\"'toggle'\" [closeOn]=\"'clickOut'\" [adaptivityEnabled]=\"true\">\n  <div class=\"ax-bg-lightest ax-rounded-md ax-w-full\">\n    <axm-admin-notification-panel (onNewNotification)=\"setTotalNewNotification($event)\"\n      (onClosePopover)=\"closePopover()\">\n    </axm-admin-notification-panel>\n  </div>\n</ax-popover>", styles: ["axm-admin-notification-slot{position:relative}axm-admin-notification-slot .__badge{position:absolute;top:-.25rem;inset-inline-end:-.25rem;pointer-events:none}\n"] }]
+        }], propDecorators: { popover: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPopoverComponent), { isSignal: true }] }] } });
+
+/**
+ * Notification Widget Component
+ * Displays notifications in a card with tabs
+ */
+class AXPNotificationWidgetViewComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super();
+        // Outputs
+        this.notificationClick = output();
+        this.markAsRead = output();
+        // Dependencies
+        this.cdr = inject(ChangeDetectorRef);
+        this.datePipe = inject(DatePipe);
+        this.notificationConnector = inject(AXMNotificationConnectorService);
+        this.toastService = inject(AXToastService);
+        // State
+        this.activeTab = signal('unread', ...(ngDevMode ? [{ debugName: "activeTab" }] : /* istanbul ignore next */ []));
+        this.refreshTimerId = null;
+        // Configuration
+        this.maxItems = computed(() => this.options()?.['maxItems'] ?? 10, ...(ngDevMode ? [{ debugName: "maxItems" }] : /* istanbul ignore next */ []));
+        this.showAvatar = computed(() => this.options()?.['showAvatar'] ?? true, ...(ngDevMode ? [{ debugName: "showAvatar" }] : /* istanbul ignore next */ []));
+        this.showDate = computed(() => this.options()?.['showDate'] ?? true, ...(ngDevMode ? [{ debugName: "showDate" }] : /* istanbul ignore next */ []));
+        this.autoRefresh = computed(() => this.options()?.['autoRefresh'] ?? true, ...(ngDevMode ? [{ debugName: "autoRefresh" }] : /* istanbul ignore next */ []));
+        this.refreshInterval = computed(() => (this.options()?.['refreshInterval'] ?? 60) * 1000, ...(ngDevMode ? [{ debugName: "refreshInterval" }] : /* istanbul ignore next */ [])); // Convert to milliseconds
+        // Use store's signals directly
+        this.notifications = this.notificationConnector.notificationList;
+        this.totalNotifications = this.notificationConnector.total;
+        this.isLoading = this.notificationConnector.loading;
+        // Computed data
+        this.notificationItems = computed(() => {
+            const items = this.notifications();
+            if (!items?.length)
+                return [];
+            const sortedItems = sortNotificationsByPinnedThenDate(items);
+            // Filter by active tab
+            const filtered = this.activeTab() === 'unread' ? sortedItems.filter((n) => !n.readAt) : sortedItems;
+            return filtered.slice(0, this.maxItems());
+        }, ...(ngDevMode ? [{ debugName: "notificationItems" }] : /* istanbul ignore next */ []));
+        /**
+         * Bridge click from admin item (emits notification id)
+         */
+        this.onAdminItemClick = async (id) => {
+            const item = this.notifications()?.find((n) => n.id === id);
+            if (!item) {
+                return;
+            }
+            await this.markAsReadIfNeeded(item);
+            this.notificationClick.emit(item);
+        };
+        this.onTogglePin = async (id) => {
+            try {
+                await this.notificationConnector.togglePin(id);
+                this.cdr.detectChanges();
+            }
+            catch (error) {
+                this.toastService.show({
+                    content: 'Failed to update notification pin',
+                    color: 'danger',
+                    location: 'bottom-center',
+                    closeButton: true,
+                    timeOut: 3000,
+                });
+            }
+        };
+        // Watch for changes to auto-refresh settings
+        effect(() => {
+            this.setupAutoRefresh();
+        });
+    }
+    ngOnInit() {
+        this.loadNotifications();
+    }
+    ngOnDestroy() {
+        this.clearRefreshTimer();
+    }
+    /**
+     * Set up auto-refresh timer based on configuration
+     */
+    setupAutoRefresh() {
+        this.clearRefreshTimer();
+        if (this.autoRefresh()) {
+            const interval = this.refreshInterval();
+            this.refreshTimerId = setInterval(() => {
+                this.loadNotifications();
+            }, interval);
+        }
+    }
+    /**
+     * Clear the refresh timer if it exists
+     */
+    clearRefreshTimer() {
+        if (this.refreshTimerId !== null) {
+            clearInterval(this.refreshTimerId);
+            this.refreshTimerId = null;
+        }
+    }
+    /**
+     * Load notifications data from service
+     */
+    async loadNotifications() {
+        try {
+            await this.notificationConnector.getList();
+            this.cdr.detectChanges();
+        }
+        catch (error) {
+            this.toastService.show({
+                content: typeof error === 'string' ? error : 'Failed to load notifications!',
+                color: 'danger',
+                location: 'bottom-center',
+                closeButton: true,
+                timeOut: 3000,
+                timeOutProgress: true,
+            });
+        }
+    }
+    /**
+     * Manually refresh notifications
+     */
+    refreshNotifications() {
+        this.loadNotifications();
+    }
+    /**
+     * Get the count of new messages for the badge
+     */
+    getNewMessageCount() {
+        const items = this.notifications();
+        if (!items?.length)
+            return 0;
+        return items.filter((n) => !n.readAt).length;
+    }
+    /**
+     * Handle tab change event from ax-tabs component
+     * @param data The tab change event data
+     */
+    handleTabChange(data) {
+        const index = data.index;
+        // Map index to tab name: 0 = 'unread', 1 = 'all'
+        const tabName = index === 0 ? 'unread' : 'all';
+        this.onTabChange(tabName);
+    }
+    /**
+     * Mark all notifications as read
+     */
+    async markAllAsRead() {
+        try {
+            await this.notificationConnector.markAsRead({ id: [] });
+            this.cdr.detectChanges();
+        }
+        catch (error) {
+            this.toastService.show({
+                content: 'Failed to mark notifications as read',
+                color: 'danger',
+                location: 'bottom-center',
+                closeButton: true,
+                timeOut: 3000,
+            });
+        }
+    }
+    /**
+     * Change the active tab
+     */
+    onTabChange(tabName) {
+        this.activeTab.set(tabName);
+        this.cdr.detectChanges();
+    }
+    /**
+     * Handle notification click event
+     */
+    onNotificationClick(notification) {
+        this.markAsReadIfNeeded(notification);
+        this.notificationClick.emit(notification);
+    }
+    /**
+     * Format the timestamp in a user-friendly way
+     */
+    formatTime(date) {
+        if (!date)
+            return '';
+        const dateObj = typeof date === 'string' ? new Date(date) : date;
+        const diffDays = this.getDaysDifference(dateObj);
+        // Format based on how recent the date is
+        if (diffDays === 0)
+            return this.datePipe.transform(dateObj, 'h:mm a') || ''; // Today
+        if (diffDays === 1)
+            return 'Yesterday';
+        if (diffDays < 7)
+            return this.datePipe.transform(dateObj, 'EEE') || ''; // Day of week
+        return this.datePipe.transform(dateObj, 'MM/DD/YYYY') || ''; // Older date
+    }
+    /**
+     * Mark notification as read if needed
+     */
+    async markAsReadIfNeeded(notification) {
+        try {
+            // Always mark as read on click if unread, but don't toggle back to unread
+            if (notification.readAt)
+                return;
+            await this.notificationConnector.markAsRead({ id: [notification.id] });
+            // Emit the updated notification with readAt set
+            // It will be read now because we only call this for unread notifications
+            const updatedNotification = {
+                ...notification,
+                readAt: new Date(),
+            };
+            this.markAsRead.emit(updatedNotification);
+            this.cdr.detectChanges();
+        }
+        catch (error) {
+            console.error('Failed to mark notification as read:', error);
+        }
+    }
+    /**
+     * Calculate days difference from now
+     */
+    getDaysDifference(date) {
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNotificationWidgetViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXPNotificationWidgetViewComponent, isStandalone: true, selector: "ng-component", outputs: { notificationClick: "notificationClick", markAsRead: "markAsRead" }, providers: [
+            DatePipe,
+            // Provide a lightweight stub for AXMAdminNotificationSlotComponent so the admin item can inject it
+            {
+                provide: AXMAdminNotificationSlotComponent,
+                useValue: {
+                    popover: () => ({ close: () => { } }),
+                },
+            },
+        ], usesInheritance: true, ngImport: i0, template: "<div class=\"ax-p-2 ax-size-full ax-flex ax-flex-col ax-gap-2\">\n  <ax-tabs\n    class=\"ax-bg-light-start ax-border-b ax-border-default ax-shrink-0\"\n    [fitParent]=\"true\"\n    location=\"bottom\"\n    (onActiveTabChanged)=\"handleTabChange($event)\"\n  >\n    <ax-tab-item [text]=\"('@notification-management:unread' | translate | async) ?? 'Unread'\" class=\"ax-font-medium\">\n      <ax-suffix>\n        @if (getNewMessageCount() > 0) {\n          <ax-badge color=\"primary\" [text]=\"getNewMessageCount().toString()\" size=\"sm\" class=\"ax-ml-1\"></ax-badge>\n        }\n      </ax-suffix>\n    </ax-tab-item>\n    <ax-tab-item\n      [text]=\"('@notification-management:all' | translate | async) ?? 'All'\"\n      class=\"ax-font-medium\"\n    ></ax-tab-item>\n  </ax-tabs>\n  <div class=\"ax-space-y-1 ax-overflow-auto\">\n    @for (item of notificationItems(); track item.id) {\n      <axp-master-notification-item\n        [data]=\"item\"\n        [showAvatar]=\"showAvatar()\"\n        [showDate]=\"showDate()\"\n        (onPressNotificationItem)=\"onAdminItemClick($event)\"\n        (onTogglePin)=\"onTogglePin($event)\"\n      />\n    } @empty {\n      <axp-state-message\n        icon=\"fa-light fa-bell-slash\"\n        [title]=\"'@notification-management:no-notifications.title'\"\n        [description]=\"'@notification-management:no-notifications.description'\"\n      >\n      </axp-state-message>\n    }\n  </div>\n</div>\n", styles: [":host{display:block;width:100%;height:100%}.notification-item{position:relative;margin-top:2px;margin-bottom:2px;display:flex;cursor:pointer;gap:1rem;border-radius:1rem;padding:.5rem;text-align:start;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.2s;background-color:rgb(var(--ax-sys-color-lightest-surface));color:rgb(var(--ax-sys-color-on-lightest-surface));border-color:rgb(var(--ax-sys-color-border-lightest-surface));animation-duration:.2s}.notification-item .notification-avatar{position:relative;height:3rem}.notification-item .notification-avatar .unread-badge{position:absolute;bottom:.25rem;inset-inline-end:.25rem;width:10px;height:10px;background:rgb(var(--ax-sys-color-primary-500));border:2px solid rgb(var(--ax-sys-color-surface));border-radius:50%}.notification-item .notification-content{min-width:0px;flex:1 1 0%}.notification-item .notification-content .notification-header{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.notification-item .notification-content .notification-header .notification-title{font-size:1rem;line-height:1.5rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.notification-item .notification-content .notification-header .notification-time{white-space:nowrap;font-size:.75rem;line-height:1rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .notification-content .notification-body{margin-top:.25rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;color:rgb(var(--ax-sys-color-on-surface-variant))}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXTabsModule }, { kind: "component", type: i2$1.AXTabsComponent, selector: "ax-tabs", inputs: ["look", "location", "fitParent", "minWidth", "content"], outputs: ["onActiveTabChanged"] }, { kind: "component", type: i2$1.AXTabItemComponent, selector: "ax-tab-item", inputs: ["disabled", "text", "key", "headerTemplate", "active"], outputs: ["disabledChange", "onClick", "onBlur", "onFocus", "activeChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i3$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: AXMAdminNotificationItemComponent, selector: "axp-master-notification-item", inputs: ["data", "showAvatar", "showDate", "selectionMode"], outputs: ["onPressNotificationItem", "onClosePopover", "onTogglePin"] }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "look"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPNotificationWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [
+                        CommonModule,
+                        AXTabsModule,
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXBadgeModule,
+                        AXTranslationModule,
+                        AXMAdminNotificationItemComponent,
+                        AXPStateMessageComponent,
+                    ], providers: [
+                        DatePipe,
+                        // Provide a lightweight stub for AXMAdminNotificationSlotComponent so the admin item can inject it
+                        {
+                            provide: AXMAdminNotificationSlotComponent,
+                            useValue: {
+                                popover: () => ({ close: () => { } }),
+                            },
+                        },
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"ax-p-2 ax-size-full ax-flex ax-flex-col ax-gap-2\">\n  <ax-tabs\n    class=\"ax-bg-light-start ax-border-b ax-border-default ax-shrink-0\"\n    [fitParent]=\"true\"\n    location=\"bottom\"\n    (onActiveTabChanged)=\"handleTabChange($event)\"\n  >\n    <ax-tab-item [text]=\"('@notification-management:unread' | translate | async) ?? 'Unread'\" class=\"ax-font-medium\">\n      <ax-suffix>\n        @if (getNewMessageCount() > 0) {\n          <ax-badge color=\"primary\" [text]=\"getNewMessageCount().toString()\" size=\"sm\" class=\"ax-ml-1\"></ax-badge>\n        }\n      </ax-suffix>\n    </ax-tab-item>\n    <ax-tab-item\n      [text]=\"('@notification-management:all' | translate | async) ?? 'All'\"\n      class=\"ax-font-medium\"\n    ></ax-tab-item>\n  </ax-tabs>\n  <div class=\"ax-space-y-1 ax-overflow-auto\">\n    @for (item of notificationItems(); track item.id) {\n      <axp-master-notification-item\n        [data]=\"item\"\n        [showAvatar]=\"showAvatar()\"\n        [showDate]=\"showDate()\"\n        (onPressNotificationItem)=\"onAdminItemClick($event)\"\n        (onTogglePin)=\"onTogglePin($event)\"\n      />\n    } @empty {\n      <axp-state-message\n        icon=\"fa-light fa-bell-slash\"\n        [title]=\"'@notification-management:no-notifications.title'\"\n        [description]=\"'@notification-management:no-notifications.description'\"\n      >\n      </axp-state-message>\n    }\n  </div>\n</div>\n", styles: [":host{display:block;width:100%;height:100%}.notification-item{position:relative;margin-top:2px;margin-bottom:2px;display:flex;cursor:pointer;gap:1rem;border-radius:1rem;padding:.5rem;text-align:start;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.2s;background-color:rgb(var(--ax-sys-color-lightest-surface));color:rgb(var(--ax-sys-color-on-lightest-surface));border-color:rgb(var(--ax-sys-color-border-lightest-surface));animation-duration:.2s}.notification-item .notification-avatar{position:relative;height:3rem}.notification-item .notification-avatar .unread-badge{position:absolute;bottom:.25rem;inset-inline-end:.25rem;width:10px;height:10px;background:rgb(var(--ax-sys-color-primary-500));border:2px solid rgb(var(--ax-sys-color-surface));border-radius:50%}.notification-item .notification-content{min-width:0px;flex:1 1 0%}.notification-item .notification-content .notification-header{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.notification-item .notification-content .notification-header .notification-title{font-size:1rem;line-height:1.5rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.notification-item .notification-content .notification-header .notification-time{white-space:nowrap;font-size:.75rem;line-height:1rem;color:rgb(var(--ax-sys-color-on-surface-variant))}.notification-item .notification-content .notification-body{margin-top:.25rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;color:rgb(var(--ax-sys-color-on-surface-variant))}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { notificationClick: [{ type: i0.Output, args: ["notificationClick"] }], markAsRead: [{ type: i0.Output, args: ["markAsRead"] }] } });
+
+var notificationWidget_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPNotificationWidgetViewComponent: AXPNotificationWidgetViewComponent
+});
+
+/**
+ * Configuration for the Notification Widget
+ */
+const AXPMyNotificationDashboardWidget = {
+    name: RootConfig.widgets.myNotificationDashboard,
+    title: '@dashboard:widgets.my-notification.widget-title',
+    categories: [AXP_WIDGETS_UTILITY_CATEGORY],
+    groups: [AXPWidgetGroupEnum.DashboardWidget],
+    type: 'dashboard',
+    description: '@dashboard:widgets.my-notification.widget-description',
+    icon: 'fa-regular fa-bell',
+    properties: [
+        cloneProperty(AXP_DATA_PATH_PROPERTY, { visible: false }),
+        // ====== Title ======
+        {
+            name: 'title',
+            title: '@notification-management:widgets.my-notification-dashboard.chart-title',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: '',
+                dataType: 'string',
+                interface: {
+                    name: 'title',
+                    path: 'options.title',
+                    type: AXPWidgetsCatalog.text,
+                    options: {
+                        placeholder: '@dashboard:widgets.my-notification.title-placeholder',
+                    },
+                },
+            },
+            visible: true,
+        },
+        {
+            name: 'maxItems',
+            title: '@notification-management:widgets.my-notification-dashboard.max-items',
+            description: 'Maximum number of notification items to display',
+            group: AXP_STYLING_PROPERTY_GROUP,
+            schema: {
+                defaultValue: 10,
+                dataType: 'number',
+                interface: {
+                    name: 'maxItems',
+                    path: 'options.maxItems',
+                    type: AXPWidgetsCatalog.number,
+                    options: {
+                        minValue: 1,
+                        maxValue: 100,
+                    },
+                },
+            },
+            visible: true,
+        },
+        {
+            name: 'showAvatar',
+            title: '@notification-management:widgets.my-notification-dashboard.show-avatar',
+            description: 'Whether to show avatars in notifications',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: true,
+                dataType: 'boolean',
+                interface: {
+                    name: 'showAvatar',
+                    path: 'options.showAvatar',
+                    type: AXPWidgetsCatalog.toggle,
+                },
+            },
+            visible: true,
+        },
+        {
+            name: 'showDate',
+            title: '@notification-management:widgets.my-notification-dashboard.show-date',
+            description: 'Whether to show date in notifications',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: true,
+                dataType: 'boolean',
+                interface: {
+                    name: 'showDate',
+                    path: 'options.showDate',
+                    type: AXPWidgetsCatalog.toggle,
+                },
+            },
+            visible: true,
+        },
+        {
+            name: 'autoRefresh',
+            title: '@notification-management:widgets.my-notification-dashboard.auto-refresh',
+            description: 'Automatically refresh notifications at regular intervals',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: true,
+                dataType: 'boolean',
+                interface: {
+                    name: 'autoRefresh',
+                    path: 'options.autoRefresh',
+                    type: AXPWidgetsCatalog.toggle,
+                },
+            },
+            visible: true,
+        },
+        {
+            name: 'refreshInterval',
+            title: '@notification-management:widgets.my-notification-dashboard.refresh-interval',
+            description: 'Interval in seconds between automatic refreshes',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: 60,
+                dataType: 'number',
+                interface: {
+                    name: 'refreshInterval',
+                    path: 'options.refreshInterval',
+                    type: AXPWidgetsCatalog.number,
+                    options: {
+                        minValue: 10,
+                        maxValue: 3600,
+                    },
+                },
+            },
+            visible: true,
+        },
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return notificationWidget_component; }).then((c) => c.AXPNotificationWidgetViewComponent),
+        },
+    },
+    meta: {
+        dimensions: {
+            lg: {
+                width: 3,
+                height: 5,
+                minWidth: 2,
+                minHeight: 4,
+                maxWidth: 4,
+                maxHeight: 7,
+            },
+            md: {
+                width: 3,
+                height: 5,
+                minWidth: 2,
+                minHeight: 4,
+                maxWidth: 4,
+                maxHeight: 7,
+            },
+            sm: {
+                height: 5,
+                minHeight: 4,
+                maxHeight: 7,
+            },
+        },
+    },
+};
+
+//#endregion
+//#region ----   Notification Management Widgets Provider   ----
+class AXMNotificationManagementWidgetsProvider {
+    getWidgets() {
+        return [AXPMyNotificationDashboardWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Command keys ----
+const NOTIFICATION_MANAGEMENT_EMAIL_SHOW_DIALOG_COMMAND_KEY = 'NotificationManagement:Email:ShowDialog';
+const NOTIFICATION_MANAGEMENT_EMAIL_SEND_COMMAND_KEY = 'NotificationManagement:Email:Send';
+//#endregion
+
+//#region ---- Types ----
+//#endregion
+
+//#endregion
+//#region ---- Helpers ----
+function normalizeTextTemplateId(value) {
+    if (typeof value === 'string') {
+        const t = value.trim();
+        return t || undefined;
+    }
+    if (value != null && typeof value === 'object' && 'id' in value) {
+        const id = value.id;
+        if (typeof id === 'string' && id.trim())
+            return id.trim();
+    }
+    return undefined;
+}
+function parseMergeRecord(value) {
+    if (value == null)
+        return {};
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = v == null ? '' : String(v);
+        }
+        return out;
+    }
+    return {};
+}
+/**
+ * True when HTML/plain body has no user-visible text (handles empty `<p><br></p>` etc.).
+ */
+function isEffectivelyEmptyRichTextBody(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return true;
+    }
+    const withoutTags = trimmed
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return withoutTags.length === 0;
+}
+/** Resolved entity module for the text-template data selector. */
+const TEXT_TEMPLATE_ENTITY_MODULE = 'ContentManagement';
+/** Resolved entity name for the text-template data selector. */
+const TEXT_TEMPLATE_ENTITY_NAME = 'TextTemplate';
+/** List filter: only templates with a non-empty `channels.email.body` (excludes SMS-only rows). */
+const TEXT_TEMPLATE_LIST_EMAIL_BODY_FILTER = {
+    field: 'channels.email.body',
+    operator: { type: 'isNotEmpty' },
+};
+//#endregion
+//#region ---- Service ----
+/**
+ * Opens the send-email dialog built with the layout dialog builder and delegates send to
+ * {@link NOTIFICATION_MANAGEMENT_EMAIL_SEND_COMMAND_KEY}.
+ */
+class AXMNotificationEmailComposerService {
+    constructor() {
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+        this.commandService = inject(AXPCommandService);
+        this.entityDataSelector = inject(AXPEntityDataSelectorService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+    }
+    /**
+     * Shows the compose dialog; on submit runs the send command with the dialog context.
+     * When {@link NotificationManagementEmailShowDialogInput.textTemplateId} is not set, the standard
+     * entity data selector ({@link AXPEntityDataSelectorService}) runs first; the compose dialog has no template field.
+     */
+    async openSendEmailDialog(input) {
+        const merge = parseMergeRecord(input.merge);
+        let textTemplateId = input.textTemplateId?.trim() ?? '';
+        if (!textTemplateId) {
+            const picked = await this.openTextTemplatePickerDialog();
+            if (picked === null) {
+                return { success: false, data: null };
+            }
+            textTemplateId = picked;
+        }
+        let subject = input.subject ?? '';
+        let body = input.body ?? '';
+        if (textTemplateId) {
+            const rendered = await this.commandService.execute(AXC_TEXT_TEMPLATE_RENDER_COMMAND_KEY, {
+                textTemplateId,
+                channel: 'email',
+                merge,
+                locale: this.translationService.getActiveLang() ?? 'en-US',
+            });
+            if (rendered?.success && rendered.data) {
+                subject = rendered.data.subject ?? subject;
+                body = rendered.data.body ?? body;
+            }
+        }
+        const defaultTitle = await this.translationService.translateAsync('@notification-management:email.dialog.title');
+        const title = input.dialogTitle?.trim()
+            ? await this.translationService.translateAsync(input.dialogTitle)
+            : defaultTitle;
+        try {
+            const result = await this.layoutBuilder
+                .create()
+                .dialog((dialog) => {
+                dialog
+                    .setTitle(title)
+                    .setSize('lg')
+                    .setCloseButton(true)
+                    .setContext({
+                    to: input.to ?? '',
+                    cc: input.cc ?? '',
+                    bcc: input.bcc ?? '',
+                    subject,
+                    body,
+                    textTemplateId,
+                })
+                    .content((flex) => {
+                    flex
+                        .setDirection('column')
+                        .setGap('16px')
+                        .formField('@notification-management:email.dialog.fields.to.title', (field) => {
+                        field.path('to');
+                        field.textBox({
+                            validations: [{ rule: 'required' }],
+                            placeholder: '@notification-management:email.dialog.fields.to.placeholder',
+                        });
+                    })
+                        .formField('@notification-management:email.dialog.fields.cc.title', (field) => {
+                        field.path('cc');
+                        field.textBox({
+                            placeholder: '@notification-management:email.dialog.fields.cc.placeholder',
+                        });
+                    })
+                        .formField('@notification-management:email.dialog.fields.bcc.title', (field) => {
+                        field.path('bcc');
+                        field.textBox({
+                            placeholder: '@notification-management:email.dialog.fields.bcc.placeholder',
+                        });
+                    })
+                        .formField('@notification-management:email.dialog.fields.subject.title', (field) => {
+                        field.path('subject');
+                        field.textBox({
+                            validations: [{ rule: 'required' }],
+                            placeholder: '@notification-management:email.dialog.fields.subject.placeholder',
+                        });
+                    })
+                        .formField('@notification-management:email.dialog.fields.body.title', (field) => {
+                        field.path('body');
+                        field.richText({
+                            validations: [{ rule: 'required' }],
+                            placeholder: '@notification-management:email.dialog.fields.body.placeholder',
+                        });
+                    });
+                })
+                    .setActions((actions) => {
+                    actions.cancel('@general:actions.cancel.title').submit('@general:actions.send.title');
+                })
+                    .onAction(async (dialogRef) => {
+                    const context = dialogRef.context();
+                    const action = dialogRef.action();
+                    if (!context || action === 'cancel') {
+                        return { success: false, data: null };
+                    }
+                    const to = String(context['to'] ?? '').trim();
+                    const subjectOut = String(context['subject'] ?? '').trim();
+                    const bodyOut = String(context['body'] ?? '');
+                    if (!to || !subjectOut || isEffectivelyEmptyRichTextBody(bodyOut)) {
+                        return {
+                            success: false,
+                            message: {
+                                text: await this.translationService.translateAsync('@notification-management:email.dialog.messages.required-fields'),
+                            },
+                            data: null,
+                        };
+                    }
+                    const sendInput = {
+                        to,
+                        cc: String(context['cc'] ?? '').trim() || undefined,
+                        bcc: String(context['bcc'] ?? '').trim() || undefined,
+                        subject: subjectOut,
+                        body: bodyOut.trim(),
+                        textTemplateId: normalizeTextTemplateId(context['textTemplateId']),
+                    };
+                    const sendResult = await this.commandService.execute(NOTIFICATION_MANAGEMENT_EMAIL_SEND_COMMAND_KEY, sendInput);
+                    return (sendResult ?? {
+                        success: false,
+                        message: { text: 'Send command did not return a result.' },
+                        data: null,
+                    });
+                });
+            })
+                .show();
+            return result;
+        }
+        catch (e) {
+            return {
+                success: false,
+                message: {
+                    text: e instanceof Error ? e.message : 'Failed to open send email dialog.',
+                },
+                data: null,
+            };
+        }
+    }
+    /**
+     * Opens {@link AXPEntityDataSelectorService} for `ContentManagement.TextTemplate`. Returns `null` if
+     * the selector is dismissed without applying, `''` if the user applies with no row selected (compose
+     * without a template), or the selected template id.
+     */
+    async openTextTemplatePickerDialog() {
+        const entity = await this.entityRegistry.resolve(TEXT_TEMPLATE_ENTITY_MODULE, TEXT_TEMPLATE_ENTITY_NAME);
+        if (!entity) {
+            return null;
+        }
+        const title = await this.translationService.translateAsync('@notification-management:email.template-picker.title');
+        try {
+            const result = await this.entityDataSelector.open({
+                entity,
+                title,
+                allowMultiple: false,
+                allowCreate: 'none',
+                filters: TEXT_TEMPLATE_LIST_EMAIL_BODY_FILTER,
+                columns: ['title', 'name'],
+                searchFields: ['title', 'name'],
+            });
+            if (result == null) {
+                return null;
+            }
+            const items = result.items ?? [];
+            if (items.length === 0) {
+                return '';
+            }
+            const rawId = items[0]['id'];
+            if (rawId != null && String(rawId).trim() !== '') {
+                return String(rawId).trim();
+            }
+            return '';
+        }
+        catch {
+            return null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEmailComposerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEmailComposerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationEmailComposerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#endregion
+//#region ---- Command ----
+class NotificationManagementEmailShowDialogCommand {
+    constructor() {
+        this.composer = inject(AXMNotificationEmailComposerService);
+    }
+    async execute(input) {
+        const raw = input;
+        const { __context__: _workflowContext, ...rest } = raw;
+        const contextOptions = _workflowContext?.options;
+        const evaluated = {
+            ...(contextOptions ?? {}),
+            ...rest,
+        };
+        return this.composer.openSendEmailDialog(evaluated);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NotificationManagementEmailShowDialogCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NotificationManagementEmailShowDialogCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NotificationManagementEmailShowDialogCommand, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var showEmailDialog_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    NotificationManagementEmailShowDialogCommand: NotificationManagementEmailShowDialogCommand
+});
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Service ----
+class AXMInAppNotificationService {
+    constructor() {
+        this.notificationService = inject(AXMNotificationEntityService);
+    }
+    async create(request) {
+        await this.notificationService.create({
+            id: request.id,
+            title: request.title,
+            body: request.body,
+            type: 'Log',
+            channel: 'InApp',
+            content: {
+                content: request.body,
+                contentType: 'text',
+            },
+            sender: {
+                id: 'system',
+                type: 'user',
+                fullName: 'System',
+            },
+            receiver: request.receiver,
+            template: {
+                category: 'Inbox',
+                prority: request.priority,
+                icon: request.icon,
+                isPinned: false,
+            },
+            readAt: null,
+            createAt: new Date(),
+            entityName: 'notifications',
+            data: request.data,
+            name: request.name,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMInAppNotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMInAppNotificationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMInAppNotificationService, decorators: [{
+            type: Injectable
+        }] });
+//#endregion
+//#region ---- Provider ----
+const AXM_IN_APP_NOTIFICATION_SERVICE_PROVIDER = {
+    provide: AXP_IN_APP_NOTIFICATION_SERVICE,
+    useClass: AXMInAppNotificationService,
+};
+
+function routesFactory() {
+    const routes = [
+        {
+            path: ':app/notifications',
+            canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+            loadComponent: () => {
+                return AXPRootLayoutComponent;
+            },
+            title: 'Notifications',
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-modules-notification-management-notification-page.component-ATFOFL7C.mjs').then((c) => c.AXMNotificationPageComponent),
+                    data: { reuse: true },
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMNotificationManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementModule, imports: [i1$2.AXPComponentSlotModule, AXPWidgetCoreModule,
+            // Entity Modules
+            AXMNotificationEntityModule,
+            AXMNotificationTemplateEntityModule,
+            AXMNotificationChannelEntityModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementModule, providers: [
+            AXM_IN_APP_NOTIFICATION_SERVICE_PROVIDER,
+            // Module-specific providers (not part of manifest system)
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFactory,
+            },
+            {
+                provide: AXP_TASK_BADGE_PROVIDERS,
+                useClass: AXMNotificationBadgeProvider,
+                multi: true,
+            },
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: NotificationManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityLoader,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMNotificationManagementWidgetsProvider,
+                multi: true,
+            },
+            provideCommandSetups([
+                {
+                    key: NOTIFICATION_MANAGEMENT_EMAIL_SHOW_DIALOG_COMMAND_KEY,
+                    command: () => Promise.resolve().then(function () { return showEmailDialog_command; }).then((m) => m.NotificationManagementEmailShowDialogCommand),
+                },
+            ]),
+        ], imports: [AXPComponentSlotModule.forChild({
+                'root-header-end': [
+                    {
+                        name: 'notification',
+                        component: AXMAdminNotificationSlotComponent,
+                    },
+                ],
+            }),
+            AXPWidgetCoreModule,
+            // Entity Modules
+            AXMNotificationEntityModule,
+            AXMNotificationTemplateEntityModule,
+            AXMNotificationChannelEntityModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMNotificationManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                            'root-header-end': [
+                                {
+                                    name: 'notification',
+                                    component: AXMAdminNotificationSlotComponent,
+                                },
+                            ],
+                        }),
+                        AXPWidgetCoreModule,
+                        // Entity Modules
+                        AXMNotificationEntityModule,
+                        AXMNotificationTemplateEntityModule,
+                        AXMNotificationChannelEntityModule,
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        AXM_IN_APP_NOTIFICATION_SERVICE_PROVIDER,
+                        // Module-specific providers (not part of manifest system)
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFactory,
+                        },
+                        {
+                            provide: AXP_TASK_BADGE_PROVIDERS,
+                            useClass: AXMNotificationBadgeProvider,
+                            multi: true,
+                        },
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: NotificationManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityLoader,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMNotificationManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: NOTIFICATION_MANAGEMENT_EMAIL_SHOW_DIALOG_COMMAND_KEY,
+                                command: () => Promise.resolve().then(function () { return showEmailDialog_command; }).then((m) => m.NotificationManagementEmailShowDialogCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+var AXPSettingKeys;
+(function (AXPSettingKeys) {
+    // Email Settings
+    AXPSettingKeys["Server"] = "NotificationManagement:Setting:Email.Server";
+    AXPSettingKeys["Port"] = "NotificationManagement:Setting:Email.Port";
+    AXPSettingKeys["Username"] = "NotificationManagement:Setting:Email.Username";
+    AXPSettingKeys["Password"] = "NotificationManagement:Setting:Email.Password";
+    AXPSettingKeys["FromAddress"] = "NotificationManagement:Setting:Email.FromAddress";
+    AXPSettingKeys["UseSSL"] = "NotificationManagement:Setting:Email.UseSSL";
+    AXPSettingKeys["UseTLS"] = "NotificationManagement:Setting:Email.UseTLS";
+    // Telegram Settings
+    AXPSettingKeys["TelegramToken"] = "NotificationManagement:Setting:Telegram.Token";
+    AXPSettingKeys["TelegramChatId"] = "NotificationManagement:Setting:Telegram.ChatId";
+    // WhatsApp Settings
+    AXPSettingKeys["WhatsAppApiUrl"] = "NotificationManagement:Setting:WhatsApp.ApiUrl";
+    AXPSettingKeys["WhatsAppAuthToken"] = "NotificationManagement:Setting:WhatsApp.AuthToken";
+    // Firebase Settings
+    AXPSettingKeys["FirebaseApiKey"] = "NotificationManagement:Setting:Firebase.ApiKey";
+    AXPSettingKeys["FirebaseProjectId"] = "NotificationManagement:Setting:Firebase.ProjectId";
+    AXPSettingKeys["FirebaseSenderId"] = "NotificationManagement:Setting:Firebase.SenderId";
+    AXPSettingKeys["FirebaseAppId"] = "NotificationManagement:Setting:Firebase.AppId";
+})(AXPSettingKeys || (AXPSettingKeys = {}));
+
+const I18N = '@notification-management:settings.notification-settings';
+class AXMSettingProvider {
+    async provide(context) {
+        context
+            // Add Notification Settings Group
+            .addGroup('notification-settings', `${I18N}.nav-title`, `${I18N}.description`, RootConfig$1.module.icon, `${I18N}.title`, 95)
+            // SMTP Settings Section
+            .addSection('smtp-settings', `${I18N}.smtp.title`, `${I18N}.smtp.description`)
+            .addSetting({
+            key: AXPSettingKeys.Server,
+            title: `${I18N}.smtp.server.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.smtp.server.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.Port,
+            title: `${I18N}.smtp.port.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: 587,
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: {
+                    minValue: 1,
+                    maxValue: 65535,
+                },
+            },
+            description: `${I18N}.smtp.port.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.Username,
+            title: `${I18N}.smtp.username.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.smtp.username.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.Password,
+            title: `${I18N}.smtp.password.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.PasswordBox,
+            },
+            description: `${I18N}.smtp.password.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.UseSSL,
+            title: `${I18N}.smtp.ssl.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: false,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+            },
+            description: `${I18N}.smtp.ssl.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.UseTLS,
+            title: `${I18N}.smtp.tls.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: true,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+            },
+            description: `${I18N}.smtp.tls.description`,
+        })
+            .endSection()
+            // Telegram Settings Section
+            .addSection('telegram-settings', `${I18N}.telegram.title`, `${I18N}.telegram.description`)
+            .addSetting({
+            key: AXPSettingKeys.TelegramToken,
+            title: `${I18N}.telegram.token.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.telegram.token.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.TelegramChatId,
+            title: `${I18N}.telegram.chat-id.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.telegram.chat-id.description`,
+        })
+            .endSection()
+            // WhatsApp Settings Section
+            .addSection('whatsapp-settings', `${I18N}.whatsapp.title`, `${I18N}.whatsapp.description`)
+            .addSetting({
+            key: AXPSettingKeys.WhatsAppApiUrl,
+            title: `${I18N}.whatsapp.api-url.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.whatsapp.api-url.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.WhatsAppAuthToken,
+            title: `${I18N}.whatsapp.auth-token.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.PasswordBox,
+            },
+            description: `${I18N}.whatsapp.auth-token.description`,
+        })
+            .endSection()
+            // Firebase Settings Section
+            .addSection('firebase-settings', `${I18N}.firebase.title`, `${I18N}.firebase.description`)
+            .addSetting({
+            key: AXPSettingKeys.FirebaseApiKey,
+            title: `${I18N}.firebase.api-key.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.firebase.api-key.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.FirebaseProjectId,
+            title: `${I18N}.firebase.project-id.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.firebase.project-id.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.FirebaseSenderId,
+            title: `${I18N}.firebase.sender-id.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.firebase.sender-id.description`,
+        })
+            .addSetting({
+            key: AXPSettingKeys.FirebaseAppId,
+            title: `${I18N}.firebase.app-id.title`,
+            scope: 'T',
+            isInherited: true,
+            defaultValue: '',
+            widget: {
+                type: AXPWidgetsList.Editors.TextBox,
+            },
+            description: `${I18N}.firebase.app-id.description`,
+        })
+            .endSection()
+            // End Notification Settings Group
+            .endGroup();
+    }
+}
+
+async function myNotificationEntityFactory(injector) {
+    const storageService = injector.get(AXPEntityStorageService);
+    const dataProvider = new AXPEntityDataProviderImpl(storageService, 'notifications');
+    const moduleName = 'notification-management';
+    const scope = `#${moduleName}`;
+    const entityDef = {
+        module: moduleName,
+        name: 'notification',
+        title: '@notification-management:my',
+        formats: {
+            individual: '@notification-management:my',
+            plural: '@notification-management:my',
+        },
+        groups: [
+            { id: 'data', title: 'Data' },
+            { id: 'content', title: 'Content' },
+            { id: 'action', title: 'Action' },
+            { id: 'user', title: 'User' },
+            { id: 'template', title: 'Template' },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    visible: false,
+                    nullable: false,
+                    readonly: true,
+                    unique: { enabled: true },
+                },
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'body',
+                title: '@general:terms.body',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                    },
+                },
+            },
+            {
+                name: 'channel',
+                title: '@notification-management:channel',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['InApp', 'Email', 'SMS'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'content.type',
+                title: '@notification-management:content.type',
+                groupId: 'content',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+            {
+                name: 'action.type',
+                title: '@general:terms.workflow.action.type',
+                groupId: 'action',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Link', 'Entity', 'Popup'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'User.name',
+                title: '@general:terms.people.user',
+                groupId: 'user',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'template.category',
+                title: '@notification-management:template.category',
+                groupId: 'template',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Inbox', 'Archive'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'template.prority',
+                title: '@notification-management:template.priority',
+                groupId: 'template',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Warning', 'Danger', 'Notice'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'template.isPinned',
+                title: '@notification-management:template.isPinned',
+                groupId: 'template',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                        options: {
+                            label: 'Is Pinned',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'readAt',
+                title: '@notification-management:readAt',
+                groupId: 'data',
+                schema: {
+                    dataType: 'datetime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { format: 'date' },
+                    },
+                },
+            },
+            {
+                name: 'createAt',
+                title: '@notification-management:createAt',
+                groupId: 'data',
+                schema: {
+                    dataType: 'datetime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { format: 'date' },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'title' },
+            { name: 'body' },
+            { name: 'channel' },
+            { name: 'user.name' },
+            { name: 'template.category' },
+            { name: 'template.prority' },
+            { name: 'createAt' },
+            { name: 'readAt' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
+                    await dataProvider.insertOne(entity);
+                    return entity;
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await dataProvider.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    await dataProvider.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataProvider.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const list = await dataProvider.getAll();
+                    return {
+                        total: list.length,
+                        items: list.slice(e.skip, e.skip + e.take),
+                    };
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                list: {
+                    actions: [
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                    ],
+                    views: [{ name: 'all', title: 'All Notifications', fixed: true, columns: [], conditions: [], sorts: [] }],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var myNotification = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    myNotificationEntityFactory: myNotificationEntityFactory
+});
+
+async function notificationLogEntityFactory(injector) {
+    const dataService = injector.get(AXMNotificationManagementChannelEntityService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: 'notification-management',
+        name: 'notification',
+        title: 'Notification',
+        formats: {
+            individual: 'NotificationLog',
+            plural: 'NotificationLogs',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'notification',
+                title: 'Notification',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: `t("name", { scope: "${i18n}" })`,
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'title',
+                title: `t("title", { scope: "${i18n}" })`,
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'status',
+                title: `t("status", { scope: "${i18n}" })`,
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query(e);
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'notification',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'user.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: '@general:actions.detail.title',
+                            command: 'open-entity',
+                            priority: 'primary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: '@general:terms.interface.selection.all-items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMNotificationConnectorService as A, compareNotificationsByPinnedThenDate as B, myNotificationEntityFactory as C, notificationChannelEntityFactory as D, notificationEntityFactory as E, notificationLogEntityFactory as F, notificationTemplateEntityFactory as G, sortNotificationsByPinnedThenDate as H, NOTIFICATION_LIST_SORT as N, RootConfig as R, AXMAdminNotificationItemComponent as a, AXMMenuProvider as b, AXMNotificationChannelEntityModule as c, AXMNotificationEmailComposerService as d, AXMNotificationEntityModule as e, AXMNotificationEntityService as f, AXMNotificationEntityServiceImpl as g, AXMNotificationManagementChannelEntityService as h, AXMNotificationManagementChannelEntityServiceImpl as i, AXMNotificationManagementModule as j, AXMNotificationManagementTemplateEntityService as k, AXMNotificationManagementTemplateEntityServiceImpl as l, AXMNotificationRealtimeService as m, AXMNotificationTemplateEntityModule as n, AXMOsNotificationService as o, AXMSettingProvider as p, AXPMyNotificationDashboardWidget as q, AXPNotificationDefinitionProvider as r, AXPNotificationDefinitionProviderDefault as s, AXPNotificationDefinitionService as t, AXPNotificationWidgetViewComponent as u, AXP_NOTIFICATION_DEFINITION_PROVIDER as v, NOTIFICATION_MANAGEMENT_EMAIL_SEND_COMMAND_KEY as w, NOTIFICATION_MANAGEMENT_EMAIL_SHOW_DIALOG_COMMAND_KEY as x, NotificationManagementEmailShowDialogCommand as y, buildNotificationPageQuery as z };
+//# sourceMappingURL=acorex-modules-notification-management-acorex-modules-notification-management-BSf1wd6j.mjs.map