@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

package/fesm2022/mediusinc-mng-commons-core.mjs

@@ -0,0 +1,3882 @@
+import * as i0 from '@angular/core';
+import { inject, Directive, computed, signal, Component, ChangeDetectionStrategy, InjectionToken, Injectable, Injector, ElementRef, ApplicationRef, ViewContainerRef, EventEmitter, createComponent, Input, Output, TemplateRef, booleanAttribute, numberAttribute, Pipe, APP_INITIALIZER, ErrorHandler } from '@angular/core';
+import * as i3$1 from '@ngx-translate/core';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import * as i3 from 'primeng/confirmdialog';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import * as i5 from 'primeng/dialog';
+import { Dialog, DialogModule } from 'primeng/dialog';
+import * as i1 from 'primeng/toast';
+import { ToastModule } from 'primeng/toast';
+import { DialogService, DynamicDialogComponent } from 'primeng/dynamicdialog';
+import * as i2 from 'primeng/api';
+import { PrimeNGConfig, FilterService, MessageService, ConfirmationService } from 'primeng/api';
+import * as i1$1 from '@angular/router';
+import { Router, NavigationEnd, RouterLink, NavigationStart, RouteConfigLoadStart, RouteConfigLoadEnd, NavigationCancel, NavigationError } from '@angular/router';
+import * as i2$1 from 'primeng/button';
+import { ButtonModule } from 'primeng/button';
+import { Title } from '@angular/platform-browser';
+import { BehaviorSubject, ReplaySubject, distinctUntilChanged, isObservable, of, mergeMap, combineLatest, Observable, tap, Subject, take, throwError } from 'rxjs';
+import { filter, map, first, catchError } from 'rxjs/operators';
+import { DatePipe } from '@angular/common';
+import { HttpErrorResponse, HttpClient, HttpBackend } from '@angular/common/http';
+import 'reflect-metadata';
+
+class DialogKeydownHandlerDirective {
+    constructor() {
+        this.dialogService = inject(DialogService);
+        this.dynamicDialog = inject(DynamicDialogComponent, { optional: true });
+        this.dialog = inject(Dialog, { optional: true });
+        this.dialogsWithKeydownListener = [];
+    }
+    ngOnInit() {
+        if (!this.dialog && !this.dynamicDialog) {
+            // not a dialog, return
+            return;
+        }
+        this.dialogService.dialogComponentRefMap.forEach(v => {
+            if ((this.dialog || v.instance !== this.dynamicDialog) && v.instance.documentKeydownListener) {
+                // exclude self dynamic dialog
+                this.dialogsWithKeydownListener.push(v.instance);
+                v.instance.unbindDocumentKeydownListener();
+            }
+        });
+        if (!this.dialog) {
+            // if dialog is present, then do not bind (because it will bind on unbind-ed dynamic dialog
+            this.dynamicDialog?.bindDocumentKeydownListener();
+        }
+    }
+    ngOnDestroy() {
+        if (!this.dialog && !this.dynamicDialog) {
+            // not a dialog, return
+            return;
+        }
+        if (!this.dialog) {
+            this.dynamicDialog?.unbindDocumentKeydownListener();
+        }
+        this.dialogsWithKeydownListener.forEach(c => c.bindDocumentKeydownListener());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: DialogKeydownHandlerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.2", type: DialogKeydownHandlerDirective, isStandalone: true, selector: "[mngDialogKeydownHandler]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: DialogKeydownHandlerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[mngDialogKeydownHandler]'
+                }]
+        }] });
+
+class NotificationWrapperComponent {
+    constructor() {
+        this.notificationCutoff = 70;
+        this.isDialogNotificationVisible = computed(() => this.dialogNotification() !== null);
+        this.dialogNotification = signal(null);
+    }
+    getNotificationIconClass(message) {
+        if (message?.icon)
+            return message.icon;
+        switch (message?.severity) {
+            case 'info':
+                return 'pi-info-circle';
+            case 'warning':
+                return 'pi-exclamation-triangle';
+            case 'error':
+                return 'pi-times-circle';
+            case 'success':
+                return 'pi-check';
+            default:
+                return '';
+        }
+    }
+    onShowNotificationInDialog(message) {
+        this.dialogNotification.set(message);
+    }
+    onDialogNotificationVisibilityChange(visible) {
+        if (!visible) {
+            this.dialogNotification.set(null);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotificationWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.2", type: NotificationWrapperComponent, isStandalone: true, selector: "mng-notification-wrapper", ngImport: i0, template: "<ng-content></ng-content>\n<p-confirmDialog appendTo=\"body\" [baseZIndex]=\"50\"></p-confirmDialog>\n\n<p-toast [baseZIndex]=\"50\">\n    <ng-template let-message pTemplate=\"message\">\n        <span [class]=\"'p-toast-message-icon pi ' + getNotificationIconClass(message)\"></span>\n        <div class=\"p-toast-message-text\">\n            <div class=\"p-toast-summary\">{{ message.summary }}</div>\n            <div class=\"p-toast-detail\">{{ message.detail.slice(0, notificationCutoff) + (message.detail.length > notificationCutoff ? '...' : '') }}</div>\n            @if (message.detail.length > notificationCutoff) {\n                <div (click)=\"onShowNotificationInDialog(message)\" class=\"p-link font-semibold text-sm mt-2 flex align-items-center\">\n                    <i class=\"pi pi-chevron-down mr-1\"></i>{{ 'notification.details' | translate }}\n                </div>\n            }\n        </div>\n    </ng-template>\n</p-toast>\n\n<p-dialog\n    [visible]=\"isDialogNotificationVisible()\"\n    (visibleChange)=\"onDialogNotificationVisibilityChange($event)\"\n    [styleClass]=\"'p-fluid mng-dialog mng-dialog-xs ' + 'mng-message-detail-dialog mng-message-detail-dialog-' + (dialogNotification()?.severity ?? '')\">\n    <ng-template pTemplate=\"header\" mngDialogKeydownHandler>\n        <span class=\"p-dialog-title font-bold mng-dialog-success\">\n            <span [class]=\"'mr-2 pi ' + getNotificationIconClass(dialogNotification())\"></span>\n            {{ dialogNotification()?.summary ?? '' }}\n        </span>\n    </ng-template>\n    <div>\n        {{ dialogNotification()?.detail ?? '' }}\n    </div>\n</p-dialog>\n", dependencies: [{ kind: "ngmodule", type: ToastModule }, { kind: "component", type: i1.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "life", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ConfirmDialogModule }, { kind: "component", type: i3.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "closeAriaLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3$1.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i5.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "directive", type: DialogKeydownHandlerDirective, selector: "[mngDialogKeydownHandler]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotificationWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mng-notification-wrapper', standalone: true, imports: [ToastModule, ConfirmDialogModule, TranslateModule, DialogModule, DialogKeydownHandlerDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n<p-confirmDialog appendTo=\"body\" [baseZIndex]=\"50\"></p-confirmDialog>\n\n<p-toast [baseZIndex]=\"50\">\n    <ng-template let-message pTemplate=\"message\">\n        <span [class]=\"'p-toast-message-icon pi ' + getNotificationIconClass(message)\"></span>\n        <div class=\"p-toast-message-text\">\n            <div class=\"p-toast-summary\">{{ message.summary }}</div>\n            <div class=\"p-toast-detail\">{{ message.detail.slice(0, notificationCutoff) + (message.detail.length > notificationCutoff ? '...' : '') }}</div>\n            @if (message.detail.length > notificationCutoff) {\n                <div (click)=\"onShowNotificationInDialog(message)\" class=\"p-link font-semibold text-sm mt-2 flex align-items-center\">\n                    <i class=\"pi pi-chevron-down mr-1\"></i>{{ 'notification.details' | translate }}\n                </div>\n            }\n        </div>\n    </ng-template>\n</p-toast>\n\n<p-dialog\n    [visible]=\"isDialogNotificationVisible()\"\n    (visibleChange)=\"onDialogNotificationVisibilityChange($event)\"\n    [styleClass]=\"'p-fluid mng-dialog mng-dialog-xs ' + 'mng-message-detail-dialog mng-message-detail-dialog-' + (dialogNotification()?.severity ?? '')\">\n    <ng-template pTemplate=\"header\" mngDialogKeydownHandler>\n        <span class=\"p-dialog-title font-bold mng-dialog-success\">\n            <span [class]=\"'mr-2 pi ' + getNotificationIconClass(dialogNotification())\"></span>\n            {{ dialogNotification()?.summary ?? '' }}\n        </span>\n    </ng-template>\n    <div>\n        {{ dialogNotification()?.detail ?? '' }}\n    </div>\n</p-dialog>\n" }]
+        }] });
+
+class ACommonsErrorBase extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = options?.name ?? 'MngError';
+        this.messageCode = options?.messageCode;
+        this.location = options?.location ?? window?.location?.href;
+        this.cause = options?.cause;
+        this.stack = options?.stack ?? (options?.cause ? options.cause.stack : new Error(message).stack);
+        this.details = options?.details;
+    }
+}
+class CommonsInternalError extends ACommonsErrorBase {
+    constructor(message, options) {
+        super(message, {
+            name: 'CommonsInternalError',
+            ...options
+        });
+        this.type = 'CommonsInternalError';
+    }
+}
+class CommonsHttpError extends ACommonsErrorBase {
+    constructor(message, httpError, options) {
+        super(message, {
+            name: 'CommonsHttpError_' + httpError.url,
+            cause: httpError,
+            ...options
+        });
+        this.type = 'CommonsHttpError';
+        this.httpError = httpError;
+    }
+}
+
+const ngPrimerFormatSupported = [/d{1,2}/g, /E{1,5}/g, /c{1,5}/g, /M{1,5}/g, /L{1,5}/g, /y{1,4}/g, /Y{1,4}/g];
+const ngPrimeFormatOther = [/G{1,5}/g, /w{1,2}/g, /W/g, /a{1,5}/g, /B{1,5}/g, /b{1,5}/g, /h{1,2}/g, /H{1,2}/g, /m{1,2}/g, /s{1,2}/g, /S{1,3}/g, /z{1,4}/g, /Z{1,5}/g, /O{1,4}/g];
+const ngPrimerFormatMap = {
+    // days
+    d: 'd',
+    dd: 'dd',
+    E: 'D',
+    EE: 'D',
+    EEE: 'D',
+    EEEE: 'DD',
+    EEEEE: 'D',
+    EEEEEE: 'D',
+    c: 'd',
+    cc: 'dd',
+    ccc: 'D',
+    cccc: 'DD',
+    ccccc: 'D',
+    cccccc: 'D',
+    // months
+    M: 'm',
+    MM: 'mm',
+    MMM: 'M',
+    MMMM: 'MM',
+    MMMMM: 'M',
+    L: 'm',
+    LL: 'mm',
+    LLL: 'M',
+    LLLL: 'MM',
+    LLLLL: 'M',
+    // year
+    y: 'y',
+    yy: 'y',
+    yyy: 'yy',
+    yyyy: 'yy',
+    Y: 'y',
+    YY: 'y',
+    YYY: 'yy',
+    YYYY: 'yy'
+};
+function padNumber(num, size = 2) {
+    let str = String(num);
+    while (str.length < size) {
+        str = '0' + str;
+    }
+    return str;
+}
+function dateToIsoString(value, type = 'date-time', dateTimeOpts = {}) {
+    if (typeof value === 'string') {
+        value = new Date(value);
+    }
+    if (typeof value === 'number') {
+        value = new Date(value);
+    }
+    if (!(value instanceof Date)) {
+        return null;
+    }
+    if (type === 'date') {
+        // date only, no time part (and timezone, millis, utc does not matter ...)
+        return value.getFullYear() + '-' + padNumber(value.getMonth() + 1) + '-' + padNumber(value.getDate());
+    }
+    if (dateTimeOpts.utc) {
+        let str = value.toISOString();
+        if (dateTimeOpts.noMillis) {
+            const dotIdx = str.lastIndexOf('.');
+            str = str.substring(0, dotIdx) + str.substring(dotIdx + 4, str.length);
+        }
+        if (dateTimeOpts.noTimezone) {
+            str = str.substring(0, str.length - 1);
+        }
+        return str;
+    }
+    else {
+        let base = value.getFullYear() +
+            '-' +
+            padNumber(value.getMonth() + 1) +
+            '-' +
+            padNumber(value.getDate()) +
+            'T' +
+            padNumber(value.getHours()) +
+            ':' +
+            padNumber(value.getMinutes()) +
+            ':' +
+            padNumber(value.getSeconds());
+        if (!dateTimeOpts.noMillis) {
+            base += '.' + padNumber(value.getMilliseconds());
+        }
+        if (!dateTimeOpts.noTimezone) {
+            const tzo = -value.getTimezoneOffset(), dif = tzo >= 0 ? '+' : '-';
+            base = base + (dif + padNumber(Math.floor(Math.abs(tzo) / 60)) + ':' + padNumber(Math.abs(tzo) % 60));
+        }
+        return base;
+    }
+}
+function fromAngularDateFormatToPrime(ngDateFormat) {
+    let primeDateFormat = ngDateFormat;
+    for (const regex of ngPrimeFormatOther) {
+        primeDateFormat = primeDateFormat.replace(regex, ' ');
+    }
+    for (const regex of ngPrimerFormatSupported) {
+        const matches = [...primeDateFormat.matchAll(regex)].reverse();
+        for (const match of matches) {
+            if (match.index) {
+                const matchStr = match[0];
+                const replacement = ngPrimerFormatMap[matchStr] ?? match[0];
+                primeDateFormat = primeDateFormat.substring(0, match.index) + replacement + primeDateFormat.substring(match.index + matchStr.length);
+            }
+        }
+    }
+    primeDateFormat = primeDateFormat.replace(/\s+\W\s+/g, ' ');
+    primeDateFormat = primeDateFormat.replace(/\s\s+/g, ' ');
+    return primeDateFormat.trim();
+}
+function angularDateFormatHasTime(ngDateFormat) {
+    return /[hHmsS]/.test(ngDateFormat);
+}
+function angularDateFormatHasSeconds(ngDateFormat) {
+    return /[sS]/.test(ngDateFormat);
+}
+
+var LogLevelEnum;
+(function (LogLevelEnum) {
+    LogLevelEnum[LogLevelEnum["Trace"] = 0] = "Trace";
+    LogLevelEnum[LogLevelEnum["Debug"] = 1] = "Debug";
+    LogLevelEnum[LogLevelEnum["Log"] = 2] = "Log";
+    LogLevelEnum[LogLevelEnum["Info"] = 3] = "Info";
+    LogLevelEnum[LogLevelEnum["Warning"] = 4] = "Warning";
+    LogLevelEnum[LogLevelEnum["Error"] = 5] = "Error";
+})(LogLevelEnum || (LogLevelEnum = {}));
+
+class LoggerService {
+    static { this._instance = new LoggerService(); }
+    static { this._isInit = false; }
+    static { this._publishers = []; }
+    static { this._entriesBuffer = []; }
+    static { this._categoryInstances = {}; }
+    static { this._timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS'; }
+    constructor() {
+        // Temporary settings that cover logging calls before initialisation
+        this.defaultLogLevel = LogLevelEnum.Info;
+        this.datePipe = new DatePipe('en-US');
+        // empty
+    }
+    static get() {
+        return LoggerService._instance;
+    }
+    static configure(config) {
+        if (config.timestampFormat) {
+            LoggerService._timestampFormat = config.timestampFormat;
+        }
+    }
+    static init(configurationService, publishers) {
+        if (LoggerService._isInit) {
+            return;
+        }
+        LoggerService._configurationService = configurationService;
+        LoggerService._publishers = publishers;
+        LoggerService._isInit = true;
+        LoggerService._flushBuffer();
+    }
+    static _flushBuffer() {
+        if (!LoggerService._isInit) {
+            return;
+        }
+        LoggerService._entriesBuffer.forEach(e => this._instance._log(e));
+        LoggerService._entriesBuffer = [];
+    }
+    static create(category) {
+        return LoggerService._instance.create(category);
+    }
+    create(category) {
+        if (this.category) {
+            throw new CommonsInternalError(`Cannot create logger with category inside another category (${this.category}). Must create logger on root.`);
+        }
+        if (LoggerService._categoryInstances[category]) {
+            return LoggerService._categoryInstances[category];
+        }
+        const logger = new LoggerService();
+        logger.category = category;
+        LoggerService._categoryInstances[category] = logger;
+        return logger;
+    }
+    _processLog(msgOrError, logLevel, category = undefined, data) {
+        const [timestamp, timestampFormatted] = [...this._getTimestamps()];
+        const logEntry = {
+            level: logLevel,
+            message: typeof msgOrError === 'string' ? msgOrError : msgOrError.message,
+            data: data,
+            category: this.category ?? category,
+            timestamp: timestamp,
+            timestampFormatted: timestampFormatted ?? undefined
+        };
+        if (msgOrError instanceof Error) {
+            // set error from message param
+            logEntry.error = msgOrError;
+        }
+        else if (data?.length && data[0] instanceof Error) {
+            // if first data is error, also consider as error
+            logEntry.error = data[0];
+            logEntry.data = data.splice(1);
+        }
+        this._log(logEntry);
+    }
+    _getTimestamps() {
+        const timestamp = new Date();
+        const timestampFormatted = this.datePipe.transform(timestamp, LoggerService._timestampFormat) ?? dateToIsoString(timestamp);
+        return [timestamp, timestampFormatted];
+    }
+    _log(log) {
+        if (!LoggerService._isInit) {
+            // add to buffer
+            LoggerService._entriesBuffer.push(log);
+            return;
+        }
+        const logConfig = (LoggerService._configurationService?.getConfigValue)?.('log');
+        if ((this.category && log.level < (logConfig?.category?.[this.category]?.level ?? logConfig?.level ?? this.defaultLogLevel)) ||
+            (!this.category && log.level < (logConfig?.level ?? this.defaultLogLevel))) {
+            return;
+        }
+        if (logConfig?.timestampFormat) {
+            log.timestampFormatted = this.datePipe.transform(log.timestamp, logConfig.timestampFormat) ?? undefined;
+        }
+        LoggerService._publishers.forEach(p => p.addEntry(log));
+    }
+    trace(msgOrError, ...data) {
+        this._processLog(msgOrError, LogLevelEnum.Trace, undefined, data);
+    }
+    debug(msgOrError, ...data) {
+        this._processLog(msgOrError, LogLevelEnum.Debug, undefined, data);
+    }
+    log(msgOrError, logLevel = LogLevelEnum.Log, category = undefined, ...data) {
+        this._processLog(msgOrError, logLevel, category, data);
+    }
+    logEntry(logEntry) {
+        const [timestamp, timestampFormatted] = [...this._getTimestamps()];
+        const logEntryFinal = {
+            timestamp: timestamp,
+            timestampFormatted: timestampFormatted ?? undefined,
+            category: this.category ?? logEntry.category,
+            message: '',
+            messageDetails: logEntry.messageDetails,
+            level: LogLevelEnum.Log,
+            ...logEntry
+        };
+        this._log(logEntryFinal);
+    }
+    info(msgOrError, ...data) {
+        this._processLog(msgOrError, LogLevelEnum.Info, undefined, data);
+    }
+    warn(msgOrError, ...data) {
+        this._processLog(msgOrError, LogLevelEnum.Warning, undefined, data);
+    }
+    error(msgOrError, ...data) {
+        this._processLog(msgOrError, LogLevelEnum.Error, undefined, data);
+    }
+}
+
+const BROWSER_STORAGE_IT = new InjectionToken('BROWSER_STORAGE');
+
+const COMMONS_MODULE_CONFIG_IT = new InjectionToken('COMMONS_MODULE_CONFIG');
+
+class CommonsService {
+    constructor() {
+        // internal
+        this.logger = inject(LoggerService).create('CommonsService');
+        this.router = inject(Router);
+        this.primengConfig = inject(PrimeNGConfig);
+        this.translate = inject(TranslateService);
+        this.titleService = inject(Title);
+        this.filterService = inject(FilterService);
+        this.moduleConfig = inject(COMMONS_MODULE_CONFIG_IT, { optional: true });
+        this.localStorage = inject(BROWSER_STORAGE_IT);
+        // breadcrumbs
+        this.breadcrumbHomeSubject = new BehaviorSubject({
+            icon: 'pi pi-home',
+            routerLink: '/'
+        });
+        this.breadcrumbsSubject = new BehaviorSubject([]);
+        // visual
+        this._colorScheme = 'light';
+        this.userSubject = new ReplaySubject(1);
+        this._userRoles = [];
+        this.userRolesSubject = new BehaviorSubject([]);
+        // language
+        this.languageSubject = new ReplaySubject(1);
+        this.dataLanguageSubject = new ReplaySubject(1);
+    }
+    // APP section
+    get appName() {
+        return this.moduleConfig?.app?.name ?? 'app.name';
+    }
+    get appOwner() {
+        return this.moduleConfig?.app?.owner ?? 'app.owner';
+    }
+    get appLogoLight() {
+        return this.moduleConfig?.app?.logoPathLight ? this.moduleConfig.app.logoPathLight : this.moduleConfig?.app?.logoPath ?? 'assets/layout/images/logo.png';
+    }
+    get appLogoDark() {
+        return this.moduleConfig?.app?.logoPathDark ? this.moduleConfig.app.logoPathDark : this.moduleConfig?.app?.logoPath ?? 'assets/layout/images/logo.png';
+    }
+    get appLogoNameLight() {
+        return this.moduleConfig?.app?.logoNamePathLight
+            ? this.moduleConfig.app.logoNamePathLight
+            : this.moduleConfig?.app?.logoNamePath ?? 'assets/layout/images/logo-appname.png';
+    }
+    get appLogoNameDark() {
+        return this.moduleConfig?.app?.logoNamePathDark ? this.moduleConfig.app.logoNamePathDark : this.moduleConfig?.app?.logoNamePath ?? 'assets/layout/images/logo-appname.png';
+    }
+    get appLanguages() {
+        return this.moduleConfig?.app?.languages ?? ['en'];
+    }
+    get appLanguage() {
+        const lsLang = this.localStorage.getItem('lang');
+        if (lsLang && this.appLanguages.some(l => l === lsLang)) {
+            return lsLang;
+        }
+        return null;
+    }
+    set appLanguage(language) {
+        if (language === null) {
+            this.localStorage.removeItem('lang');
+            this.languageSubject.next(language);
+            return;
+        }
+        if (this.appLanguages.some(l => l === language)) {
+            this.localStorage.setItem('lang', language);
+            this.languageSubject.next(language);
+            this.translate.use(language);
+        }
+    }
+    get appLanguage$() {
+        return this.languageSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    initLanguage() {
+        const browserLang = this.translate.getBrowserLang();
+        if (browserLang && this.appLanguages.some(l => l === browserLang)) {
+            this.appLanguage = browserLang;
+            return browserLang;
+        }
+        const defaultLanguage = this.appLanguages?.length > 0 ? this.appLanguages[0] : 'en';
+        this.appLanguage = defaultLanguage;
+        return defaultLanguage;
+    }
+    getOrInitLanguage() {
+        return this.appLanguage || this.initLanguage();
+    }
+    get appDataLanguages() {
+        return this.moduleConfig?.app?.dataLanguages ?? ['en'];
+    }
+    get appDataLanguageDefault() {
+        return this.appDataLanguages[0];
+    }
+    get appDataLanguage() {
+        const dataLang = this.localStorage.getItem('dataLang');
+        if (dataLang && this.appDataLanguages.some(dl => dl === dataLang)) {
+            return dataLang;
+        }
+        return this.defaultDataLanguage;
+    }
+    set appDataLanguage(dataLanguage) {
+        if (dataLanguage === null) {
+            this.localStorage.removeItem('dataLang');
+            this.dataLanguageSubject.next(dataLanguage);
+            return;
+        }
+        if (this.appDataLanguages.some(dl => dl === dataLanguage)) {
+            this.localStorage.setItem('dataLang', dataLanguage);
+            this.dataLanguageSubject.next(dataLanguage);
+        }
+    }
+    get appDataLanguage$() {
+        return this.dataLanguageSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    // We assume, that default data language is the first one from the array of all available data languages
+    get defaultDataLanguage() {
+        return this.appDataLanguages[0];
+    }
+    get appVersion() {
+        return this.moduleConfig?.app?.version;
+    }
+    // BREADCRUMB section
+    get breadcrumbHome$() {
+        return this.breadcrumbHomeSubject.asObservable();
+    }
+    get breadcrumbs$() {
+        return this.breadcrumbsSubject.asObservable();
+    }
+    // VISUAL section
+    get colorSchemeIsLight() {
+        return this._colorScheme === 'light';
+    }
+    get colorSchemeIsDark() {
+        return this._colorScheme === 'dark';
+    }
+    // USER section
+    get user() {
+        return this._user;
+    }
+    set user(user) {
+        this._user = user;
+        this.userSubject.next(user);
+    }
+    get user$() {
+        return this.userSubject.asObservable();
+    }
+    get userRoles() {
+        return this._userRoles;
+    }
+    set userRoles(roles) {
+        this._userRoles = roles;
+        this.userRolesSubject.next(roles);
+    }
+    get userRoles$() {
+        return this.userRolesSubject.asObservable();
+    }
+    reset() {
+        // visual
+        this._colorScheme = this.moduleConfig?.app?.colorScheme ?? 'light';
+        // ripple
+        this.primengConfig.ripple = true;
+        // translate
+        this.translate.langs = this.appLanguages;
+        const lang = this.getOrInitLanguage();
+        this.languageSubject.next(lang);
+        this.dataLanguageSubject.next(this.appDataLanguage);
+        this.translate.use(lang);
+        this.translate.get('mngPrime').subscribe(value => this.primengConfig.setTranslation(value));
+        this.routerEventsSubscription?.unsubscribe();
+        this.routerEventsSubscription = this.router.events
+            .pipe(
+        // Filter the NavigationEnd events as the breadcrumb is updated only when the route reaches its end
+        filter(event => event instanceof NavigationEnd))
+            .subscribe(() => {
+            this.updateBreadcrumbs();
+            this.setPageTitle();
+        });
+        this.translateLangChangeSubscription?.unsubscribe();
+        this.translateLangChangeSubscription = this.translate.onLangChange.subscribe(() => {
+            this.updateBreadcrumbs();
+            this.setPageTitle();
+        });
+        this.logger.debug('Reset');
+    }
+    // BREADCRUMB actions
+    findBreadcrumbItem(item) {
+        const items = this.breadcrumbsSubject.value;
+        if (item.id) {
+            return items.find(i => i.id && i.id === item.id) ?? null;
+        }
+        else if (item.routerLink) {
+            const routerLinkStr = Array.isArray(item.routerLink) ? item.routerLink.join('/') : item.routerLink;
+            return items.find(i => i.routerLink && (Array.isArray(i.routerLink) ? i.routerLink.join('/') : i.routerLink) === routerLinkStr) ?? null;
+        }
+        else if (item.positionIndex) {
+            return items.find(i => i.positionIndex && i.positionIndex === i.positionIndex) ?? null;
+        }
+        else if (item.label) {
+            return items.find(i => i.label && i.label === i.label) ?? null;
+        }
+        else if (item.icon) {
+            return items.find(i => i.icon && i.icon === i.icon) ?? null;
+        }
+        return null;
+    }
+    updateBreadcrumbItem(item) {
+        const items = [...this.breadcrumbsSubject.value];
+        let posIdx = -1;
+        if (item.id) {
+            posIdx = items.findIndex(i => i.id && i.id === item.id);
+        }
+        else if (item.routerLink) {
+            const routerLinkStr = Array.isArray(item.routerLink) ? item.routerLink.join('/') : item.routerLink;
+            posIdx = items.findIndex(i => i.routerLink && (Array.isArray(i.routerLink) ? i.routerLink.join('/') : i.routerLink) === routerLinkStr);
+        }
+        else if (item.positionIndex) {
+            posIdx = items.findIndex(i => i.positionIndex && i.positionIndex === i.positionIndex);
+        }
+        else if (item.label) {
+            posIdx = items.findIndex(i => i.label && i.label === i.label);
+        }
+        else if (item.icon) {
+            posIdx = items.findIndex(i => i.icon && i.icon === i.icon);
+        }
+        if (posIdx < 0) {
+            return false;
+        }
+        items[posIdx] = {
+            ...items[posIdx],
+            ...item,
+            updated: true
+        };
+        this.breadcrumbsSubject.next(items);
+        return true;
+    }
+    updateBreadcrumbs() {
+        if (this.breadcrumbsTranslateSubscription) {
+            this.breadcrumbsTranslateSubscription.unsubscribe();
+            this.breadcrumbsTranslateSubscription = undefined;
+        }
+        if (this.breadcrumbHomeTranslateSubscription) {
+            this.breadcrumbHomeTranslateSubscription.unsubscribe();
+            this.breadcrumbHomeTranslateSubscription = undefined;
+        }
+        const rootRoute = this.router.routerState.snapshot.root;
+        const homeBreadcrumb = this.generateHomeBreadcrumb(rootRoute);
+        if (homeBreadcrumb) {
+            if (homeBreadcrumb.label) {
+                this.breadcrumbHomeTranslateSubscription = this.translate.get(homeBreadcrumb.label).subscribe(i18n => {
+                    homeBreadcrumb.label = i18n;
+                    this.breadcrumbHomeSubject.next(homeBreadcrumb);
+                });
+            }
+            else {
+                this.breadcrumbHomeSubject.next(homeBreadcrumb);
+            }
+        }
+        const breadcrumbs = [];
+        this.generateBreadcrumbs(rootRoute, [], breadcrumbs);
+        breadcrumbs.forEach((b, idx) => {
+            b.positionIndex = idx;
+        });
+        const i18nKeys = breadcrumbs.filter(b => typeof b.label === 'string').map(b => b.label);
+        if (i18nKeys.length > 0) {
+            this.breadcrumbsTranslateSubscription = this.translate.get(i18nKeys).subscribe(i18n => {
+                // Construct the breadcrumb hierarchy
+                breadcrumbs.forEach(b => {
+                    if (b.label && i18n[b.label]) {
+                        b.label = i18n[b.label];
+                    }
+                });
+                // Emit the new breadcrumbs
+                this.breadcrumbsSubject.next(breadcrumbs);
+            });
+        }
+        else {
+            this.breadcrumbsSubject.next(breadcrumbs);
+        }
+    }
+    generateHomeBreadcrumb(route) {
+        if (!route) {
+            return null;
+        }
+        const routeData = route.data;
+        const breadcrumbRouteData = routeData?.breadcrumb;
+        if (breadcrumbRouteData && typeof breadcrumbRouteData === 'object' && 'isHome' in breadcrumbRouteData) {
+            if (breadcrumbRouteData.isHome === false) {
+                return null;
+            }
+            const breadcrumb = this.createBreadcrumb('/', breadcrumbRouteData, true);
+            if (breadcrumb) {
+                if (typeof breadcrumb.icon === 'undefined') {
+                    breadcrumb.icon = 'pi pi-home';
+                }
+                return breadcrumb;
+            }
+        }
+        else {
+            return this.generateHomeBreadcrumb(route.firstChild);
+        }
+        return null;
+    }
+    generateBreadcrumbs(route, parentUrlSegments, breadcrumbs) {
+        if (!route) {
+            return;
+        }
+        const routeData = route.data;
+        const routeUrlSegments = parentUrlSegments.concat(route.url.map(url => url.path));
+        const routeUrl = `/${routeUrlSegments.join('/')}`;
+        if (routeData?.breadcrumb) {
+            const breadcrumbRouteData = routeData.breadcrumb;
+            if (Array.isArray(breadcrumbRouteData)) {
+                for (const breadcrumbRouteDataItem of breadcrumbRouteData) {
+                    const breadcrumb = this.createBreadcrumb(routeUrl, breadcrumbRouteDataItem);
+                    if (breadcrumb) {
+                        breadcrumbs.push(breadcrumb);
+                    }
+                }
+            }
+            else if (typeof breadcrumbRouteData === 'function') {
+                breadcrumbs.push(...breadcrumbRouteData(routeUrl, route));
+            }
+            else {
+                const breadcrumb = this.createBreadcrumb(routeUrl, breadcrumbRouteData);
+                if (breadcrumb) {
+                    breadcrumbs.push(breadcrumb);
+                }
+            }
+        }
+        this.generateBreadcrumbs(route.firstChild, routeUrlSegments, breadcrumbs);
+    }
+    createBreadcrumb(routeUrl, routeBreadcrumb, includeHome = false) {
+        const existingBreadcrumb = this.findBreadcrumbItem({ routerLink: routeUrl });
+        if (existingBreadcrumb?.updated) {
+            return existingBreadcrumb;
+        }
+        if (typeof routeBreadcrumb === 'string') {
+            // check for updated existing breadcrumb
+            return {
+                id: routeUrl,
+                label: routeBreadcrumb,
+                routerLink: routeUrl
+            };
+        }
+        else {
+            if (!includeHome && typeof routeBreadcrumb.isHome !== 'undefined') {
+                // home should not be included
+                return null;
+            }
+            if (typeof routeBreadcrumb.routerLink === 'undefined') {
+                routeBreadcrumb.routerLink = routeUrl;
+            }
+            routeBreadcrumb.id = routeUrl;
+            return routeBreadcrumb;
+        }
+    }
+    // TITLE section
+    setPageTitle(title) {
+        let currentRoute = this.router.routerState.snapshot.root;
+        while (currentRoute.firstChild) {
+            currentRoute = currentRoute.firstChild;
+        }
+        const routeData = currentRoute.data;
+        const pageTitle = title ?? routeData.pageTitle;
+        this.titleService.setTitle(this.formatPageTitle(pageTitle));
+    }
+    formatPageTitle(titlePrefix) {
+        const titlePieces = [];
+        if (titlePrefix) {
+            titlePieces.push(this.translate.instant(titlePrefix));
+        }
+        titlePieces.push(this.translate.instant('app.name'));
+        return titlePieces.join(' - ');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsService, decorators: [{
+            type: Injectable
+        }] });
+
+class ErrorPageComponent {
+    constructor(commons) {
+        this.commons = commons;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ErrorPageComponent, deps: [{ token: CommonsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: ErrorPageComponent, isStandalone: true, selector: "mng-error-page", ngImport: i0, template: "<div [class]=\"'exception-body min-h-screen ' + (commons.colorSchemeIsLight ? 'layout-light' : 'layout-dark')\">\n    <div class=\"exception-container min-h-screen flex align-items-center justify-content-center flex-column bg-auto md:bg-contain bg-no-repeat\">\n        <div class=\"exception-panel text-center flex align-items-center justify-content-center flex-column\">\n            <h1 class=\"text-red-400 mb-0\">{{ 'pages.notFound.title' | translate }}</h1>\n            <h3 class=\"text-red-300\">{{ 'pages.notFound.subtitle' | translate }}</h3>\n            <button type=\"button\" pButton [label]=\"'general.returnHome' | translate\" [routerLink]=\"['/']\"></button>\n        </div>\n        <div class=\"exception-footer align-items-center flex\">\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoDark : commons.appLogoLight\" class=\"exception-logo\" alt=\"App logo\" />\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoNameDark : commons.appLogoNameLight\" class=\"exception-appname ml-3\" alt=\"App name\" />\n        </div>\n    </div>\n</div>\n", styles: [".exception-body{background:var(--surface-ground)}.exception-body .exception-container{background:var(--exception-pages-image);background-repeat:no-repeat;background-size:contain;box-sizing:border-box}.exception-body .exception-container .exception-panel{box-sizing:border-box;flex-grow:1;margin-top:3rem;margin-bottom:3rem}.exception-body .exception-container .exception-panel h1{font-size:140px;font-weight:900;text-shadow:0 0 50px rgba(252,97,97,.2)}.exception-body .exception-container .exception-panel h3{font-size:80px;font-weight:900;margin-top:-90px;margin-bottom:50px}.exception-body .exception-container .exception-panel button{margin-top:50px}.exception-body .exception-container .exception-footer{margin-bottom:2rem}.exception-body .exception-container .exception-footer .exception-logo{width:34px}.exception-body .exception-container .exception-footer .exception-appname{width:72px}\n"], dependencies: [{ kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i2$1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3$1.TranslatePipe, name: "translate" }, { kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ErrorPageComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'mng-error-page', imports: [ButtonModule, TranslateModule, RouterLink], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div [class]=\"'exception-body min-h-screen ' + (commons.colorSchemeIsLight ? 'layout-light' : 'layout-dark')\">\n    <div class=\"exception-container min-h-screen flex align-items-center justify-content-center flex-column bg-auto md:bg-contain bg-no-repeat\">\n        <div class=\"exception-panel text-center flex align-items-center justify-content-center flex-column\">\n            <h1 class=\"text-red-400 mb-0\">{{ 'pages.notFound.title' | translate }}</h1>\n            <h3 class=\"text-red-300\">{{ 'pages.notFound.subtitle' | translate }}</h3>\n            <button type=\"button\" pButton [label]=\"'general.returnHome' | translate\" [routerLink]=\"['/']\"></button>\n        </div>\n        <div class=\"exception-footer align-items-center flex\">\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoDark : commons.appLogoLight\" class=\"exception-logo\" alt=\"App logo\" />\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoNameDark : commons.appLogoNameLight\" class=\"exception-appname ml-3\" alt=\"App name\" />\n        </div>\n    </div>\n</div>\n", styles: [".exception-body{background:var(--surface-ground)}.exception-body .exception-container{background:var(--exception-pages-image);background-repeat:no-repeat;background-size:contain;box-sizing:border-box}.exception-body .exception-container .exception-panel{box-sizing:border-box;flex-grow:1;margin-top:3rem;margin-bottom:3rem}.exception-body .exception-container .exception-panel h1{font-size:140px;font-weight:900;text-shadow:0 0 50px rgba(252,97,97,.2)}.exception-body .exception-container .exception-panel h3{font-size:80px;font-weight:900;margin-top:-90px;margin-bottom:50px}.exception-body .exception-container .exception-panel button{margin-top:50px}.exception-body .exception-container .exception-footer{margin-bottom:2rem}.exception-body .exception-container .exception-footer .exception-logo{width:34px}.exception-body .exception-container .exception-footer .exception-appname{width:72px}\n"] }]
+        }], ctorParameters: () => [{ type: CommonsService }] });
+
+class NotFoundPageComponent {
+    constructor(commons) {
+        this.commons = commons;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotFoundPageComponent, deps: [{ token: CommonsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: NotFoundPageComponent, isStandalone: true, selector: "mng-not-found-page", ngImport: i0, template: "<div [class]=\"'exception-body min-h-screen ' + (commons.colorSchemeIsLight ? 'layout-light' : 'layout-dark')\">\n    <div class=\"exception-container min-h-screen flex align-items-center justify-content-center flex-column bg-auto md:bg-contain bg-no-repeat\">\n        <div class=\"exception-panel text-center flex align-items-center justify-content-center flex-column\">\n            <h1 class=\"text-red-400 mb-0\">{{ 'pages.notFound.title' | translate }}</h1>\n            <h3 class=\"text-red-300\">{{ 'pages.notFound.subtitle' | translate }}</h3>\n            <p>{{ 'pages.notFound.message' | translate }}</p>\n            <button type=\"button\" pButton [label]=\"'general.returnHome' | translate\" [routerLink]=\"['/']\"></button>\n        </div>\n        <div class=\"exception-footer align-items-center flex\">\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoDark : commons.appLogoLight\" class=\"exception-logo\" alt=\"App logo\" />\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoNameDark : commons.appLogoNameLight\" class=\"exception-appname ml-3\" alt=\"App name\" />\n        </div>\n    </div>\n</div>\n", styles: [".exception-body{background:var(--surface-ground)}.exception-body .exception-container{background:var(--exception-pages-image);background-repeat:no-repeat;background-size:contain;box-sizing:border-box}.exception-body .exception-container .exception-panel{box-sizing:border-box;flex-grow:1;margin-top:3rem;margin-bottom:3rem}.exception-body .exception-container .exception-panel h1{font-size:140px;font-weight:900;text-shadow:0 0 50px rgba(252,97,97,.2)}.exception-body .exception-container .exception-panel h3{font-size:80px;font-weight:900;margin-top:-90px;margin-bottom:50px}.exception-body .exception-container .exception-panel p{font-size:24px;font-weight:400;max-width:320px}.exception-body .exception-container .exception-panel button{margin-top:50px}.exception-body .exception-container .exception-footer{margin-bottom:2rem}.exception-body .exception-container .exception-footer .exception-logo{width:34px}.exception-body .exception-container .exception-footer .exception-appname{width:72px}\n"], dependencies: [{ kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i2$1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3$1.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotFoundPageComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'mng-not-found-page', imports: [ButtonModule, RouterLink, TranslateModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div [class]=\"'exception-body min-h-screen ' + (commons.colorSchemeIsLight ? 'layout-light' : 'layout-dark')\">\n    <div class=\"exception-container min-h-screen flex align-items-center justify-content-center flex-column bg-auto md:bg-contain bg-no-repeat\">\n        <div class=\"exception-panel text-center flex align-items-center justify-content-center flex-column\">\n            <h1 class=\"text-red-400 mb-0\">{{ 'pages.notFound.title' | translate }}</h1>\n            <h3 class=\"text-red-300\">{{ 'pages.notFound.subtitle' | translate }}</h3>\n            <p>{{ 'pages.notFound.message' | translate }}</p>\n            <button type=\"button\" pButton [label]=\"'general.returnHome' | translate\" [routerLink]=\"['/']\"></button>\n        </div>\n        <div class=\"exception-footer align-items-center flex\">\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoDark : commons.appLogoLight\" class=\"exception-logo\" alt=\"App logo\" />\n            <img [src]=\"commons.colorSchemeIsLight ? commons.appLogoNameDark : commons.appLogoNameLight\" class=\"exception-appname ml-3\" alt=\"App name\" />\n        </div>\n    </div>\n</div>\n", styles: [".exception-body{background:var(--surface-ground)}.exception-body .exception-container{background:var(--exception-pages-image);background-repeat:no-repeat;background-size:contain;box-sizing:border-box}.exception-body .exception-container .exception-panel{box-sizing:border-box;flex-grow:1;margin-top:3rem;margin-bottom:3rem}.exception-body .exception-container .exception-panel h1{font-size:140px;font-weight:900;text-shadow:0 0 50px rgba(252,97,97,.2)}.exception-body .exception-container .exception-panel h3{font-size:80px;font-weight:900;margin-top:-90px;margin-bottom:50px}.exception-body .exception-container .exception-panel p{font-size:24px;font-weight:400;max-width:320px}.exception-body .exception-container .exception-panel button{margin-top:50px}.exception-body .exception-container .exception-footer{margin-bottom:2rem}.exception-body .exception-container .exception-footer .exception-logo{width:34px}.exception-body .exception-container .exception-footer .exception-appname{width:72px}\n"] }]
+        }], ctorParameters: () => [{ type: CommonsService }] });
+
+class FilterMatchMode {
+    static { this.Equals = 'equals'; }
+    static { this.EqualsAbbr = 'eq'; }
+    static { this.NotEquals = 'notEquals'; }
+    static { this.NotEqualsAbbr = 'ne'; }
+    static { this.Contains = 'contains'; }
+    static { this.ContainsAbbr = 'cn'; }
+    static { this.NotContains = 'notContains'; }
+    static { this.NotContainsAbbr = 'nc'; }
+    static { this.In = 'in'; }
+    static { this.InAbbr = 'in'; }
+    static { this.NotIn = 'notIn'; }
+    static { this.NotInAbbr = 'ni'; }
+    static { this.StartsWith = 'startsWith'; }
+    static { this.StartsWithAbbr = 'sw'; }
+    static { this.EndsWith = 'endsWith'; }
+    static { this.EndsWithAbbr = 'ew'; }
+    static { this.LessThan = 'lessThan'; }
+    static { this.LessThanAbbr = 'lt'; }
+    static { this.LessThanOrEqualTo = 'lessThanOrEqualTo'; }
+    static { this.LessThanOrEqualToAbbr = 'le'; }
+    static { this.GreaterThan = 'greaterThan'; }
+    static { this.GreaterThanAbbr = 'gt'; }
+    static { this.GreaterThanOrEqualTo = 'greaterThanOrEqualTo'; }
+    static { this.GreaterThanOrEqualToAbbr = 'ge'; }
+    static { this.Between = 'between'; }
+    static { this.BetweenAbbr = 'bt'; }
+    static { this.Exists = 'exists'; }
+    static { this.ExistsAbbr = 'ex'; }
+    static { this.DoesNotExist = 'doesNotExist'; }
+    static { this.DoesNotExistAbbr = 'nx'; }
+    static getAbbreviation(mode) {
+        switch (mode) {
+            case FilterMatchMode.Equals:
+                return FilterMatchMode.EqualsAbbr;
+            case FilterMatchMode.NotEquals:
+                return FilterMatchMode.NotEqualsAbbr;
+            case FilterMatchMode.Contains:
+                return FilterMatchMode.ContainsAbbr;
+            case FilterMatchMode.NotContains:
+                return FilterMatchMode.NotContainsAbbr;
+            case FilterMatchMode.In:
+                return FilterMatchMode.InAbbr;
+            case FilterMatchMode.NotIn:
+                return FilterMatchMode.NotInAbbr;
+            case FilterMatchMode.StartsWith:
+                return FilterMatchMode.StartsWithAbbr;
+            case FilterMatchMode.EndsWith:
+                return FilterMatchMode.EndsWithAbbr;
+            case FilterMatchMode.LessThan:
+                return FilterMatchMode.LessThanAbbr;
+            case FilterMatchMode.LessThanOrEqualTo:
+                return FilterMatchMode.LessThanOrEqualToAbbr;
+            case FilterMatchMode.GreaterThan:
+                return FilterMatchMode.GreaterThanAbbr;
+            case FilterMatchMode.GreaterThanOrEqualTo:
+                return FilterMatchMode.GreaterThanOrEqualToAbbr;
+            case FilterMatchMode.Between:
+                return FilterMatchMode.BetweenAbbr;
+            case FilterMatchMode.Exists:
+                return FilterMatchMode.ExistsAbbr;
+            case FilterMatchMode.DoesNotExist:
+                return FilterMatchMode.DoesNotExistAbbr;
+            default:
+                return null;
+        }
+    }
+    static fromAbbreviation(abbr) {
+        switch (abbr) {
+            case FilterMatchMode.EqualsAbbr:
+                return FilterMatchMode.Equals;
+            case FilterMatchMode.NotEqualsAbbr:
+                return FilterMatchMode.NotEquals;
+            case FilterMatchMode.ContainsAbbr:
+                return FilterMatchMode.Contains;
+            case FilterMatchMode.NotContainsAbbr:
+                return FilterMatchMode.NotContains;
+            case FilterMatchMode.InAbbr:
+                return FilterMatchMode.In;
+            case FilterMatchMode.NotInAbbr:
+                return FilterMatchMode.NotIn;
+            case FilterMatchMode.StartsWithAbbr:
+                return FilterMatchMode.StartsWith;
+            case FilterMatchMode.EndsWithAbbr:
+                return FilterMatchMode.EndsWith;
+            case FilterMatchMode.LessThanAbbr:
+                return FilterMatchMode.LessThan;
+            case FilterMatchMode.LessThanOrEqualToAbbr:
+                return FilterMatchMode.LessThanOrEqualTo;
+            case FilterMatchMode.GreaterThanAbbr:
+                return FilterMatchMode.GreaterThan;
+            case FilterMatchMode.GreaterThanOrEqualToAbbr:
+                return FilterMatchMode.GreaterThanOrEqualTo;
+            case FilterMatchMode.BetweenAbbr:
+                return FilterMatchMode.Between;
+            case FilterMatchMode.ExistsAbbr:
+                return FilterMatchMode.Exists;
+            case FilterMatchMode.DoesNotExistAbbr:
+                return FilterMatchMode.DoesNotExist;
+            default:
+                return null;
+        }
+    }
+}
+
+/**
+ * Converts a TableLazyLoadEvent to DataListParams.
+ *
+ * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+function fromTableLoadToDataListParams(event) {
+    const params = {};
+    if (event.first != null) {
+        params.offset = event.first;
+    }
+    if (event.rows != null) {
+        params.limit = event.rows;
+    }
+    if (typeof event.globalFilter === 'string') {
+        params.search = event.globalFilter;
+    }
+    else if (Array.isArray(event.globalFilter) && event.globalFilter.length > 0) {
+        params.search = event.globalFilter.join(',');
+    }
+    if (Array.isArray(event.multiSortMeta) && event.multiSortMeta.length > 0) {
+        params.sort = event.multiSortMeta.map(m => ({ property: m.field, ascending: m.order >= 0 }));
+    }
+    if (event.filters) {
+        params.filters = Object.keys(event.filters).reduce((acc, key) => {
+            const filter = {};
+            const eventFilter = event.filters?.[key];
+            if (Array.isArray(eventFilter)) {
+                filter.value = eventFilter[0].value;
+                filter.matchMode = eventFilter[0].matchMode;
+            }
+            else if (eventFilter !== undefined) {
+                filter.value = eventFilter.value;
+                filter.matchMode = eventFilter.matchMode;
+            }
+            return { ...acc, [key]: filter };
+        }, {});
+    }
+    return params;
+}
+/**
+ * Converts the given parameters to URL query parameters.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.
+ * @returns {Params} - The URL query parameters object.
+ */
+function dataListParamsToUrlQuery(params, defaults = {
+    limit: 25,
+    offset: 0
+}) {
+    const urlParams = {};
+    if (params.limit && params.limit !== defaults?.limit) {
+        urlParams['limit'] = params.limit;
+    }
+    if (params.offset && params.offset !== defaults?.offset) {
+        urlParams['offset'] = params.offset;
+    }
+    if (params.search && params.search !== defaults?.search) {
+        urlParams['q'] = params.search;
+    }
+    if (params.sort && Array.isArray(params.sort) && params.sort.length > 0) {
+        if (defaults?.sort == null ||
+            !Array.isArray(defaults.sort) ||
+            defaults.sort.length === 0 ||
+            params.sort.length !== defaults.sort.length ||
+            defaults.sort.some((ds, idx) => ds.property !== params.sort[idx].property || (ds.ascending ?? true) !== (params.sort[idx].ascending ?? true))) {
+            urlParams['sort'] = dataListParamsSortToUrlQuery(params);
+        }
+    }
+    if (params.filters) {
+        Object.keys(params.filters).forEach(k => {
+            const paramFilter = params.filters[k];
+            const defaultFilter = defaults?.filters?.[k];
+            if (defaultFilter &&
+                ((Array.isArray(defaultFilter.value) &&
+                    Array.isArray(paramFilter.value) &&
+                    defaultFilter.value.length === paramFilter.value.length &&
+                    defaultFilter.value.every((v, idx) => {
+                        const value = paramFilter.value[idx];
+                        if (value instanceof Date && v instanceof Date)
+                            return value.getTime() === v.getTime();
+                        else
+                            return value === v;
+                    })) || // handle arrays
+                    defaultFilter.value === paramFilter.value) &&
+                defaultFilter.matchMode === paramFilter.matchMode &&
+                (defaultFilter.caseSensitive ?? false) === (paramFilter.caseSensitive ?? false)) {
+                return;
+            }
+            if (paramFilter.value == null && defaultFilter?.value == null) {
+                return;
+            }
+            urlParams[k] = dataListParamsFiltersToUrlQuery(params, k, true);
+        });
+    }
+    if (defaults?.filters) {
+        // add other defaults
+        const paramFilterKeys = params.filters ? Object.keys(params.filters) : [];
+        Object.keys(defaults.filters)
+            .filter(k => paramFilterKeys.indexOf(k) < 0)
+            .forEach(k => {
+            urlParams[k] = dataListParamsFiltersToUrlQuery(defaults, k);
+        });
+    }
+    return urlParams;
+}
+/**
+ * Merges the provided parameters with default values and returns the merged object.
+ *
+ * @param {DataListParams} params - The parameters to merge with defaults.
+ * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).
+ * @returns {DataListParams} - The merged parameters object.
+ */
+function mergeDataListParamsWithDefaults(params, defaults = {
+    limit: 25,
+    offset: 0
+}) {
+    const merged = {
+        limit: params.limit ?? defaults.limit,
+        offset: params.offset ?? defaults.offset,
+        search: params.search ?? defaults.search,
+        sort: (params.sort ?? defaults.sort)?.map(s => ({ ...s }))
+    };
+    if (params.filters) {
+        merged.filters = {};
+        Object.entries(params.filters).forEach(([key, value]) => (merged.filters[key] = { ...value }));
+    }
+    if (defaults.filters) {
+        if (!merged.filters)
+            merged.filters = {};
+        Object.entries(defaults.filters).forEach(([key, value]) => {
+            if (merged.filters[key] === undefined) {
+                merged.filters[key] = { ...value };
+            }
+        });
+    }
+    return merged;
+}
+/**
+ * Converts an object of parameters to a URL query string for sorting.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ *
+ * @param {DataListParams} params - An optional object containing sort parameters.
+ * @returns A string representing the URL query or undefined if no sort parameters are provided.
+ */
+function dataListParamsSortToUrlQuery(params) {
+    return params && Array.isArray(params.sort)
+        ? params.sort.map(s => `${s.ascending === true || s.ascending === undefined ? 'asc' : 'desc'}:${String(s.property)}`).join(',')
+        : undefined;
+}
+/**
+ * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.
+ * @param {Filters} key - The key of the filter to convert.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.
+ * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.
+ */
+function dataListParamsFiltersToUrlQuery(params, key, allowNull = false) {
+    const paramFilter = params?.filters?.[key];
+    return dataListParamsFilterToUrlQuery(paramFilter, allowNull);
+}
+/**
+ * Converts a filter to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListFilter} paramFilter - The filter object to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.
+ * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.
+ * @throws {CommonsInternalError} - If the filter has invalid values.
+ */
+function dataListParamsFilterToUrlQuery(paramFilter, allowNull = false) {
+    const filterValueAsArray = Array.isArray(paramFilter?.value) ? paramFilter.value.filter(v => v !== undefined && (allowNull || v !== null)) : undefined;
+    if (paramFilter === undefined ||
+        (!allowNull && paramFilter.value == null) ||
+        (typeof paramFilter.value === 'string' && paramFilter.value.length === 0) ||
+        (Array.isArray(filterValueAsArray) && filterValueAsArray.length === 0)) {
+        // no need to include filters for empty values
+        return undefined;
+    }
+    const matchMode = paramFilter.matchMode ?? FilterMatchMode.Equals;
+    if (matchMode === FilterMatchMode.Between && !(Array.isArray(filterValueAsArray) && filterValueAsArray.length === 2)) {
+        throw new CommonsInternalError(`Filter match mode between requires exactly 2 values: ${paramFilter.value}`);
+    }
+    if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn) && (!Array.isArray(filterValueAsArray) || filterValueAsArray.length === 0)) {
+        throw new CommonsInternalError(`Filter match mode ${matchMode} requires non-empty array: ${paramFilter.value}`);
+    }
+    if ([FilterMatchMode.In, FilterMatchMode.NotIn, FilterMatchMode.Between].indexOf(matchMode) === -1 && Array.isArray(filterValueAsArray)) {
+        throw new CommonsInternalError(`Filter match mode ${matchMode} must not be array: ${paramFilter.value}`);
+    }
+    const noVal = paramFilter.matchMode === FilterMatchMode.Exists || paramFilter.matchMode === FilterMatchMode.DoesNotExist;
+    const urlValuePart = noVal ? '' : `:${dataListParamsFilterValueToUrlString(filterValueAsArray ?? paramFilter.value, allowNull)}`;
+    return `${paramFilter.caseSensitive ? 'cs:' : paramFilter.caseSensitive === false ? 'ci:' : ''}${FilterMatchMode.getAbbreviation(matchMode) ?? matchMode}${urlValuePart}`;
+}
+/**
+ * Converts URL query parameters to a DataListParams object.
+ * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {Params} urlParams - The URL query parameters.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+function fromUrlQueryToDataListParams(urlParams) {
+    const params = {};
+    Object.entries(urlParams).forEach(([urlParamKey, urlParamValue]) => {
+        if (urlParamKey === 'limit') {
+            params.limit = +urlParamValue;
+            if (isNaN(params.limit) || params.limit < 0) {
+                delete params.limit;
+            }
+        }
+        else if (urlParamKey === 'offset') {
+            params.offset = +urlParamValue;
+            if (isNaN(params.offset) || params.offset < 0) {
+                delete params.offset;
+            }
+        }
+        else if (urlParamKey === 'q') {
+            params.search = urlParamValue;
+        }
+        else if (urlParamKey === 'sort') {
+            if (typeof urlParamValue === 'string') {
+                params.sort = urlParamValue.split(',').map(s => {
+                    const [direction, property] = s.split(':');
+                    return { property: (property ?? direction), ascending: direction !== 'desc' };
+                });
+            }
+            else {
+                throw new CommonsInternalError(`String is expected as value for '${urlParamKey}' when converting from urlParams`);
+            }
+        }
+        else if (typeof urlParamValue === 'string') {
+            if (urlParamValue.length === 0) {
+                // empty string should be ignored
+                return;
+            }
+            const filterParts = urlParamValue.split(':');
+            let partIdx = 0;
+            // case sensitive
+            let caseSensitive = undefined;
+            if (filterParts[partIdx] === 'cs' || filterParts[partIdx] === 'ci') {
+                caseSensitive = filterParts[partIdx++] === 'cs';
+            }
+            // match mode
+            const matchMode = filterParts[partIdx] ? FilterMatchMode.fromAbbreviation(filterParts[partIdx]) ?? filterParts[partIdx] : FilterMatchMode.Equals;
+            partIdx++;
+            const noVal = matchMode === FilterMatchMode.Exists || matchMode === FilterMatchMode.DoesNotExist;
+            // value
+            let value = undefined;
+            if (!noVal) {
+                if (filterParts.length < 2) {
+                    return;
+                }
+                if (partIdx === filterParts.length - 1) {
+                    value = filterParts[partIdx];
+                }
+                else if (partIdx < filterParts.length) {
+                    // array that should not be array, so join back together
+                    value = filterParts.slice(partIdx, filterParts.length).join(':');
+                }
+                if (value === undefined && matchMode !== FilterMatchMode.Exists && matchMode !== FilterMatchMode.DoesNotExist) {
+                    // if value undefined and match mode expects value, then skip
+                    return;
+                }
+                if (value === 'null') {
+                    value = null;
+                }
+                if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn || matchMode === FilterMatchMode.Between) && typeof value === 'string') {
+                    let arrayVal = [];
+                    // these match modes expect array
+                    if (value.indexOf('"') >= 0) {
+                        const tokens = [];
+                        let currentToken = '';
+                        let explicitQuotes = false; //token is quoted, e.g. in:1,2,"22""",",123"""
+                        let quotesOpened = false; //token has started processing
+                        let quotesExplicitlyClosed = false; //token processing has finished, after single " in quoted mode, or before , in not quoted
+                        for (let i = 0; i < value.length; i++) {
+                            const c = value[i];
+                            // reset the tokenizer when seeing the token separator
+                            // only if either:
+                            // the quotes have not been opened yet (when there are no characters between separators),
+                            // the token has been explicitly closed (when we actually have explicit opening i.e., quotes as the first character)
+                            // or we have implicit quotes (i.e., quotes are not the first character)
+                            if (c === ',' && (!quotesOpened || quotesExplicitlyClosed || !explicitQuotes)) {
+                                tokens.push(currentToken);
+                                currentToken = '';
+                                quotesOpened = false;
+                                quotesExplicitlyClosed = false;
+                                explicitQuotes = false;
+                            }
+                            else if (c == '"') {
+                                // escaped double-quotes
+                                if (explicitQuotes && i + 1 < value.length && value[i + 1] === '"') {
+                                    currentToken += c; // Append one double-quote to the current token
+                                    i++; // Skip the next double-quote
+                                }
+                                // we encounter quotes again after they were the first character => we close the token
+                                else if (explicitQuotes) {
+                                    quotesExplicitlyClosed = true;
+                                }
+                                // implicit quotes
+                                else if (quotesOpened) {
+                                    currentToken += c;
+                                }
+                                // quotes are the first character => explicitly open the token
+                                else {
+                                    currentToken = '';
+                                    quotesOpened = true;
+                                    explicitQuotes = true;
+                                }
+                            }
+                            else {
+                                if (quotesExplicitlyClosed) {
+                                    return;
+                                }
+                                quotesOpened = true;
+                                currentToken += c;
+                            }
+                        }
+                        if (quotesOpened && !quotesExplicitlyClosed && explicitQuotes) {
+                            return;
+                        }
+                        // Append the last token after the loop ends
+                        tokens.push(currentToken.toString());
+                        arrayVal = tokens;
+                    }
+                    else {
+                        arrayVal = value.split(',');
+                    }
+                    if (matchMode === FilterMatchMode.Between && arrayVal.length !== 2) {
+                        return;
+                    }
+                    value = arrayVal;
+                }
+                if ((typeof value === 'string' && value.length === 0) || (Array.isArray(value) && value.length === 0)) {
+                    // filter with empty value is to be ignored
+                    return;
+                }
+            }
+            else {
+                caseSensitive = undefined;
+            }
+            if (!params.filters) {
+                params.filters = {};
+            }
+            params.filters[urlParamKey] = { value: value, matchMode: matchMode, caseSensitive: caseSensitive };
+        }
+    });
+    return params;
+}
+/**
+ * Makes a copy of the given DataListParams object.
+ *
+ * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.
+ * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.
+ */
+function copyDataListParams(params) {
+    const copy = {
+        offset: params.offset,
+        limit: params.limit,
+        search: params.search
+    };
+    if (params.sort) {
+        copy.sort = params.sort?.map(s => ({ ...s }));
+    }
+    if (params.filters) {
+        copy.filters = Object.entries(params.filters).reduce((acc, [key, value]) => {
+            const filterValue = value;
+            return {
+                ...acc,
+                [key]: {
+                    ...filterValue,
+                    value: Array.isArray(filterValue.value) ? [...filterValue.value] : filterValue.value
+                }
+            };
+        }, {});
+    }
+    return copy;
+}
+/**
+ * Converts a value to a URL query param string representation.
+ *
+ * @param {unknown} value - The value to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.
+ * @returns {string} The URL parameter representation of the value.
+ * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.
+ * @throws {CommonsInternalError} If the value is an object (excluding Date).
+ */
+function dataListParamsFilterValueToUrlString(value, allowNull = false) {
+    if (value === null && allowNull)
+        return 'null';
+    if (value == null)
+        throw new CommonsInternalError('Undefined value cannot be converted to url param.'); // this should not happen, should be filtered out earlier
+    if (Array.isArray(value))
+        return value
+            .map(v => dataListParamsFilterValueToUrlString(v, allowNull))
+            .map(v => (v.indexOf(',') >= 0 || v.indexOf('"') >= 0 ? `"${v.replaceAll('"', '""')}"` : v))
+            .join(',');
+    if (typeof value === 'object') {
+        if (value instanceof Date)
+            return dateToIsoString(value, 'dateTime', { utc: true });
+        else {
+            throw new CommonsInternalError('Filter value cannot be object');
+        }
+    }
+    return String(value);
+}
+
+/**
+ * A base data provider class used for handling data operations.
+ *
+ * @tparam Model - The type of data this data provider will handle.
+ * @tparam Service - The type of service used by this data provider (optional).
+ * @tparam ModelClass - The model type for the data provider  (optional).
+ * @tparam ServiceClass - The service type for the data provider  (optional).
+ */
+class DataProviderInst {
+    constructor(classType, serviceType) {
+        this.classType = classType;
+        this.serviceType = serviceType;
+    }
+    get isDataProvider() {
+        return true;
+    }
+}
+class DataProvider extends DataProviderInst {
+    constructor() {
+        super(undefined, undefined);
+    }
+    static create() {
+        return new DataProviderInst(undefined, undefined);
+    }
+    static fromClass(type) {
+        return new DataProviderInst(type, undefined);
+    }
+    static fromClassWithService(type, serviceType) {
+        return new DataProviderInst(type, serviceType);
+    }
+    static fromService(serviceType) {
+        return new DataProviderInst(undefined, serviceType);
+    }
+    static fromAnyParam(type, serviceType) {
+        if (typeof type !== 'undefined') {
+            return typeof serviceType !== 'undefined'
+                ? DataProvider.fromClassWithService(type, serviceType)
+                : DataProvider.fromClass(type);
+        }
+        else if (typeof serviceType !== 'undefined') {
+            return DataProvider.fromService(serviceType);
+        }
+        else {
+            return DataProvider.create();
+        }
+    }
+}
+
+class ComponentDirective {
+    constructor() {
+        this.injector = inject(Injector);
+        this.elementRef = inject(ElementRef);
+        this.applicationRef = inject(ApplicationRef);
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.attachToHost = false;
+        this.componentInstanceEventEmitter = new EventEmitter();
+    }
+    ngOnInit() {
+        let component = null;
+        if (this.component) {
+            component = this.component;
+        }
+        else if (this.componentIt) {
+            component = this.injector.get(this.componentIt, null, { optional: true });
+        }
+        if (!component) {
+            throw new CommonsInternalError(`Component cannot be created, no component (${this.component}) or no or invalid injection token provided (${this.componentIt}).`);
+        }
+        if (this.attachToHost) {
+            this.componentRef = createComponent(component, {
+                hostElement: this.elementRef.nativeElement,
+                environmentInjector: this.applicationRef.injector,
+                elementInjector: this.nodeInjector ?? this.injector
+            });
+        }
+        else {
+            this.viewContainerRef.clear();
+            this.componentRef = this.viewContainerRef.createComponent(component, {
+                injector: this.nodeInjector ?? undefined
+            });
+        }
+        if (this.inputs) {
+            for (const input in this.inputs) {
+                this.componentRef.setInput(input, this.inputs[input]);
+            }
+        }
+        if (this.attachToHost) {
+            this.applicationRef.attachView(this.componentRef.hostView);
+        }
+        this.componentInstanceEventEmitter.next(this.componentRef.instance);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ComponentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.2", type: ComponentDirective, isStandalone: true, selector: "[mngComponent]", inputs: { component: ["mngComponent", "component"], componentIt: ["injectionToken", "componentIt"], inputs: "inputs", attachToHost: "attachToHost", nodeInjector: "nodeInjector" }, outputs: { componentInstanceEventEmitter: "instanceCreated" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ComponentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[mngComponent]'
+                }]
+        }], propDecorators: { component: [{
+                type: Input,
+                args: [{ alias: 'mngComponent' }]
+            }], componentIt: [{
+                type: Input,
+                args: [{ alias: 'injectionToken' }]
+            }], inputs: [{
+                type: Input
+            }], attachToHost: [{
+                type: Input
+            }], nodeInjector: [{
+                type: Input
+            }], componentInstanceEventEmitter: [{
+                type: Output,
+                args: ['instanceCreated']
+            }] } });
+
+class TemplateDirective {
+    constructor() {
+        this.template = inject((TemplateRef));
+        this.viewContainerRef = inject(ViewContainerRef);
+    }
+    getType() {
+        return this.name;
+    }
+    getViewContainerRef() {
+        return this.viewContainerRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.2", type: TemplateDirective, isStandalone: true, selector: "[mngTemplate]", inputs: { type: "type", name: ["mngTemplate", "name"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[mngTemplate]'
+                }]
+        }], propDecorators: { type: [{
+                type: Input
+            }], name: [{
+                type: Input,
+                args: [{ required: true, alias: 'mngTemplate' }]
+            }] } });
+
+/**
+ * Returns array of names for constants in enum.
+ * @param enumType Enum object.
+ */
+function getEnumConstantNames(enumType) {
+    return getEnumConstantNamesFromObject(enumType);
+}
+/**
+ * Returns array of names for constants in enum.
+ * @param enumObj Enum object.
+ */
+function getEnumConstantNamesFromObject(enumObj) {
+    // in number enum, the numbers are also represented in objects and should be filtered out
+    return Object.keys(enumObj).filter(v => isNaN(+v));
+}
+/**
+ * Returns array of string values for constants in enum.
+ * @param enumType Enum object.
+ */
+function getEnumConstantValuesAsString(enumType) {
+    return Object.keys(enumType).map(v => enumType[v]);
+}
+/**
+ * Returns array of number values for constants in enum.
+ * @param enumType Enum object.
+ */
+function getEnumConstantValuesAsNumber(enumType) {
+    return Object.keys(enumType)
+        .filter(v => !isNaN(+v))
+        .map(v => +v);
+}
+/**
+ * Returns array of type EnumValue for all constants in enum.
+ * @param enumType Enum object.
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+function fromEnumConstantsAsValueArray(enumType, nameAsValue = false, titlePath) {
+    return getEnumConstantNames(enumType).map(n => ({ name: n, title: `${titlePath ? `${titlePath}.` : ''}${n}`, value: nameAsValue ? n : enumType[n] }));
+}
+/**
+ * Returns array of type EnumValue for provided values in enum.
+ * @param enumType Enum object.
+ * @param values Enum values (constants).
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+function fromEnumValuesAsValueArray(enumType, values, nameAsValue = false, titlePath) {
+    return values.map(v => {
+        const k = getEnumConstantName(enumType, v);
+        return { name: k, title: `${titlePath ? `${titlePath}.` : ''}${k}`, value: nameAsValue ? k : v };
+    });
+}
+/**
+ * Gets constant name for value.
+ * @param enumType Enum object.
+ * @param value Value of enum constant.
+ */
+function getEnumConstantName(enumType, value) {
+    if (typeof value === 'string') {
+        return getEnumConstantNames(enumType).find(c => enumType[c] === value) ?? null;
+    }
+    else {
+        return typeof enumType[value] !== 'undefined' ? enumType[value] : null;
+    }
+}
+/**
+ * Gets constant name for value.
+ * @param enumObj Enum object.
+ * @param value Value of enum constant.
+ */
+function getEnumConstantNameFromObject(enumObj, value) {
+    const enumObjAny = enumObj;
+    if (typeof value === 'string') {
+        return getEnumConstantNamesFromObject(enumObj).find(c => enumObjAny[c] === value) ?? null;
+    }
+    else {
+        return typeof enumObjAny[value] !== 'undefined' ? enumObjAny[value] : null;
+    }
+}
+
+function objectDeepCopy(obj, options) {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(+obj);
+    }
+    let copy;
+    if (options?.mapGettersToProperties) {
+        copy = {};
+    }
+    else {
+        copy = options?.objectPrototype ? Object.create(options.objectPrototype['prototype']) : Object.create(Object.getPrototypeOf(obj));
+        Object.assign(copy, obj);
+    }
+    for (const key of getObjectProperties(obj)) {
+        const prop = obj[key];
+        copy[key] = handleProp(prop, { mapGettersToProperties: options?.mapGettersToProperties });
+    }
+    if (options?.mapGettersToProperties) {
+        for (const getterKey of getObjectGetters(obj)) {
+            const prop = obj[getterKey];
+            copy[getterKey] = handleProp(prop, { mapGettersToProperties: options?.mapGettersToProperties });
+        }
+    }
+    return copy;
+}
+function objectDeepMerge(target, source) {
+    if (!isObject(source)) {
+        return target;
+    }
+    for (const key of getObjectProperties(source)) {
+        if (isObject(source[key])) {
+            if (isObject(target[key])) {
+                target[key] = objectDeepMerge(target[key], source[key]);
+            }
+            else {
+                target[key] = objectDeepCopy(source[key]);
+            }
+        }
+        else if (Array.isArray(source[key])) {
+            if (!Array.isArray(target[key])) {
+                target[key] = source[key].map(i => (isObject(i) ? objectDeepMerge({}, i) : i));
+            }
+        }
+        else if (typeof target[key] === 'undefined') {
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function isObject(obj) {
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+}
+function handleProp(prop, options) {
+    if (Array.isArray(prop)) {
+        return prop.map(i => objectDeepCopy(i, options));
+    }
+    else if (typeof prop === 'object' && prop !== null) {
+        return objectDeepCopy(prop, options);
+    }
+    else {
+        return prop;
+    }
+}
+function getObjectProperties(obj) {
+    return Object.keys(obj);
+}
+function getObjectGetters(obj) {
+    const getterSet = new Set();
+    let currObj = obj;
+    while (currObj) {
+        const getters = Object.entries(Object.getOwnPropertyDescriptors(currObj))
+            .filter(([, descriptor]) => typeof descriptor.get === 'function')
+            .filter(([key]) => key !== '__proto__')
+            .map(([key]) => key);
+        for (const getter of getters) {
+            getterSet.add(getter);
+        }
+        currObj = Object.getPrototypeOf(currObj);
+    }
+    return Array.from(getterSet);
+}
+function getObjectPropertyByPath(value, path) {
+    if (path === '$') {
+        // only return the root
+        return value;
+    }
+    // Check for leading root object notation
+    if (path.startsWith('$')) {
+        path = path.substring(1);
+    }
+    // Check for leading .
+    if (path.startsWith('.')) {
+        path = path.substring(1);
+    }
+    if (path.indexOf('.') >= 0) {
+        const pathSplit = path.split('.');
+        let currValue = value;
+        for (const p of pathSplit) {
+            if (typeof currValue === 'undefined' || currValue === null) {
+                return currValue;
+            }
+            if (!p.length) {
+                // empty path, return current value
+                return currValue;
+            }
+            const leftBracketIdx = p.indexOf('[');
+            if (leftBracketIdx >= 0 && p.endsWith(']')) {
+                // should be reference to array
+                const arrayPath = p.substring(0, leftBracketIdx);
+                const arrayIdx = +p.substring(leftBracketIdx + 1, p.length - 1);
+                const array = currValue[arrayPath];
+                if (Array.isArray(array)) {
+                    if (arrayIdx >= 0 && arrayIdx < array.length) {
+                        // valid index, continue on the path
+                        currValue = array[arrayIdx];
+                        continue;
+                    }
+                }
+                return undefined;
+            }
+            else if (typeof currValue === 'object') {
+                currValue = currValue[p];
+            }
+        }
+        return currValue;
+    }
+    else {
+        return value[path];
+    }
+}
+function flattenObjectKeys(objectModel) {
+    const flatten = (object, parent) => {
+        let results = [];
+        for (const key in object) {
+            const value = object[key];
+            const thisKey = parent ? `${parent}.${key}` : `${key}`;
+            results = results.concat(isObject(value) ? flatten(value, thisKey) : [[`${thisKey}`, value]]);
+        }
+        return results;
+    };
+    return flatten(objectModel);
+}
+
+function escapeHtml(value) {
+    return value.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function escapeHtmlAny(value) {
+    if (typeof value === 'string') {
+        return escapeHtml(value);
+    }
+    else if (typeof value === 'object') {
+        const escapedValue = objectDeepCopy(value, { mapGettersToProperties: true });
+        for (const key in value) {
+            if (typeof value[key] === 'string') {
+                escapedValue[key] = escapeHtml(value[key]);
+            }
+            else if (typeof value[key] === 'object') {
+                escapedValue[key] = escapeHtmlAny(value[key]);
+            }
+            else {
+                escapedValue[key] = value[key];
+            }
+        }
+        return escapedValue;
+    }
+    return value;
+}
+/**
+ * Stringifies a value - primitives with toString, dates with dateUtil, objects with JSON.stringify.
+ * @param value Any value.
+ */
+function stringify(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'undefined') {
+        return 'undefined';
+    }
+    // eliminate functions, cause they could fall into objects
+    if (typeof value === 'function') {
+        return `Function ${value.name ?? 'anonymous'}()`;
+    }
+    if (typeof value === 'object') {
+        // date is object, but would like it in ISO string representation
+        if (value instanceof Date) {
+            return dateToIsoString(value) ?? 'null';
+        }
+        try {
+            return JSON.stringify(value);
+        }
+        catch (e) {
+            return value.toString();
+        }
+    }
+    // only primitives should be left to be printed like this (string, number, boolean)
+    return value.toString();
+}
+
+/**
+ * Converts RxJS subscription error to CommonsError.
+ * @param error Error.
+ * @param name Optional name to write in commons error.
+ * @param details Optional details of error.
+ */
+function fromSubscribeError(error, name, details) {
+    const opts = {
+        name,
+        details,
+        location: window?.location?.href
+    };
+    if (error instanceof HttpErrorResponse) {
+        return new CommonsHttpError(error.message ?? 'Http Error occurred', error, opts);
+    }
+    else {
+        opts.cause = error;
+        return new CommonsInternalError(error.message ?? 'Internal Error occurred', opts);
+    }
+}
+/**
+ * Checks if error is Http error (Angular or Commons).
+ * @param error
+ */
+function isHttpErrorResponse(error) {
+    return error instanceof HttpErrorResponse || error instanceof CommonsHttpError || error?.httpError instanceof HttpErrorResponse;
+}
+/**
+ * Gets HttpErrorResponse from error (Angular or Commons).
+ * @param error Error.
+ */
+function getHttpErrorResponse(error) {
+    if (error instanceof HttpErrorResponse) {
+        return error;
+    }
+    else if (error instanceof CommonsHttpError) {
+        return error.httpError;
+    }
+    else if (error?.httpError instanceof HttpErrorResponse) {
+        return error.httpError;
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Gets HttpErrorResponse status from error (Angular or Commons).
+ * @param error Error.
+ */
+function getHttpErrorResponseStatus(error) {
+    return getHttpErrorResponse(error)?.status ?? null;
+}
+/**
+ * Get error log level. All is error, except if error is http error with status >=400 and <500.
+ * @param error Error.
+ */
+function getErrorLogLevel(error) {
+    if (isHttpErrorResponse(error)) {
+        const status = getHttpErrorResponseStatus(error);
+        if (status && status >= 400 && status < 500) {
+            return LogLevelEnum.Warning;
+        }
+    }
+    return LogLevelEnum.Error;
+}
+/**
+ * Get error name (prototype name or type from commons error if name is not provided).
+ * @param error Error.
+ */
+function getErrorName(error) {
+    if (error instanceof ACommonsErrorBase) {
+        return error.name ?? error.type;
+    }
+    else {
+        return error.name;
+    }
+}
+/**
+ * Writes http error to string with all headers and body.
+ * @param error Http response error.
+ * @param opts Options for hiding parts of error:
+ *  - hideMessage Hides message of error (message include url, status and status text!).
+ *  - hideHeaders Hides headers.
+ *  - hideBody Hides JSON representation of body.
+ */
+function httpErrorResponseToString(error, opts) {
+    let str = opts?.hideMessage ? '' : `${error.message}\n`; // message should already include url, status, etc.
+    if (!opts?.hideHeaders) {
+        str += `Http Response Headers: ${error.headers.keys().reduce((acc, key) => `${acc}[${key}: ${error.headers.get(key)}]`, '')}`;
+    }
+    if (!opts?.hideBody) {
+        str += `\nHttp Response Body: ${stringify(error.error)}`;
+    }
+    return str;
+}
+/**
+ * Error to string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ */
+function errorToString(error, opts) {
+    if (error instanceof ACommonsErrorBase) {
+        return commonsErrorToString(error, opts);
+    }
+    else if (error instanceof HttpErrorResponse) {
+        return httpErrorResponseToString(error, opts);
+    }
+    const strBlocks = [];
+    if (!opts?.hideMessage) {
+        strBlocks.push(error.message);
+    }
+    if (error.name) {
+        strBlocks.push(`Error name: ${error.name}`);
+    }
+    if (!opts?.hideCause) {
+        strBlocks.push(errorCauseToString(error, opts));
+    }
+    if (!opts?.hideStack && error.stack) {
+        strBlocks.push(`Stack trace:\n${error.stack}`);
+    }
+    return strBlocks.filter(s => s.trim().length > 0).join('\n');
+}
+/**
+ * Commons error to string.
+ * @param error Commons error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ * - hideItems Hides all item information (http body, action context data).
+ * - hideActionData See @link(commonsActionErrorContextToString) for additional info.
+ * - hideQueryParams See @link(commonsActionErrorContextToString) for additional info.
+ */
+function commonsErrorToString(error, opts) {
+    const strBlocks = [];
+    if (!opts?.hideMessage) {
+        strBlocks.push(`${error.message}${error.messageCode ? ` (code: ${error.messageCode})` : ''}`);
+    }
+    if (!opts?.hideName) {
+        strBlocks.push(`Error name: ${error.name ?? error.type} ${error.name ? `(${error.type})` : ''}`);
+    }
+    if (!opts?.hideLocation && error.location) {
+        strBlocks.push(`Location: ${error.location}`);
+    }
+    let isHttp = false;
+    if (!opts?.hideHttp && error instanceof CommonsHttpError) {
+        strBlocks.push(httpErrorResponseToString(error.httpError, {
+            hideBody: opts?.hideItems || opts?.hideBody,
+            hideHeaders: opts?.hideHeaders,
+            hideMessage: error.message.indexOf(error.httpError.message) >= 0
+        }));
+        isHttp = true;
+    }
+    if (error.type === 'CommonsActionError') {
+        const actionError = error;
+        if (actionError.actionContext) {
+            strBlocks.push(commonsActionErrorContextToString(actionError, opts));
+        }
+        if (!opts?.hideHttp && actionError.httpError instanceof HttpErrorResponse) {
+            strBlocks.push(httpErrorResponseToString(actionError.httpError, {
+                hideBody: opts?.hideItems || opts?.hideBody,
+                hideHeaders: opts?.hideHeaders,
+                hideMessage: error.message.indexOf(actionError.httpError.message) >= 0
+            }));
+            isHttp = true;
+        }
+    }
+    if (!opts?.hideDetails && error.details) {
+        strBlocks.push(`Details: ${stringify(error.details)}`);
+    }
+    if (!opts?.hideCause && (!isHttp || !(error.cause instanceof HttpErrorResponse))) {
+        strBlocks.push(errorCauseToString(error, opts));
+    }
+    if (!opts?.hideStack && error.stack) {
+        strBlocks.push(`Stack trace:\n${error.stack}`);
+    }
+    return strBlocks.filter(s => s.trim().length > 0).join('\n');
+}
+/**
+ * Writes commons action error info from context as string.
+ * @param error Commons action error.
+ * @param opts Options for hiding parts of error:
+ * - hideItems Hides all item related information (item, form item, submit item, ...).
+ * - hideActionData Hides action data.
+ * - hideQueryParams Hides query params.
+ */
+function commonsActionErrorContextToString(error, opts) {
+    let paramsMessage = '';
+    if (error.actionContext?.parameters) {
+        if (error.actionContext?.parameters.itemId) {
+            paramsMessage += `[itemId: ${error.actionContext.parameters.itemId}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.item) {
+            paramsMessage += `[item: ${stringify(error.actionContext.parameters.item)}]`;
+        }
+        if (!opts?.hideActionData && error.actionContext?.parameters.actionData) {
+            paramsMessage += Object.entries(error.actionContext?.parameters.actionData).reduce((acc, [key, value]) => `${acc}[actionData ${key}: ${stringify(value)}]`, '');
+        }
+        if (!opts?.hideQueryParams && error.actionContext?.parameters.dataListParams) {
+            paramsMessage += `[dataListParams: ${stringify(error.actionContext.parameters.dataListParams)}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.formItem) {
+            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.formItem)}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.submitResult) {
+            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.submitResult)}]`;
+        }
+        if (error.actionContext?.parameters.locale) {
+            paramsMessage += `[locale: ${stringify(error.actionContext.parameters.locale)}]`;
+        }
+    }
+    return paramsMessage;
+}
+/**
+ * Writes cause of an error as string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - causeOnErrorOnly Prints only if cause is instance of error.
+ * - causeAsJson Print error cause as a JSON (by default, if error only message and name will be printed).
+ */
+function errorCauseToString(error, opts) {
+    // if already logged as http error, check that cause is not also http error (cause it is usually duplicated)
+    if (error.cause && (!opts?.causeOnErrorOnly || error.cause instanceof Error)) {
+        const needsStringify = opts?.causeAsJson || !(error.cause instanceof Error);
+        if (!opts?.causeOnErrorOnly || error.cause instanceof Error) {
+            return ('Caused by: ' +
+                (needsStringify ? stringify(error.cause) : `${error.cause.message}${error.cause.name ? ` (${error.cause.name})` : ''}`));
+        }
+    }
+    return '';
+}
+
+class CommonsErrorHandler {
+    constructor() {
+        this.logger = LoggerService.get();
+    }
+    static { this.logCategory = 'ErrorHandler'; }
+    handleError(error) {
+        if (error instanceof ACommonsErrorBase || error instanceof HttpErrorResponse) {
+            const logLevel = getErrorLogLevel(error);
+            this.logger.log(error, logLevel);
+        }
+        else {
+            this.logger.error('Unexpected error occurred', error);
+        }
+    }
+}
+
+function boolean$Attribute(value) {
+    return isObservable(value) ? value : of(booleanAttribute(value));
+}
+function number$Attribute(value) {
+    return isObservable(value) ? value : of(numberAttribute(value));
+}
+const toObservable = (value) => {
+    return isObservable(value) ? value : of(value);
+};
+const itemIdToNumber = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    else if (typeof value === 'string') {
+        const num = +value;
+        if (!isNaN(num)) {
+            return num;
+        }
+        throw new CommonsInternalError(`ItemId is a string, but could not be transformed to number: ${value}`);
+    }
+    else {
+        throw new CommonsInternalError(`ItemId is not a number: ${value}`);
+    }
+};
+const itemIdToString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else {
+        throw new CommonsInternalError(`ItemId is not a string: ${value}`);
+    }
+};
+const itemIdToDefined = (value) => {
+    if (typeof value === 'undefined') {
+        throw new CommonsInternalError(`ItemId is not defined: ${value}`);
+    }
+    else {
+        return value;
+    }
+};
+const valueToDefined = (value) => {
+    if (typeof value === 'undefined' || value === null) {
+        throw new CommonsInternalError(`Value is null or not defined: ${value}`);
+    }
+    else {
+        return value;
+    }
+};
+
+function toastMessage(messageService, title, message, severity = 'success', icon) {
+    const notification = { severity: severity, summary: title, detail: message, life: severity === 'error' ? 10000 : 5000, icon: icon };
+    messageService.add(notification);
+    return notification;
+}
+
+function removeRouteEmptyPathSegments(path) {
+    const filteredPath = path.filter(ps => typeof ps === 'string' && ps.length > 0);
+    return filteredPath.length > 0 ? filteredPath : [''];
+}
+function appendRoutePathToBasePath(basePath, path) {
+    if (path.length > 0) {
+        if (path[0].startsWith('/')) {
+            return path;
+        }
+        else if (path[0].startsWith('../')) {
+            throw new CommonsInternalError('Not implemented', { name: 'RouteUtilsError' });
+        }
+        else {
+            return removeRouteEmptyPathSegments([...basePath, ...path]);
+        }
+    }
+    else {
+        return basePath;
+    }
+}
+function doesUrlMatchRouterLink(link, url) {
+    if (typeof url === 'string' && url.startsWith('/')) {
+        url = url.substring(1);
+    }
+    else if (Array.isArray(url) && url.length > 0 && url[0].startsWith('/')) {
+        url[0] = url[0].substring(1);
+    }
+    const routeSegments = Array.isArray(link) ? link : link.split('/');
+    const urlSegments = Array.isArray(url) ? url : url.split('#')[0].split('?')[0].split('/');
+    if (routeSegments.length > 0 && urlSegments.length > 0) {
+        for (let i = 0; i < routeSegments.length; i++) {
+            if (i < urlSegments.length) {
+                if (routeSegments[i] !== urlSegments[i]) {
+                    return false;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function adjustRouteMenuLazyChildrenRouterLinks(rootMenuItem, lazyChildren) {
+    return lazyChildren.map(i => {
+        const childMenuItem = { ...i };
+        if (childMenuItem.routerLink) {
+            childMenuItem.routerLink = appendRoutePathToBasePath(rootMenuItem.routerLink, typeof childMenuItem.routerLink === 'string' ? [childMenuItem.routerLink] : childMenuItem.routerLink);
+        }
+        if (Array.isArray(childMenuItem.items)) {
+            childMenuItem.items = adjustRouteMenuLazyChildrenRouterLinks(rootMenuItem, childMenuItem.items);
+        }
+        return childMenuItem;
+    });
+}
+
+function findTemplateByName(templates, name) {
+    return templates.find(t => t.getType() === name)?.template ?? null;
+}
+
+function getI18nAsync(translate, params, ...keys) {
+    return translate.stream(keys, params).pipe(map(i18n => selectI18n(keys, i18n)));
+}
+function getI18n(translate, params, ...keys) {
+    const i18n = translate.instant(keys, params);
+    return selectI18n(keys, i18n);
+}
+function populateI18nParams(item, params = {}) {
+    const paramsRes = { ...params };
+    if (item) {
+        paramsRes.item = item;
+    }
+    return paramsRes;
+}
+function selectI18n(keys, i18n) {
+    for (const key of keys) {
+        if (key !== i18n[key]) {
+            return i18n[key];
+        }
+    }
+    return null;
+}
+
+function getI18nForError(translate, error, params = {}) {
+    const i18nParams = getI18nErrorParams(error, params);
+    if (error.messageCode) {
+        const keys = [`errors.${error.messageCode}`, `messages.${error.messageCode}`];
+        const i18n = getI18n(translate, i18nParams, ...keys);
+        if (i18n) {
+            return i18n;
+        }
+    }
+    return getI18n(translate, i18nParams, error.message);
+}
+function getI18nErrorParams(error, params = {}) {
+    const paramsRes = { ...params };
+    paramsRes.errorStatus = '';
+    paramsRes.errorMessage = '';
+    if (isHttpErrorResponse(error)) {
+        const httpError = getHttpErrorResponse(error);
+        paramsRes.errorStatus = httpError?.status;
+        paramsRes.errorMessage = httpError?.message;
+        paramsRes.errorStatusDescription = httpError?.statusText;
+    }
+    paramsRes.error = error;
+    return paramsRes;
+}
+
+const reflectTypeNameKey = 'typeName';
+const reflectEnumNameKey = 'enumName';
+/**
+ * Defines type name decorator.
+ * @param targetType class.
+ * @param typeName Name of the type.
+ */
+function defineReflectTypeName(targetType, typeName) {
+    if (!Reflect.hasOwnMetadata(reflectTypeNameKey, targetType)) {
+        Reflect.defineMetadata(reflectTypeNameKey, typeName, targetType);
+    }
+}
+/**
+ * Defines enum name decorator.
+ * @param targetType enum object.
+ * @param enumName Name of the enum.
+ */
+function defineReflectEnumName(targetType, enumName) {
+    if (!Reflect.hasOwnMetadata(reflectEnumNameKey, targetType)) {
+        Reflect.defineMetadata(reflectEnumNameKey, enumName, targetType);
+    }
+}
+/**
+ * Gets type name from reflect metadata.
+ * @param type Class.
+ */
+function findReflectTypeName(type) {
+    if (!type) {
+        return null;
+    }
+    const typeName = Reflect.getMetadata(reflectTypeNameKey, type);
+    if (typeName) {
+        return typeName;
+    }
+    LoggerService.get().debug('WARNING: Reflect metadata could not be found for type, you might experience some issues in production build.', type?.name);
+    return type.name;
+}
+/**
+ * Gets type name from either decorator or reflect metadata.
+ * @param type Class.
+ */
+function reflectTypeNameExists(type) {
+    return Reflect.hasOwnMetadata(reflectTypeNameKey, type);
+}
+/**
+ * Gets enum name from either decorator or reflect metadata.
+ * @param enumType Class.
+ */
+function findReflectEnumName(enumType) {
+    const enumName = Reflect.getMetadata(reflectEnumNameKey, enumType);
+    if (enumName) {
+        return enumName;
+    }
+    LoggerService.get().debug(`WARNING: Reflect metadata could not be found for enum ${typeof enumType === 'object' ? Object.keys(enumType) : enumType}`, {
+        name: 'TypeUtilsError',
+        enumType: enumType
+    });
+    return null;
+}
+
+function getI18nClassNameAsync(translate, classType, singular) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeNameAsync(translate, typeName ?? '', singular);
+}
+function getI18nClassName(translate, classType, singular) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeName(translate, typeName ?? '', singular);
+}
+function getI18nTypeNameAsync(translate, typeName, singular) {
+    const keys = getI18nTypeNameKeys(typeName, singular);
+    return getI18nAsync(translate, undefined, ...keys);
+}
+function getI18nTypeName(translate, typeName, singular) {
+    const keys = getI18nTypeNameKeys(typeName, singular);
+    return getI18n(translate, undefined, ...keys);
+}
+function getI18nClassTabKey(classType, tab) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeTabKey(typeName ?? '', tab);
+}
+function getI18nTypeTabKey(typeName, tab) {
+    return getI18nTypeKeyBasePath(typeName, 'tabs', tab);
+}
+function getI18nClassGroupKey(classType, group) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeGroupKey(typeName ?? '', group);
+}
+function getI18nTypeGroupKey(typeName, group) {
+    return getI18nTypeKeyBasePath(typeName, 'groups', group);
+}
+function getI18nClassPropertyKey(classType, property) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypePropertyKey(typeName ?? '', property);
+}
+function getI18nTypePropertyKey(typeName, property) {
+    return getI18nTypeKeyBasePath(typeName, 'properties', property);
+}
+function getI18nClassKeyBasePath(classType, ...path) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeKeyBasePath(typeName ?? '', ...path);
+}
+function getI18nTypeKeyBasePath(typeName, ...path) {
+    return `${typeName.length ? `${typeName}.` : ''}${path.join('.')}`;
+}
+function getI18nClassParams(translate, classType, item, params = {}) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeParams(translate, typeName ?? undefined, item, params);
+}
+function getI18nTypeParams(translate, typeName, item, params = {}) {
+    const i18nTypeName = typeName ? getI18nTypeName(translate, typeName, true) : null;
+    return populateI18nTypeParams(i18nTypeName ?? undefined, item, params);
+}
+function getI18nClassParamsAsync(translate, classType, item, params = {}) {
+    const typeName = findReflectTypeName(classType);
+    return getI18nTypeParamsAsync(translate, typeName ?? undefined, item, params);
+}
+function getI18nTypeParamsAsync(translate, typeName, item, params = {}) {
+    return (typeName ? getI18nTypeNameAsync(translate, typeName, true) : of(null)).pipe(map(i18nTypeName => populateI18nTypeParams(i18nTypeName ?? undefined, item, params)));
+}
+function populateI18nTypeParams(i18nTypeName, item, params = {}) {
+    const paramsRes = { ...params };
+    if (i18nTypeName) {
+        paramsRes.typeName = i18nTypeName;
+    }
+    return populateI18nParams(item, paramsRes);
+}
+function getI18nTypeNameKeys(typeName, singular) {
+    const keys = [];
+    if (typeof singular !== 'undefined') {
+        keys.push(singular ? `${typeName}.nameSingular` : `${typeName}.namePlural`);
+    }
+    keys.push(`${typeName.length ? `${typeName}.` : ''}name`);
+    return keys;
+}
+
+/* eslint-disable no-console */
+class LogPublisherConsoleService {
+    addEntry(entry) {
+        let prefix = `${entry.timestampFormatted}`;
+        if (entry.category)
+            prefix += ` [${entry.category}]`;
+        prefix += ':';
+        const message = `${entry.message}${entry.messageDetails ? `\n${entry.messageDetails}` : ''}`;
+        const logParams = [prefix, message];
+        if (entry.error) {
+            logParams.push(`\n${getErrorName(entry.error)}:`, entry.error);
+        }
+        if (entry.data?.length) {
+            logParams.push(`\nData:\n`, ...entry.data);
+        }
+        switch (entry.level) {
+            case LogLevelEnum.Trace:
+                console.trace(...logParams);
+                break;
+            case LogLevelEnum.Debug:
+                console.debug(...logParams);
+                break;
+            case LogLevelEnum.Log:
+                console.log(...logParams);
+                break;
+            case LogLevelEnum.Info:
+                console.info(...logParams);
+                break;
+            case LogLevelEnum.Warning:
+                console.warn(...logParams);
+                break;
+            case LogLevelEnum.Error:
+                console.error(...logParams);
+                break;
+        }
+    }
+}
+
+class BooleanPipe {
+    transform(value, yes, no, icon = false) {
+        if (typeof value === 'boolean') {
+            if (icon) {
+                return value ? yes ?? 'pi pi-check' : no ?? 'pi pi-times';
+            }
+            else {
+                return value ? yes ?? 'general.yes' : no ?? 'general.no';
+            }
+        }
+        else {
+            return value;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BooleanPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: BooleanPipe, isStandalone: true, name: "mngBoolean" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BooleanPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngBoolean',
+                    pure: true
+                }]
+        }] });
+
+class ClassMapPipe {
+    transform(className, classNameMapFn, item) {
+        if (classNameMapFn && typeof classNameMapFn === 'function') {
+            return classNameMapFn(className, item);
+        }
+        else {
+            return className ?? '';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ClassMapPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ClassMapPipe, isStandalone: true, name: "mngClassMap" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ClassMapPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngClassMap',
+                    pure: true
+                }]
+        }] });
+
+class EnumPipe {
+    transform(value, enumDesc, i18nPath) {
+        if (!value || (typeof value !== 'number' && typeof value !== 'string')) {
+            return value;
+        }
+        const enumConstantName = !enumDesc || enumDesc.nameAsValue ? value : getEnumConstantNameFromObject(enumDesc.type, value) ?? value;
+        if (typeof i18nPath === 'undefined' && enumDesc) {
+            i18nPath = enumDesc.i18nBaseKey === undefined ? findReflectEnumName(enumDesc.type) : null;
+        }
+        return i18nPath ? `${i18nPath}.${enumConstantName}` : enumConstantName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: EnumPipe, isStandalone: true, name: "mngEnum" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngEnum',
+                    pure: true
+                }]
+        }] });
+
+/**
+ * Imitation of JSONPath Syntax. Supports:
+ *  - Root object notation with '$'
+ *  - Dot notation (e.g.: $.foo.bar), no bracket notation for properties
+ *  - Array notation (e.g.: [0])
+ */
+class JsonPathPipe {
+    transform(value, path = '') {
+        return getObjectPropertyByPath(value, path);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: JsonPathPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: JsonPathPipe, isStandalone: true, name: "mngJsonPath" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: JsonPathPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngJsonPath',
+                    pure: true
+                }]
+        }] });
+
+class EnumeratePipe {
+    constructor() {
+        this.translate = inject(TranslateService);
+    }
+    transform(value, jsonPath = '$', valueSeparator = ', ', emptyValueReturn = '/', i18nBaseKey = '') {
+        if (!value) {
+            return emptyValueReturn;
+        }
+        i18nBaseKey = getEnumerationI18nBaseKey(i18nBaseKey);
+        return Array.from(value)
+            .map(i => {
+            const itemEnumerate = toEnumerationI18nEnumerate(i, jsonPath, i18nBaseKey);
+            itemEnumerate.i18n = this.translate.instant(itemEnumerate.i18nKey);
+            // return i18n only if used and transl. was found
+            return selectEnumerationI18n(itemEnumerate, i18nBaseKey);
+        })
+            .join(valueSeparator);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumeratePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: EnumeratePipe, isStandalone: true, name: "mngEnumerate" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumeratePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngEnumerate',
+                    pure: true
+                }]
+        }] });
+function getEnumerationI18nBaseKey(baseKey) {
+    return baseKey.endsWith('.') ? baseKey?.substring(0, baseKey.length - 1) : baseKey;
+}
+function selectEnumerationI18n(value, baseKey) {
+    return baseKey && value.i18nKey === value.i18n ? value.value : value.i18n;
+}
+function toEnumerationI18nEnumerate(value, jsonPath, baseKey) {
+    const valueTrans = new JsonPathPipe().transform(value, jsonPath);
+    const valueAsString = valueTrans.toString();
+    return {
+        value: valueAsString,
+        i18nKey: baseKey ? `${baseKey}.${valueAsString}` : valueAsString,
+        i18n: valueAsString
+    };
+}
+
+class EnumerateAsyncPipe {
+    constructor() {
+        this.translate = inject(TranslateService);
+    }
+    transform(value, jsonPath = '$', valueSeparator = ', ', emptyValueReturn = '/', i18nBaseKey = '') {
+        i18nBaseKey = getEnumerationI18nBaseKey(i18nBaseKey);
+        return value.pipe(mergeMap(v => {
+            if (!v) {
+                return of([emptyValueReturn]);
+            }
+            return combineLatest(Array.from(v)
+                .map(ai => toEnumerationI18nEnumerate(ai, jsonPath, i18nBaseKey))
+                .map(i => this.translate.stream(i.i18nKey).pipe(map((i18n) => {
+                i.i18n = i18n;
+                return selectEnumerationI18n(i, i18nBaseKey);
+            }))));
+        }), map(i => i.join(valueSeparator)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumerateAsyncPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: EnumerateAsyncPipe, isStandalone: true, name: "mngEnumerateAsync" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: EnumerateAsyncPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngEnumerateAsync',
+                    pure: true
+                }]
+        }] });
+
+class GetterPipe {
+    transform(value, getterFn, item) {
+        if (typeof getterFn === 'function') {
+            return getterFn(item, value);
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: GetterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: GetterPipe, isStandalone: true, name: "mngGetter" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: GetterPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngGetter',
+                    pure: true
+                }]
+        }] });
+
+class I18nPropertyPipe {
+    transform(property, model) {
+        return getI18nTypePropertyKey(model.i18nBaseKey, property);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: I18nPropertyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: I18nPropertyPipe, isStandalone: true, name: "mngI18nProperty" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: I18nPropertyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngI18nProperty',
+                    pure: true
+                }]
+        }] });
+
+class ParametrizePipe {
+    constructor() {
+        this.jsonPath = new JsonPathPipe();
+    }
+    transform(value, itemId, item, data) {
+        let params = {};
+        if (data) {
+            params = {
+                ...params,
+                ...data
+            };
+        }
+        if (item) {
+            params = {
+                ...params,
+                item: escapeHtmlAny(item)
+            };
+        }
+        if (itemId) {
+            params = {
+                ...params,
+                itemId: itemId
+            };
+        }
+        if (typeof value === 'string') {
+            return this.transformString(value, params);
+        }
+        else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'string') {
+            return value.map((s) => this.transformString(s, params));
+        }
+        else if (typeof value === 'object') {
+            // process only first level citizens
+            const obj = { ...value };
+            for (const key in obj) {
+                const objProp = obj[key];
+                if (typeof objProp === 'string') {
+                    obj[key] = this.transformString(objProp, params);
+                }
+            }
+            return obj;
+        }
+        else {
+            return value;
+        }
+    }
+    transformString(s, params) {
+        if ((s.indexOf('/') >= 0 && s.indexOf(':') >= 0 && !s.startsWith('http://') && !s.startsWith('https://')) || s.startsWith(':')) {
+            // this is router link
+            return s
+                .split('/')
+                .map(s => this.parametrizeStringAsRouterLink(s, params))
+                .join('/');
+        }
+        else {
+            // parametrize normally
+            return this.parametrizeString(s, params);
+        }
+    }
+    parametrizeStringAsRouterLink(s, params) {
+        if (s.startsWith(':')) {
+            const itemProperty = s.substring(1);
+            return this.jsonPath.transform(params, itemProperty) ?? '';
+        }
+        else {
+            return s;
+        }
+    }
+    parametrizeString(s, params) {
+        return s.replace(/{{\s?([^{}\s]*)\s?}}/g, (subs, key) => this.jsonPath.transform(params, key) ?? subs);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParametrizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ParametrizePipe, isStandalone: true, name: "mngParametrize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParametrizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'mngParametrize',
+                    pure: true
+                }]
+        }] });
+
+class TemplatePipe {
+    constructor() {
+        this.parametrizePipe = new ParametrizePipe();
+    }
+    transform(value, template) {
+        if (typeof template === 'string') {
+            return this.parametrizePipe.transform(template, undefined, value);
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TemplatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: TemplatePipe, isStandalone: true, name: "template" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TemplatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'template',
+                    pure: true
+                }]
+        }] });
+
+function TypeName(typeName) {
+    return function (target) {
+        defineReflectTypeName(target, typeName);
+    };
+}
+function EnumName(typeName) {
+    return function (target) {
+        defineReflectEnumName(target, typeName);
+    };
+}
+
+class TypeRegistry {
+    constructor() {
+        this._logCategory = 'TypeRegistry';
+        this._typeMap = {};
+        this._enumMap = {};
+    }
+    static { this._instance = new TypeRegistry(); }
+    get typeMap() {
+        return this._typeMap;
+    }
+    get enumMap() {
+        return this._enumMap;
+    }
+    /**
+     * Only use one instance of object (out of Angular context)
+     */
+    static get() {
+        return TypeRegistry._instance;
+    }
+    findAttributeDefinitionByClassType(type, attributeName) {
+        const typeName = findReflectTypeName(type);
+        return typeName ? this.findAttributeDefinition(typeName, attributeName) : null;
+    }
+    findAttributeDefinition(typeName, attributeName) {
+        const attributeDefs = this.findAttributesDefinition(typeName);
+        if (!attributeDefs) {
+            return null;
+        }
+        for (const attribute of attributeDefs) {
+            if (attribute.name === attributeName) {
+                return attribute;
+            }
+        }
+        return null;
+    }
+    findAttributesDefinitionByClassType(type) {
+        const typeName = findReflectTypeName(type);
+        return typeName ? this.findAttributesDefinition(typeName) : null;
+    }
+    findAttributesDefinition(typeName) {
+        const typeDef = this.findType(typeName);
+        if (!typeDef || typeof typeDef.getAttributeTypeMap !== 'function') {
+            return null;
+        }
+        return typeDef.getAttributeTypeMap();
+    }
+    findByClassType(type) {
+        const typeName = findReflectTypeName(type);
+        return typeName ? this.findType(typeName) : null;
+    }
+    findType(typeName) {
+        return this._typeMap[typeName];
+    }
+    findEnum(enumName) {
+        return this._enumMap[enumName];
+    }
+    registerTypes(types) {
+        for (const key in types) {
+            this.registerType(types[key], key);
+        }
+    }
+    registerType(type, optTypeName) {
+        // try to find name from metadata
+        let typeName;
+        if (reflectTypeNameExists(type)) {
+            // defined name from optional type name
+            typeName = findReflectTypeName(type) ?? undefined;
+        }
+        else if (optTypeName) {
+            typeName = optTypeName;
+            // register metadata
+            defineReflectTypeName(type, typeName);
+        }
+        if (!typeName) {
+            // this._logger.debug(`WARNING: registering type ${type} failed, because typeName could not be determined and optional name was not provided.`);
+            LoggerService.get().log(`WARNING: registering type ${type} failed, because typeName could not be determined and optional name was not provided.`, LogLevelEnum.Debug, this._logCategory);
+            return;
+        }
+        if (typeof this._typeMap[typeName] !== 'undefined') {
+            // this._logger.debug(`WARNING: registering type ${type} under key ${typeName} skipped, because type already exists for this key.`);
+            LoggerService.get().log(`WARNING: registering type ${type} under key ${typeName} skipped, because type already exists for this key.`, LogLevelEnum.Debug, this._logCategory);
+        }
+        else {
+            this._typeMap[typeName] = type;
+        }
+    }
+    registerEnums(enums) {
+        for (const key in enums) {
+            this.registerEnum(enums[key], key);
+        }
+    }
+    registerEnum(enumType, enumName) {
+        // try to find name from decorator
+        defineReflectEnumName(enumType, enumName);
+        if (typeof this._enumMap[enumName] !== 'undefined') {
+            LoggerService.get().log(`Registering enum ${enumName} skipped, because enum already exists.`, LogLevelEnum.Debug, this._logCategory);
+        }
+        else {
+            this._enumMap[enumName] = enumType;
+        }
+    }
+}
+
+var PermissionTypeEnum;
+(function (PermissionTypeEnum) {
+    PermissionTypeEnum["All"] = "ALL";
+    PermissionTypeEnum["Any"] = "ANY";
+    PermissionTypeEnum["Rbac"] = "ROLE_BASED_ACCESS_CONTROL";
+    PermissionTypeEnum["Service"] = "SERVICE";
+})(PermissionTypeEnum || (PermissionTypeEnum = {}));
+class APermissions {
+    constructor(type) {
+        this._authorizationType = type;
+    }
+    get authorizationType() {
+        return this._authorizationType;
+    }
+}
+var Permissions;
+(function (Permissions) {
+    class All extends APermissions {
+        constructor() {
+            super(PermissionTypeEnum.All);
+            this._permissions = [];
+        }
+        static of(...permissions) {
+            const inst = new All();
+            inst.and(...permissions);
+            return inst;
+        }
+        get permissions() {
+            return this._permissions;
+        }
+        and(...permissions) {
+            this._permissions.push(...permissions);
+            return this;
+        }
+    }
+    Permissions.All = All;
+    class Any extends APermissions {
+        constructor() {
+            super(PermissionTypeEnum.Any);
+            this._permissions = [];
+        }
+        static of(...permissions) {
+            const inst = new Any();
+            inst.or(...permissions);
+            return inst;
+        }
+        get permissions() {
+            return this._permissions;
+        }
+        or(...permissions) {
+            this._permissions.push(...permissions);
+            return this;
+        }
+    }
+    Permissions.Any = Any;
+    class Roles extends APermissions {
+        constructor() {
+            super(PermissionTypeEnum.Rbac);
+            this._roles = [];
+        }
+        static of(...roles) {
+            const inst = new Roles();
+            inst.or(...roles);
+            return inst;
+        }
+        get roles() {
+            return this._roles;
+        }
+        and(...roles) {
+            if (this._roles.length === 0) {
+                this._roles.push([]);
+            }
+            this._roles[this._roles.length - 1].push(...roles);
+            return this;
+        }
+        or(...roles) {
+            this._roles.push(...roles.map(s => [s]));
+            return this;
+        }
+    }
+    Permissions.Roles = Roles;
+    class Service extends APermissions {
+        constructor(service) {
+            super(PermissionTypeEnum.Service);
+            this.service = service;
+        }
+        static of(service) {
+            return new Service(service);
+        }
+    }
+    Permissions.Service = Service;
+})(Permissions || (Permissions = {}));
+
+function isPermitted(permissions, userRoles) {
+    switch (permissions.authorizationType) {
+        case PermissionTypeEnum.Rbac:
+            return isRbacPermitted(permissions, userRoles);
+        default:
+            throw new CommonsInternalError(`Permission type "${permissions.authorizationType}" not implemented`);
+    }
+}
+function isRbacPermitted(permissions, userRoles) {
+    return permissions.roles.some(prg => prg.every(pr => userRoles.indexOf(pr) > -1));
+}
+
+class PermissionService {
+    constructor() {
+        this.router = inject(Router);
+        this.injector = inject(Injector);
+        this.commons = inject(CommonsService);
+        this.logger = inject(LoggerService).create('AuthorizationService');
+    }
+    isPermitted(permissions, route, actionCtx) {
+        switch (permissions.authorizationType) {
+            case PermissionTypeEnum.All:
+                return this.isPermittedAll(permissions, route, actionCtx);
+            case PermissionTypeEnum.Any:
+                return this.isPermittedAny(permissions, route, actionCtx);
+            case PermissionTypeEnum.Service:
+                return this.isPermittedService(permissions, route, actionCtx);
+            default:
+                return this.commons.userRoles$.pipe(map(ur => isPermitted(permissions, ur)));
+        }
+    }
+    isPermittedAll(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.every(ip => ip === true)));
+    }
+    isPermittedAny(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.some(ip => ip === true)));
+    }
+    isPermittedService(permission, route, actionCtx) {
+        const serviceInstance = this.injector.get(permission.service);
+        if (!serviceInstance) {
+            this.logger.debug(`WARNING: Service instance could not be retreived for type ${permission.service}`);
+            return of(false);
+        }
+        return serviceInstance.isPermitted(route, this.router.routerState.snapshot, actionCtx);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PermissionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable
+        }] });
+
+const permissionGuard = (route) => {
+    const permission = inject(PermissionService);
+    const data = route.data;
+    if (data.permissions) {
+        return permission.isPermitted(data.permissions).pipe(first());
+    }
+    else {
+        return of(true);
+    }
+};
+
+class RouteBuilder {
+    constructor(route) {
+        this.routePath = [];
+        this.routeData = { breadcrumb: null };
+        this.children = [];
+        this.menuItemChildren = [];
+        this.menuItemChildrenAfter = []; // append after route children
+        this.route = route;
+        if (this.route.path && this.route.path.length > 0) {
+            this.routePath = [this.route.path];
+        }
+    }
+    static create(path, component) {
+        return new RouteBuilder({
+            path: path,
+            component: component
+        });
+    }
+    static createRedirect(path, redirectTo, pathMatch = 'prefix') {
+        return new RouteBuilder({
+            path: path,
+            redirectTo: redirectTo,
+            pathMatch: pathMatch
+        });
+    }
+    static createLazyRouteModule(path, loadChildren, canMatch) {
+        const route = { path: path, loadChildren: loadChildren };
+        if (canMatch?.length) {
+            route.canMatch = canMatch;
+        }
+        return new RouteBuilder(route);
+    }
+    static createLazyRouteComponent(path, loadComponent, canMatch) {
+        const route = { path: path, loadComponent: loadComponent };
+        if (canMatch?.length) {
+            route.canMatch = canMatch;
+        }
+        return new RouteBuilder(route);
+    }
+    static createFromRoute(route) {
+        return new RouteBuilder(route);
+    }
+    withRoot(routesBuilder) {
+        this.root = routesBuilder;
+        return this;
+    }
+    withParent(parent) {
+        this.parent = parent;
+        this.routePath = removeRouteEmptyPathSegments([...this.parent.routePath, this.route.path ?? '']);
+        return this;
+    }
+    withBreadcrumb(breadcrumb) {
+        this.breadcrumb = breadcrumb;
+        this.routeData.breadcrumb = breadcrumb;
+        return this;
+    }
+    withPageTitle(pageTitle) {
+        this.pageTitle = pageTitle;
+        this.routeData.pageTitle = pageTitle;
+        return this;
+    }
+    withRedirectTo(redirectTo) {
+        this.route.redirectTo = redirectTo;
+        return this;
+    }
+    withPathMatch(pathMatch) {
+        this.route.pathMatch = pathMatch;
+        return this;
+    }
+    withTitle(title) {
+        this.withPageTitle(title);
+        this.withBreadcrumb(title);
+        return this;
+    }
+    withCanActivate(diToken) {
+        if (!this.route.canActivate) {
+            this.route.canActivate = [];
+        }
+        this.route.canActivate.push(diToken);
+        return this;
+    }
+    withCanDeactivate(diToken) {
+        if (!this.route.canDeactivate) {
+            this.route.canDeactivate = [];
+        }
+        this.route.canDeactivate.push(diToken);
+        return this;
+    }
+    withResolver(diToken, name) {
+        if (!this.route.resolve) {
+            this.route.resolve = {};
+        }
+        this.route.resolve[name] = diToken;
+        return this;
+    }
+    withProvider(provider) {
+        if (!this.route.providers) {
+            this.route.providers = [];
+        }
+        this.route.providers.push(provider);
+        return this;
+    }
+    withData(data) {
+        if (!data.breadcrumb) {
+            data.breadcrumb = null;
+        }
+        this.routeData = data;
+        return this;
+    }
+    withCommonsMenuItem(menuItem) {
+        this.menuItem = menuItem;
+        return this;
+    }
+    withMenuItem(icon, label, routerLink, breadcrumb = false) {
+        this.menuItem = this.createMenuItem(icon, label, routerLink);
+        if (breadcrumb && label) {
+            this.withBreadcrumb({
+                label: label
+            });
+        }
+        return this;
+    }
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param label Label.
+     * @param icon Icon.
+     * @param routerLink Router link.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withMenuItemChild(label, icon, routerLink, afterRouteChildren = false) {
+        if (afterRouteChildren) {
+            this.menuItemChildrenAfter.push(this.createMenuItem(icon, label, routerLink));
+        }
+        else {
+            this.menuItemChildren.push(this.createMenuItem(icon, label, routerLink));
+        }
+        return this;
+    }
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param menuItem Configuration object for menu item.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withCommonsMenuItemChild(menuItem, afterRouteChildren = false) {
+        if (afterRouteChildren) {
+            this.menuItemChildrenAfter.push(menuItem);
+        }
+        else {
+            this.menuItemChildren.push(menuItem);
+        }
+        return this;
+    }
+    withMenuItemLazyChildren() {
+        if (!this.menuItem) {
+            this.menuItem = {};
+        }
+        this.menuItem.lazyChildren = true;
+        return this;
+    }
+    withPermissions(permissions) {
+        this.permissions = permissions;
+        this.withCanActivate(permissionGuard);
+        return this;
+    }
+    addChild(path, component, adjustFn) {
+        const childRouteBuilder = RouteBuilder.create(path, component);
+        adjustFn?.(childRouteBuilder);
+        return this.addChildBuilder(childRouteBuilder);
+    }
+    addChildBuilder(builder) {
+        builder.withParent(this);
+        if (this.root) {
+            builder.withRoot(this.root);
+        }
+        this.children.push(builder);
+        return this;
+    }
+    build() {
+        const angularRoute = {
+            ...this.route
+        };
+        if (angularRoute.data) {
+            angularRoute.data = {
+                ...angularRoute.data,
+                ...this.routeData
+            };
+        }
+        else {
+            angularRoute.data = { ...this.routeData };
+        }
+        // append permissions if not already in route data
+        if (this.permissions && !angularRoute.data.permissions) {
+            angularRoute.data.permissions = this.permissions;
+        }
+        const menu = this.buildMenu();
+        if (menu.length > 0) {
+            angularRoute.data.menuItems = menu;
+        }
+        if ((this.route.children?.length ?? 0) > 0 || this.children.length > 0) {
+            // route has children
+            angularRoute.children = [];
+            if (this.route.children?.length) {
+                angularRoute.children.push(...this.route.children);
+            }
+            if (this.children.length) {
+                for (const childRoute of this.children) {
+                    angularRoute.children.push(childRoute.build());
+                }
+            }
+        }
+        if (this.route.canActivate) {
+            angularRoute.canActivate = [...this.route.canActivate];
+        }
+        if (this.route.canActivateChild) {
+            angularRoute.canActivateChild = [...this.route.canActivateChild];
+        }
+        if (this.route.canLoad) {
+            angularRoute.canLoad = [...this.route.canLoad];
+        }
+        if (this.route.canDeactivate) {
+            angularRoute.canDeactivate = [...this.route.canDeactivate];
+        }
+        if (this.route.resolve) {
+            angularRoute.resolve = { ...this.route.resolve };
+        }
+        return angularRoute;
+    }
+    buildMenu() {
+        const menuItemBuild = this.menuItem ? { ...this.menuItem } : null;
+        const routeChildrenMenuItems = this.children.flatMap(child => child.buildMenu());
+        const menuItemChildren = [];
+        const menuItemChildrenBuild = [];
+        if (menuItemBuild?.items) {
+            menuItemChildrenBuild.push(...menuItemBuild.items);
+        }
+        const processMenuItemChild = (child) => {
+            const finalChild = { ...child };
+            if (typeof finalChild.routerLink === 'undefined') {
+                finalChild.routerLink = this.routePath;
+            }
+            if (typeof finalChild.routerLink === 'string') {
+                finalChild.routerLink = [finalChild.routerLink];
+            }
+            if (finalChild.routerLink) {
+                finalChild.routerLink = removeRouteEmptyPathSegments(finalChild.routerLink);
+            }
+            return finalChild;
+        };
+        this.menuItemChildren.forEach(child => menuItemChildren.push(processMenuItemChild(child)));
+        const menuItemChildrenAfterBuild = this.menuItemChildrenAfter.map(child => processMenuItemChild(child));
+        menuItemChildrenBuild.push(...menuItemChildren, ...routeChildrenMenuItems, ...menuItemChildrenAfterBuild);
+        if (!menuItemBuild) {
+            return menuItemChildrenBuild;
+        }
+        menuItemBuild.label = menuItemBuild.label ?? this.pageTitle;
+        if (typeof menuItemBuild.routerLink === 'string') {
+            menuItemBuild.routerLink = [menuItemBuild.routerLink];
+        }
+        menuItemBuild.routerLink = removeRouteEmptyPathSegments(menuItemBuild.routerLink ?? this.routePath);
+        if (menuItemChildrenBuild.length > 0) {
+            menuItemBuild.items = menuItemChildrenBuild;
+        }
+        if (!menuItemBuild.guards) {
+            const guards = this.findMenuItemGuards();
+            if (guards.length > 0) {
+                menuItemBuild.guards = guards;
+            }
+        }
+        if (!menuItemBuild.permissions) {
+            menuItemBuild.permissions = this.findMenuItemPermissions();
+        }
+        return [menuItemBuild];
+    }
+    createMenuItem(icon, label, routerLink) {
+        const menuItem = {};
+        if (icon) {
+            menuItem.icon = icon;
+        }
+        if (label) {
+            menuItem.label = label;
+        }
+        if (routerLink) {
+            menuItem.routerLink = routerLink;
+        }
+        return menuItem;
+    }
+    findMenuItemGuards() {
+        const guards = [];
+        if (this.route.canActivate?.length) {
+            guards.push(...this.route.canActivate);
+        }
+        if (this.parent) {
+            // Check for parent guards that should be included in decision to hide menu item!
+            // Some parent routes might have guards, but no menu items, so this guards must be taken into account here,
+            // because there is no parent menu item to hide.
+            this.parent.findMenuItemGuards().forEach(g => {
+                if (guards.indexOf(g) < 0) {
+                    guards.push(g);
+                }
+            });
+        }
+        return guards;
+    }
+    findMenuItemPermissions() {
+        if (this.menuItem?.permissions) {
+            return this.menuItem.permissions;
+        }
+        if (this.routeData.permissions) {
+            // this is already built
+            return this.routeData.permissions;
+        }
+        if (this.permissions) {
+            return this.permissions;
+        }
+        return undefined;
+    }
+}
+
+class RoutesBuilder {
+    constructor(layoutRoute) {
+        this.routes = [];
+        this.layoutRoute = layoutRoute?.withRoot(this);
+        this.currentRoute = layoutRoute;
+    }
+    static create() {
+        return new RoutesBuilder();
+    }
+    addAngularRoute(route, builderAdjustFn) {
+        const builder = RouteBuilder.createFromRoute(route);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRouteRedirect(path, redirectTo, pathMatch = 'prefix') {
+        return this.addRouteBuilder(RouteBuilder.createRedirect(path, redirectTo, pathMatch));
+    }
+    addLazyRouteComponent(path, loadComponent, canMatch, builderAdjustFn) {
+        const builder = RouteBuilder.createLazyRouteComponent(path, loadComponent, canMatch);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addLazyRouteModule(path, loadChildren, canMatch, builderAdjustFn) {
+        const builder = RouteBuilder.createLazyRouteModule(path, loadChildren, canMatch);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRoute(path, component, builderAdjustFn) {
+        const builder = RouteBuilder.create(path, component);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRouteBuilder(routeBuilder) {
+        this.currentRoute = routeBuilder.withRoot(this);
+        this.routes.push(routeBuilder);
+        return this;
+    }
+    build() {
+        let angularRoutes = [];
+        for (const route of this.routes) {
+            angularRoutes.push(route.build());
+        }
+        if (this.layoutRoute) {
+            const layoutAngularRoute = this.layoutRoute.build();
+            if (angularRoutes.length > 0) {
+                layoutAngularRoute.children = angularRoutes;
+            }
+            angularRoutes = [layoutAngularRoute];
+        }
+        return angularRoutes;
+    }
+}
+
+/**
+ * Maps an Observable of data with optional totalCount and data to a data list result object with provided defaults of empty array and count 0.
+ */
+function mapToDataList() {
+    return function (source) {
+        return new Observable(subscriber => {
+            return source.subscribe({
+                next(value) {
+                    subscriber.next({
+                        data: value.data ?? [],
+                        totalCount: value.totalCount ?? value.data?.length ?? 0
+                    });
+                }
+            });
+        });
+    };
+}
+
+function commonsInitializerProvider(handler, commonsInit) {
+    return () => commonsInit.initialize(handler);
+}
+
+const COMMONS_INITIALIZER_IT = new InjectionToken('COMMONS_INIZIALIZER');
+
+const LOG_PUBLISHERS = new InjectionToken('LOG_PUBLISHERS');
+
+class CommonsConfigurationService {
+    static { this._instance = new CommonsConfigurationService(); }
+    static get() {
+        return CommonsConfigurationService._instance;
+    }
+    constructor() {
+        this.jsonSources = [];
+        this.objectSources = [];
+        this.configuration = { ...this.projectEnvironment };
+        /**
+         * returns true if there is no jsonSources
+         */
+        this.skipJsonConfigsLoading = () => this.jsonSources === null || this.jsonSources.length === 0;
+        /**
+         * loads json sources or skips them returning true in both cases
+         * used for `skipJsonSourceInit` configuration parameter
+         */
+        this.loadJsonConfigurations = () => (this.skipJsonConfigsLoading() ? of(true) : this.loadJsonSources());
+        // empty, but needed for private constructor
+    }
+    init(httpClient, logger) {
+        this.http = httpClient;
+        this.logger = logger?.create('ConfigurationService');
+        return this;
+    }
+    /**
+     * Add commons module config.
+     * @param config Module config.
+     */
+    addModuleConfigSource(config) {
+        this.moduleConfig = config;
+        this.mergeConfigs();
+        this.logger?.debug(`Module configuration source added.`);
+    }
+    /**
+     * Add project environment source.
+     * @param environment Environment.
+     */
+    addEnvironmentSource(environment) {
+        this.projectEnvironment = environment;
+        this.mergeConfigs();
+        this.logger?.debug(`Environment configuration source added.`);
+    }
+    /**
+     * Adds new config source from JSON file loaded from HTTP.
+     * @param config Config for JSON file.
+     * @param loadImmediately Load is by default triggered on app initialization. If immediate load is required, pass true.
+     */
+    addJsonSource(config = {}, loadImmediately = false) {
+        if (!config) {
+            config = {};
+        }
+        const url = config?.url ?? 'assets/config/env{{environment}}.json';
+        const enableEnvProdReplace = config?.enableEnvProd ?? false;
+        const sourceInfo = {
+            url: url,
+            isEnvironment: false,
+            environmentEnableEnvProd: enableEnvProdReplace,
+            isLoaded: false
+        };
+        this.jsonSources.push(sourceInfo);
+        this.logger?.debug(`JSON configuration source added: ${url}.`);
+        if (loadImmediately) {
+            return this.loadJsonConfigurations();
+        }
+        else {
+            return of(true);
+        }
+    }
+    /**
+     * Adds new config object from any object.
+     * @param config Config object.
+     */
+    addObjectSource(config) {
+        this.objectSources.push(config);
+        this.logger?.debug(`Object configuration source added.`);
+        this.mergeConfigs();
+    }
+    loadJsonSources() {
+        if (!this.http) {
+            this.logger?.warn('HTTP client was not initialized. Json source cannot be loaded');
+            return of(false);
+        }
+        const httpClient = this.http;
+        return combineLatest(this.jsonSources
+            .filter(source => !source.isLoaded)
+            .map(sourceInfo => {
+            let url = sourceInfo.url;
+            sourceInfo.environment = this.projectEnvironment?.name || (this.projectEnvironment?.production ? (sourceInfo.environmentEnableEnvProd ? 'prod' : null) : 'dev');
+            sourceInfo.isEnvironment = !!sourceInfo.environment;
+            if (sourceInfo.isEnvironment) {
+                url = url.replace('{{environment}}', '.' + sourceInfo.environment);
+            }
+            else {
+                // replace possible environment entry and change source info url
+                url = url.replace('{{environment}}', '');
+                sourceInfo.url = url;
+            }
+            this.logger?.debug(`Loading JSON configuration source from ${url}.`);
+            return httpClient.get(url).pipe(catchError((err) => {
+                if (sourceInfo.isEnvironment) {
+                    const noEnvUrl = sourceInfo.url.replace('{{environment}}', '');
+                    sourceInfo.environment = null;
+                    return httpClient.get(noEnvUrl);
+                }
+                else {
+                    this.logger?.warn(`Configuration file ${url} not loaded`, err);
+                    return of(false);
+                }
+            }), map(configuration => {
+                if (typeof configuration !== 'object') {
+                    return false;
+                }
+                sourceInfo.configuration = configuration;
+                sourceInfo.isLoaded = true;
+                return true;
+            }));
+        })).pipe(map(sourceResults => sourceResults.every(sr => sr)), tap(() => this.mergeConfigs()));
+    }
+    /**
+     * Get configuration.
+     */
+    getConfig() {
+        return this.configuration;
+    }
+    /**
+     * Get configuration value for key.
+     * @param key Configuration key.
+     */
+    getConfigValue(key) {
+        return this.configuration[key] ? this.configuration[key] : null;
+    }
+    /**
+     * Has configuration for key.
+     * @param key Configuration key.
+     */
+    hasConfigKey(key) {
+        return Object.keys(this.configuration).some(k => k === key);
+    }
+    /**
+     * Merges configuration from multiple sources with
+     */
+    mergeConfigs() {
+        let config = {};
+        // 1. object sources have highest priority
+        if (this.objectSources.length) {
+            for (const objConfig of this.objectSources) {
+                config = objectDeepMerge(config, objConfig);
+            }
+        }
+        // 2. JSON sources come next
+        const jsonConfigs = this.jsonSources.filter(source => source.isLoaded && typeof source.configuration === 'object').map(source => source.configuration);
+        if (jsonConfigs.length) {
+            for (const jsonConfig of jsonConfigs) {
+                if (jsonConfig) {
+                    config = objectDeepMerge(config, jsonConfig);
+                }
+            }
+        }
+        // 3. project env has the next priority
+        if (this.projectEnvironment) {
+            config = objectDeepMerge(config, this.projectEnvironment);
+        }
+        // 4. module config has the lowest priority
+        if (this.moduleConfig) {
+            config = objectDeepMerge(config, this.moduleConfig);
+        }
+        this.configuration = config;
+    }
+}
+
+class CommonsRouterService {
+    constructor(router) {
+        this.router = router;
+        this.logger = inject(LoggerService).create('CommonsRouterService');
+        this.routesLoadedPropKey = '_loadedRoutes';
+        this.currentNavigationModuleKeys = [];
+        this.lazyLoadedRoutesConfig = {};
+    }
+    getRouteLoadedChildren(path) {
+        return this.getOrCreateRouteForModule(this.getModulePathFromRouterLink(path)).loadedRoutes;
+    }
+    getRouteLoadedChildren$(path) {
+        return this.getOrCreateRouteForModule(this.getModulePathFromRouterLink(path)).loadedRoutesSubject.asObservable().pipe(first());
+    }
+    initialize() {
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                this.startNavigation(event.url);
+            }
+            else if (event instanceof RouteConfigLoadStart) {
+                this.markNavigationConfigLoad(event.route);
+            }
+            else if (event instanceof RouteConfigLoadEnd) {
+                this.markNavigationConfigLoad(event.route, true);
+            }
+            else if (event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError) {
+                this.finishNavigation();
+            }
+        });
+    }
+    startNavigation(url) {
+        this.currentNavigationPath = url.split('?')[0].split('#')[0];
+        this.currentNavigationModuleKeys = [];
+    }
+    finishNavigation() {
+        if (this.currentNavigationModuleKeys.length) {
+            this.currentNavigationModuleKeys.forEach(k => this.getLoadedRoutesFromRoute(k, true));
+        }
+        this.currentNavigationPath = undefined;
+    }
+    markNavigationConfigLoad(route, isEnd = false) {
+        const routePath = route.path ?? '';
+        let moduleKey = routePath;
+        const currentNavigationPathRoutePathIdx = this.currentNavigationPath?.indexOf(routePath) ?? -1;
+        if (this.currentNavigationPath && currentNavigationPathRoutePathIdx >= 0) {
+            moduleKey = this.currentNavigationPath.substring(0, currentNavigationPathRoutePathIdx + routePath.length);
+        }
+        else if (this.currentNavigationPath && routePath !== this.currentNavigationPath && !routePath.startsWith('/')) {
+            // usually means that redirect to currentNavigationPath was done, additionally, route path was also triggered on lazy routes load
+            moduleKey = `${this.currentNavigationPath}/${routePath}`;
+        }
+        if (!isEnd && this.currentNavigationModuleKeys.indexOf(moduleKey) < 0) {
+            this.currentNavigationModuleKeys.push(moduleKey);
+        }
+        this.logger.trace(`Config load ${isEnd ? 'end' : 'start'} for ${moduleKey} (routePath: ${routePath}; navigationUrl: ${this.currentNavigationPath})`);
+        const config = this.getOrCreateRouteForModule(moduleKey);
+        config.route = route;
+        config.isLoadEnd = isEnd;
+        if (isEnd) {
+            this.getLoadedRoutesFromRoute(moduleKey);
+        }
+    }
+    getLoadedRoutesFromRoute(moduleKey, isFinish = false) {
+        const moduleConfig = this.lazyLoadedRoutesConfig[moduleKey];
+        if (!moduleConfig?.route || Array.isArray(moduleConfig.loadedRoutes)) {
+            return;
+        }
+        moduleConfig.loadedRoutes = moduleConfig.route[this.routesLoadedPropKey];
+        if (!Array.isArray(moduleConfig.loadedRoutes) && isFinish) {
+            // if is called from finish and no lazy loaded routes are matched from router events, try finding in route config, it should be there!
+            this.logger.trace(`Route loadedRoutes for ${moduleKey} not found, searching in router config now`);
+            const route = this.findRouteInRouteConfig(moduleKey);
+            if (route) {
+                moduleConfig.route = route;
+                moduleConfig.loadedRoutes = moduleConfig.route[this.routesLoadedPropKey];
+            }
+            else {
+                this.logger.warn(`Route loadedRoutes for ${moduleKey} were not found in router config`);
+            }
+        }
+        if (typeof moduleConfig.loadedRoutes !== 'undefined') {
+            moduleConfig.loadedRoutesSubject.next(moduleConfig.loadedRoutes);
+            moduleConfig.loadedRoutesSubject.complete();
+            this.logger.trace(`Config load for ${moduleKey} is complete`, moduleConfig);
+        }
+    }
+    /**
+     * Search for route config by module path by recursive scanning of router config tree.
+     * @param modulePath Path of module that is searched.
+     * @param routes Routes to be scanned. If not provided, it starts on root router config.
+     * @private
+     */
+    findRouteInRouteConfig(modulePath, routes = this.router.config) {
+        if (modulePath.startsWith('/')) {
+            modulePath = modulePath.substring(1);
+        }
+        for (const route of routes) {
+            if (typeof route.path === 'undefined') {
+                continue;
+            }
+            let routePath = route.path;
+            if (routePath.startsWith('/')) {
+                routePath = routePath.substring(1);
+            }
+            const longestPathMatch = this.findLongestPathMatch(modulePath, routePath);
+            if (longestPathMatch === null) {
+                continue;
+            }
+            // there is a partial or full match
+            if (route.loadChildren && modulePath === longestPathMatch) {
+                // it's a hit!
+                return route;
+            }
+            else if (route.loadChildren && Array.isArray(route[this.routesLoadedPropKey])) {
+                const result = this.findRouteInRouteConfig(modulePath.substring(longestPathMatch.length, modulePath.length), route[this.routesLoadedPropKey]);
+                if (result) {
+                    return result;
+                }
+            }
+            else if (route.children) {
+                const result = this.findRouteInRouteConfig(modulePath.substring(longestPathMatch.length, modulePath.length), route.children);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Finds longest path match of source to match string. If match is '', it is considered as a match in Angular routing.
+     * @param source Source string from on which comparison is based.
+     * @param match Match string to which the source is matched to.
+     * @private
+     */
+    findLongestPathMatch(source, match) {
+        const sourceSegments = source.split('/');
+        const matchSegments = match.split('/');
+        if (matchSegments.length === 1 && matchSegments[0] === '') {
+            // it's a hit, because empty route must always be processed (kind of a "abstract" route)
+            return '';
+        }
+        if (sourceSegments[0] === matchSegments[0]) {
+            // there is a match, find how long it is
+            for (let i = 1; i < sourceSegments.length; i++) {
+                if (sourceSegments[i] !== matchSegments[i]) {
+                    // end of match
+                    return sourceSegments.slice(0, i).join('/');
+                }
+            }
+            // there is full match
+            return sourceSegments.join('/');
+        }
+        return null;
+    }
+    getOrCreateRouteForModule(moduleKey) {
+        if (!this.lazyLoadedRoutesConfig[moduleKey]) {
+            this.lazyLoadedRoutesConfig[moduleKey] = {
+                loadedRoutesSubject: new ReplaySubject(1),
+                isLoadEnd: false
+            };
+        }
+        return this.lazyLoadedRoutesConfig[moduleKey];
+    }
+    getModulePathFromRouterLink(path) {
+        return ('/' + (Array.isArray(path) ? path.join('/') : path)).replace(/\/\//g, '/');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsRouterService, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsRouterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsRouterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.Router }] });
+
+var CommonsInitEventEnum;
+(function (CommonsInitEventEnum) {
+    CommonsInitEventEnum[CommonsInitEventEnum["CommonsInitStart"] = 0] = "CommonsInitStart";
+    CommonsInitEventEnum[CommonsInitEventEnum["ConfigSourceModuleLoaded"] = 1] = "ConfigSourceModuleLoaded";
+    CommonsInitEventEnum[CommonsInitEventEnum["ConfigSourceProjectEnvLoaded"] = 2] = "ConfigSourceProjectEnvLoaded";
+    CommonsInitEventEnum[CommonsInitEventEnum["ConfigSourceJsonAdded"] = 3] = "ConfigSourceJsonAdded";
+    CommonsInitEventEnum[CommonsInitEventEnum["ConfigSourceJsonLoaded"] = 4] = "ConfigSourceJsonLoaded";
+    CommonsInitEventEnum[CommonsInitEventEnum["CommonsInitEnd"] = 5] = "CommonsInitEnd";
+    CommonsInitEventEnum[CommonsInitEventEnum["CommonsInitError"] = 6] = "CommonsInitError";
+})(CommonsInitEventEnum || (CommonsInitEventEnum = {}));
+class CommonsInitService {
+    constructor() {
+        this.logger = inject(LoggerService);
+        this.logPublishers = inject(LOG_PUBLISHERS, { optional: true });
+        this.config = inject(CommonsConfigurationService);
+        this.commons = inject(CommonsService);
+        this.commonsRouter = inject(CommonsRouterService);
+        this.moduleConfig = inject(COMMONS_MODULE_CONFIG_IT, { optional: true });
+        this.commonsInitializers = inject(COMMONS_INITIALIZER_IT, { optional: true });
+        this.isInitialized = false;
+        this.isInitializedSubject = new ReplaySubject();
+        this.commonsInitServiceEvents = new Subject();
+    }
+    get events$() {
+        return this.commonsInitServiceEvents.asObservable();
+    }
+    get isInitialized$() {
+        return this.isInitializedSubject.asObservable().pipe(take(1));
+    }
+    initialize(handler) {
+        if (this.isInitialized) {
+            return of(void 0);
+        }
+        this.isInitialized = true;
+        LoggerService.configure({ timestampFormat: this.moduleConfig?.log?.timestampFormat });
+        const ctxLogger = this.logger.create('CommonsInitService');
+        ctxLogger.debug('Commons initialization is starting');
+        this.commonsInitServiceEvents.next(CommonsInitEventEnum.CommonsInitStart);
+        // init http client
+        this.httpClient = new HttpClient(handler);
+        // init router
+        this.commonsRouter.initialize();
+        // init configurations with settings from module config
+        this.config.init(this.httpClient, this.logger);
+        this.config.addModuleConfigSource(this.moduleConfig ?? undefined);
+        this.commonsInitServiceEvents.next(CommonsInitEventEnum.ConfigSourceModuleLoaded);
+        if (this.moduleConfig?.configuration?.projectEnvironment) {
+            this.config.addEnvironmentSource(this.moduleConfig.configuration.projectEnvironment);
+            this.commonsInitServiceEvents.next(CommonsInitEventEnum.ConfigSourceProjectEnvLoaded);
+        }
+        // init configurations with settings from module config for json source
+        if (!(this.moduleConfig?.configuration?.skipJsonSourceInit ?? false)) {
+            const jsonSourceEnableEnvProd = this.moduleConfig?.configuration?.jsonSourceEnableEnvProd ?? false;
+            const jsonSource = this.moduleConfig?.configuration?.jsonSource;
+            if (!jsonSource) {
+                this.config.addJsonSource({ enableEnvProd: jsonSourceEnableEnvProd });
+            }
+            else if (Array.isArray(jsonSource)) {
+                jsonSource.forEach(source => this.config.addJsonSource({ url: source, enableEnvProd: jsonSourceEnableEnvProd }));
+            }
+            else {
+                this.config.addJsonSource({ url: jsonSource, enableEnvProd: jsonSourceEnableEnvProd });
+            }
+            this.commonsInitServiceEvents.next(CommonsInitEventEnum.ConfigSourceJsonAdded);
+        }
+        return this.config.loadJsonConfigurations().pipe(mergeMap(() => {
+            if (!(this.moduleConfig?.configuration?.skipJsonSourceInit ?? false)) {
+                this.commonsInitServiceEvents.next(CommonsInitEventEnum.ConfigSourceJsonLoaded);
+            }
+            // init logger
+            LoggerService.init(this.config, this.logPublishers ?? []);
+            if (this.commonsInitializers) {
+                ctxLogger.debug('Project initializers are being initialized');
+                return combineLatest(this.commonsInitializers.map(ci => ci())).pipe(map(res => res));
+            }
+            else {
+                return of(true);
+            }
+        }), map(() => {
+            ctxLogger.debug('Commons initialization is finished');
+            this.commonsInitServiceEvents.next(CommonsInitEventEnum.CommonsInitEnd);
+            this.commonsInitServiceEvents.complete();
+            this.isInitializedSubject.next(true);
+            return this.commons.reset();
+        }), catchError(err => {
+            ctxLogger.warn('Commons initialization failed with error', err);
+            this.commonsInitServiceEvents.next(CommonsInitEventEnum.CommonsInitError);
+            this.commonsInitServiceEvents.complete();
+            this.isInitializedSubject.next(false);
+            return throwError(() => err);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsInitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsInitService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: CommonsInitService, decorators: [{
+            type: Injectable
+        }] });
+
+class LocalStorageService {
+    constructor() {
+        this._configKey = 'CommonsUserPrefs';
+    }
+    buildLocalStorageKey(type, key) {
+        return `${this._configKey}_${type}_${key}`;
+    }
+    getItem(type, key) {
+        const localstorageData = localStorage.getItem(this.buildLocalStorageKey(type, key));
+        if (localstorageData) {
+            return JSON.parse(localstorageData);
+        }
+        return undefined;
+    }
+    setItem(type, key, value) {
+        localStorage.setItem(this.buildLocalStorageKey(type, key), JSON.stringify(value));
+    }
+    removeItem(type, key) {
+        localStorage.removeItem(this.buildLocalStorageKey(type, key));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable
+        }] });
+
+var StyleSizeEnum;
+(function (StyleSizeEnum) {
+    StyleSizeEnum[StyleSizeEnum["ExtraSmall"] = 0] = "ExtraSmall";
+    StyleSizeEnum[StyleSizeEnum["Small"] = 1] = "Small";
+    StyleSizeEnum[StyleSizeEnum["Normal"] = 2] = "Normal";
+    StyleSizeEnum[StyleSizeEnum["Large"] = 3] = "Large";
+    StyleSizeEnum[StyleSizeEnum["ExtraLarge"] = 4] = "ExtraLarge";
+})(StyleSizeEnum || (StyleSizeEnum = {}));
+var StyleLevelEnum;
+(function (StyleLevelEnum) {
+    StyleLevelEnum[StyleLevelEnum["Default"] = 0] = "Default";
+    StyleLevelEnum[StyleLevelEnum["Primary"] = 1] = "Primary";
+    StyleLevelEnum[StyleLevelEnum["Secondary"] = 2] = "Secondary";
+    StyleLevelEnum[StyleLevelEnum["Info"] = 3] = "Info";
+    StyleLevelEnum[StyleLevelEnum["Help"] = 4] = "Help";
+    StyleLevelEnum[StyleLevelEnum["Success"] = 5] = "Success";
+    StyleLevelEnum[StyleLevelEnum["Warning"] = 6] = "Warning";
+    StyleLevelEnum[StyleLevelEnum["Danger"] = 7] = "Danger";
+})(StyleLevelEnum || (StyleLevelEnum = {}));
+
+class Styles {
+    static { this.BUTTON_ROUNDED_WIDTH_XS = 26; }
+    static { this.BUTTON_ROUNDED_WIDTH_SM = 28; }
+    static { this.BUTTON_ROUNDED_WIDTH = 32; }
+    static { this.BUTTON_ROUNDED_WIDTH_LG = 45; }
+    static { this.ACTION_BUTTON_MARGIN_X = 2; }
+    static { this.TABLE_CELL_PADDING_X = 8; } // left and right paddings are same
+    static { this.TABLE_CELL_PADDING_X_SM = 4; }
+    static { this.TABLE_CELL_PADDING_X_LG = 12; }
+}
+
+var CommonsFeatureTypeEnum;
+(function (CommonsFeatureTypeEnum) {
+    CommonsFeatureTypeEnum[CommonsFeatureTypeEnum["Layout"] = 0] = "Layout";
+    CommonsFeatureTypeEnum[CommonsFeatureTypeEnum["Tableview"] = 1] = "Tableview";
+    CommonsFeatureTypeEnum[CommonsFeatureTypeEnum["DataApiAsClassV1"] = 2] = "DataApiAsClassV1";
+})(CommonsFeatureTypeEnum || (CommonsFeatureTypeEnum = {}));
+function provideCommons(config, ...features) {
+    const providers = [
+        // primeng services
+        DialogService,
+        MessageService,
+        ConfirmationService,
+        // services
+        CommonsInitService,
+        CommonsService,
+        CommonsRouterService,
+        PermissionService,
+        LocalStorageService,
+        {
+            provide: COMMONS_MODULE_CONFIG_IT,
+            useValue: config
+        },
+        {
+            provide: TypeRegistry,
+            useFactory: () => TypeRegistry.get()
+        },
+        {
+            provide: CommonsConfigurationService,
+            useFactory: () => CommonsConfigurationService.get()
+        },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: commonsInitializerProvider,
+            deps: [HttpBackend, CommonsInitService],
+            multi: true
+        },
+        {
+            provide: LoggerService,
+            useFactory: () => LoggerService.get()
+        },
+        {
+            provide: LOG_PUBLISHERS,
+            useClass: LogPublisherConsoleService,
+            multi: true
+        },
+        {
+            provide: BROWSER_STORAGE_IT,
+            useFactory: () => localStorage
+        },
+        {
+            provide: ErrorHandler,
+            useClass: CommonsErrorHandler
+        }
+    ];
+    features.forEach(f => {
+        providers.push(...f.providers);
+    });
+    return providers;
+}
+
+// action
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ACommonsErrorBase, APermissions, BROWSER_STORAGE_IT, BooleanPipe, COMMONS_INITIALIZER_IT, COMMONS_MODULE_CONFIG_IT, ClassMapPipe, CommonsConfigurationService, CommonsErrorHandler, CommonsFeatureTypeEnum, CommonsHttpError, CommonsInitEventEnum, CommonsInitService, CommonsInternalError, CommonsRouterService, CommonsService, ComponentDirective, DataProvider, DataProviderInst, DialogKeydownHandlerDirective, EnumName, EnumPipe, EnumerateAsyncPipe, EnumeratePipe, ErrorPageComponent, FilterMatchMode, GetterPipe, I18nPropertyPipe, JsonPathPipe, LOG_PUBLISHERS, LocalStorageService, LogLevelEnum, LogPublisherConsoleService, LoggerService, NotFoundPageComponent, NotificationWrapperComponent, ParametrizePipe, PermissionService, PermissionTypeEnum, Permissions, RouteBuilder, RoutesBuilder, StyleLevelEnum, StyleSizeEnum, Styles, TemplateDirective, TemplatePipe, TypeName, TypeRegistry, adjustRouteMenuLazyChildrenRouterLinks, angularDateFormatHasSeconds, angularDateFormatHasTime, appendRoutePathToBasePath, boolean$Attribute, commonsActionErrorContextToString, commonsErrorToString, commonsInitializerProvider, copyDataListParams, dataListParamsFilterToUrlQuery, dataListParamsFilterValueToUrlString, dataListParamsFiltersToUrlQuery, dataListParamsSortToUrlQuery, dataListParamsToUrlQuery, dateToIsoString, defineReflectEnumName, defineReflectTypeName, doesUrlMatchRouterLink, errorCauseToString, errorToString, escapeHtml, escapeHtmlAny, findReflectEnumName, findReflectTypeName, findTemplateByName, flattenObjectKeys, fromAngularDateFormatToPrime, fromEnumConstantsAsValueArray, fromEnumValuesAsValueArray, fromSubscribeError, fromTableLoadToDataListParams, fromUrlQueryToDataListParams, getEnumConstantName, getEnumConstantNameFromObject, getEnumConstantNames, getEnumConstantNamesFromObject, getEnumConstantValuesAsNumber, getEnumConstantValuesAsString, getEnumerationI18nBaseKey, getErrorLogLevel, getErrorName, getHttpErrorResponse, getHttpErrorResponseStatus, getI18n, getI18nAsync, getI18nClassGroupKey, getI18nClassKeyBasePath, getI18nClassName, getI18nClassNameAsync, getI18nClassParams, getI18nClassParamsAsync, getI18nClassPropertyKey, getI18nClassTabKey, getI18nErrorParams, getI18nForError, getI18nTypeGroupKey, getI18nTypeKeyBasePath, getI18nTypeName, getI18nTypeNameAsync, getI18nTypeParams, getI18nTypeParamsAsync, getI18nTypePropertyKey, getI18nTypeTabKey, getObjectGetters, getObjectProperties, getObjectPropertyByPath, httpErrorResponseToString, isHttpErrorResponse, isPermitted, isRbacPermitted, itemIdToDefined, itemIdToNumber, itemIdToString, mapToDataList, mergeDataListParamsWithDefaults, number$Attribute, objectDeepCopy, objectDeepMerge, permissionGuard, populateI18nParams, populateI18nTypeParams, provideCommons, reflectEnumNameKey, reflectTypeNameExists, reflectTypeNameKey, removeRouteEmptyPathSegments, selectEnumerationI18n, selectI18n, stringify, toEnumerationI18nEnumerate, toObservable, toastMessage, valueToDefined };
+//# sourceMappingURL=mediusinc-mng-commons-core.mjs.map