@yuuvis/client-core 0.6.5

package/fesm2022/yuuvis-client-core.mjs

@@ -0,0 +1,4775 @@
+import * as i1$1 from '@ngx-translate/core';
+import { TranslateModule, TranslateService, TranslateLoader, MissingTranslationHandler } from '@ngx-translate/core';
+export { TranslateDirective, TranslateLoader, TranslateModule, TranslatePipe, TranslateService } from '@ngx-translate/core';
+import * as i0 from '@angular/core';
+import { NgModule, InjectionToken, Inject, Injectable, Optional, inject, APP_INITIALIZER, SkipSelf, Pipe } from '@angular/core';
+import { HttpErrorResponse, HttpHeaders, HttpClient, HttpParams, HttpRequest, HttpEventType, HttpResponse, HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+import { map, tap, finalize, shareReplay, catchError, filter, switchMap, first, scan, delay } from 'rxjs/operators';
+import { EMPTY, of, from, Observable, forkJoin, Subject, ReplaySubject, BehaviorSubject, tap as tap$1, map as map$1, merge, fromEvent, filter as filter$1, debounceTime, throwError } from 'rxjs';
+import * as i1 from 'angular-oauth2-oidc';
+import { OAuthStorage, OAuthModule } from 'angular-oauth2-oidc';
+import { __decorate, __param, __metadata } from 'tslib';
+import { StorageMap } from '@ngx-pwa/local-storage';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { ToastService } from '@yuuvis/components/toast';
+import { registerLocaleData, DecimalPipe, PercentPipe, CurrencyPipe } from '@angular/common';
+import localeAr from '@angular/common/locales/ar';
+import localeBn from '@angular/common/locales/bn';
+import localeDe from '@angular/common/locales/de';
+import localeDeCh from '@angular/common/locales/de-CH';
+import localeEs from '@angular/common/locales/es';
+import localeExtraAr from '@angular/common/locales/extra/ar';
+import localeExtraBn from '@angular/common/locales/extra/bn';
+import localeExtraDe from '@angular/common/locales/extra/de';
+import localeExtraDeCh from '@angular/common/locales/extra/de-CH';
+import localeExtraEs from '@angular/common/locales/extra/es';
+import localeExtraFi from '@angular/common/locales/extra/fi';
+import localeExtraFr from '@angular/common/locales/extra/fr';
+import localeExtraHi from '@angular/common/locales/extra/hi';
+import localeExtraIt from '@angular/common/locales/extra/it';
+import localeExtraJa from '@angular/common/locales/extra/ja';
+import localeExtraKo from '@angular/common/locales/extra/ko';
+import localeExtraLv from '@angular/common/locales/extra/lv';
+import localeExtraNb from '@angular/common/locales/extra/nb';
+import localeExtraNl from '@angular/common/locales/extra/nl';
+import localeExtraPl from '@angular/common/locales/extra/pl';
+import localeExtraPt from '@angular/common/locales/extra/pt';
+import localeExtraRu from '@angular/common/locales/extra/ru';
+import localeExtraSk from '@angular/common/locales/extra/sk';
+import localeExtraSv from '@angular/common/locales/extra/sv';
+import localeExtraTh from '@angular/common/locales/extra/th';
+import localeExtraTr from '@angular/common/locales/extra/tr';
+import localeExtraUk from '@angular/common/locales/extra/uk';
+import localeExtraVi from '@angular/common/locales/extra/vi';
+import localeExtraZh from '@angular/common/locales/extra/zh';
+import localeFi from '@angular/common/locales/fi';
+import localeFr from '@angular/common/locales/fr';
+import localeHi from '@angular/common/locales/hi';
+import localeIt from '@angular/common/locales/it';
+import localeJa from '@angular/common/locales/ja';
+import localeKo from '@angular/common/locales/ko';
+import localeLv from '@angular/common/locales/lv';
+import localeNb from '@angular/common/locales/nb';
+import localeNl from '@angular/common/locales/nl';
+import localePl from '@angular/common/locales/pl';
+import localePt from '@angular/common/locales/pt';
+import localeRu from '@angular/common/locales/ru';
+import localeSk from '@angular/common/locales/sk';
+import localeSv from '@angular/common/locales/sv';
+import localeTh from '@angular/common/locales/th';
+import localeTr from '@angular/common/locales/tr';
+import localeUk from '@angular/common/locales/uk';
+import localeVi from '@angular/common/locales/vi';
+import localeZh from '@angular/common/locales/zh';
+import * as i1$2 from '@angular/platform-browser';
+
+/**
+ * `YuvClientCoreSharedModule` sets up and re-exports the TranslateModule.
+ */
+class YuvClientCoreSharedModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreSharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreSharedModule, exports: [TranslateModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreSharedModule, imports: [TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreSharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [TranslateModule]
+                }]
+        }] });
+
+const TENANT_HEADER = 'X-ID-TENANT-NAME';
+var Situation;
+(function (Situation) {
+    Situation["EDIT"] = "EDIT";
+    Situation["CREATE"] = "CREATE";
+    Situation["SEARCH"] = "SEARCH";
+})(Situation || (Situation = {}));
+const SystemType = {
+    OBJECT: 'system:object',
+    DOCUMENT: 'system:document',
+    FOLDER: 'system:folder',
+    AUDIT: 'system:audit',
+    SOT: 'system:secondray'
+};
+const SystemResult = {
+    DELETE: 'system:deletionResult',
+};
+const AdministrationRoles = {
+    ADMIN: 'YUUVIS_TENANT_ADMIN',
+    SYSTEM: 'YUUVIS_SYSTEM_INTEGRATOR',
+    MANAGE_SETTINGS: 'YUUVIS_MANAGE_SETTINGS'
+};
+const UserRoles = {
+    MULTI_TENANT: 'YUUVIS_MULTI_TENANT'
+};
+const SystemSOT = {
+    DESTRUCTION_RETENTION: 'system:rmDestructionRetention'
+};
+const RetentionField = {
+    RETENTION_END: 'system:rmExpirationDate',
+    RETENTION_START: 'system:rmStartOfRetention',
+    DESTRUCTION_DATE: 'system:rmDestructionDate'
+};
+var RetentionState;
+(function (RetentionState) {
+    // no retention
+    RetentionState[RetentionState["NONE"] = 0] = "NONE";
+    // retention is active
+    RetentionState[RetentionState["ACTIVE"] = 1] = "ACTIVE";
+    // supposed to be destructed
+    RetentionState[RetentionState["DESTRUCT"] = 2] = "DESTRUCT";
+    // retention is not active yet
+    RetentionState[RetentionState["INACTIVE"] = 3] = "INACTIVE";
+})(RetentionState || (RetentionState = {}));
+const BaseObjectTypeField = {
+    OBJECT_TYPE_ID: 'system:objectTypeId',
+    VERSION_NUMBER: 'system:versionNumber',
+    CREATION_DATE: 'system:creationDate',
+    CREATED_BY: 'system:createdBy',
+    MODIFICATION_DATE: 'system:lastModificationDate',
+    MODIFIED_BY: 'system:lastModifiedBy',
+    ...RetentionField,
+    PARENT_ID: 'system:parentId',
+    PARENT_OBJECT_TYPE_ID: 'system:parentObjectTypeId',
+    PARENT_VERSION_NUMBER: 'system:parentVersionNumber',
+    TENANT: 'system:tenant',
+    ACL: 'system:acl',
+    TRACE_ID: 'system:traceId',
+    SECONDARY_OBJECT_TYPE_IDS: 'system:secondaryObjectTypeIds',
+    BASE_TYPE_ID: 'system:baseTypeId',
+    TAGS: 'system:tags',
+    OBJECT_ID: 'system:objectId'
+};
+// Fields provided by a special secondary object type that most of
+// the object types should have applied to them
+const ClientDefaultsObjectTypeField = {
+    TITLE: 'appClient:clienttitle',
+    DESCRIPTION: 'appClient:clientdescription'
+};
+const ContentStreamField = {
+    LENGTH: 'system:contentStreamLength',
+    MIME_TYPE: 'system:contentStreamMimeType',
+    FILENAME: 'system:contentStreamFileName',
+    ID: 'system:contentStreamId',
+    RANGE: 'system:contentStreamRange',
+    REPOSITORY_ID: 'system:contentStreamRepositoryId',
+    DIGEST: 'system:digest',
+    ARCHIVE_PATH: 'system:archivePath'
+};
+const AuditField = {
+    REFERRED_OBJECT_ID: 'system:referredObjectId',
+    CREATION_DATE: 'system:creationDate',
+    VERSION: 'system:versionNumber',
+    DETAIL: 'system:detail',
+    CREATED_BY: 'system:createdBy',
+    ACTION: 'system:action',
+    SUBACTION: 'system:subaction'
+};
+const ParentField = {
+    asvaktenzeichen: 'tenKolibri:asvaktenzeichen',
+    asvaktenzeichentext: 'tenKolibri:asvaktenzeichentext',
+    asvsichtrechte: 'tenKolibri:asvsichtrechte',
+    asvvorgangsname: 'tenKolibri:asvvorgangsname',
+    asvvorgangsnummer: 'tenKolibri:asvvorgangsnummer'
+};
+var ContentStreamAllowed;
+(function (ContentStreamAllowed) {
+    ContentStreamAllowed["ALLOWED"] = "allowed";
+    ContentStreamAllowed["NOT_ALLOWED"] = "notallowed";
+    ContentStreamAllowed["REQUIRED"] = "required";
+})(ContentStreamAllowed || (ContentStreamAllowed = {}));
+// classifications applied to object type fields
+var Classification;
+(function (Classification) {
+    Classification["STRING_CATALOG_CUSTOM"] = "custom:catalog";
+    Classification["STRING_CATALOG_DYNAMIC"] = "dynamic:catalog";
+    Classification["STRING_CATALOG"] = "catalog";
+    Classification["STRING_ORGANIZATION"] = "id:organization";
+    Classification["STRING_ORGANIZATION_SET"] = "id:organization:set";
+    Classification["STRING_REFERENCE"] = "id:reference";
+    Classification["STRING_EMAIL"] = "email";
+    Classification["STRING_URL"] = "url";
+    Classification["STRING_PHONE"] = "phone";
+    Classification["NUMBER_FILESIZE"] = "filesize";
+    Classification["NUMBER_DIGIT"] = "digit";
+    Classification["BOOLEAN_SWITCH"] = "switch";
+    Classification["SYSTEM_SOT"] = "systemsot";
+    Classification["PREDICTION_CLASSIFY"] = "prediction:classify";
+    Classification["TABLE_SORTABLE"] = "sortable";
+})(Classification || (Classification = {}));
+// classifications applied to object types
+var ObjectTypeClassification;
+(function (ObjectTypeClassification) {
+    ObjectTypeClassification["SEARCH_FALSE"] = "appClient:search:false";
+    ObjectTypeClassification["CREATE_FALSE"] = "appClient:create:false";
+    ObjectTypeClassification["OBJECT_TYPE_ICON"] = "appClient:icon";
+})(ObjectTypeClassification || (ObjectTypeClassification = {}));
+// classifications applied to object types
+var ObjectTypePropertyClassification;
+(function (ObjectTypePropertyClassification) {
+    ObjectTypePropertyClassification["SUMMARY_HIDDEN"] = "appClient:summary:hidden";
+})(ObjectTypePropertyClassification || (ObjectTypePropertyClassification = {}));
+// classifications applied to secondary object types
+var SecondaryObjectTypeClassification;
+(function (SecondaryObjectTypeClassification) {
+    SecondaryObjectTypeClassification["REQUIRED"] = "appClient:required";
+    SecondaryObjectTypeClassification["PRIMARY"] = "appClient:primary";
+    SecondaryObjectTypeClassification["EXTENSION_ADD_FALSE"] = "appClient:extension:add:false";
+    SecondaryObjectTypeClassification["EXTENSION_REMOVE_FALSE"] = "appClient:extension:remove:false";
+})(SecondaryObjectTypeClassification || (SecondaryObjectTypeClassification = {}));
+// special internal types of object type fields
+var InternalFieldType;
+(function (InternalFieldType) {
+    InternalFieldType["STRING_ORGANIZATION_SET"] = "string:organization:set";
+    InternalFieldType["STRING_ORGANIZATION"] = "string:organization";
+    InternalFieldType["STRING_REFERENCE"] = "string:reference";
+    InternalFieldType["STRING_CATALOG"] = "string:catalog";
+    InternalFieldType["STRING_DYNAMIC_CATALOG"] = "string:catalog:dynamic";
+    InternalFieldType["BOOLEAN_SWITCH"] = "boolean:switch";
+})(InternalFieldType || (InternalFieldType = {}));
+;
+var ObjectTag;
+(function (ObjectTag) {
+    ObjectTag["AFO"] = "appclient:dlm:prepare";
+})(ObjectTag || (ObjectTag = {}));
+// possible states of a DLM item
+const AFO_STATE = {
+    // created but no FSOT assigned so far
+    IN_PROGRESS: 0,
+    // an FSOT has been assigned
+    READY: 1
+};
+const ColumnConfigSkipFields = [
+    BaseObjectTypeField.OBJECT_ID,
+    BaseObjectTypeField.OBJECT_TYPE_ID,
+    BaseObjectTypeField.PARENT_ID,
+    BaseObjectTypeField.PARENT_OBJECT_TYPE_ID,
+    BaseObjectTypeField.PARENT_VERSION_NUMBER,
+    BaseObjectTypeField.TENANT,
+    BaseObjectTypeField.TRACE_ID,
+    // BaseObjectTypeField.TAGS,
+    BaseObjectTypeField.BASE_TYPE_ID,
+    ContentStreamField.ID,
+    ContentStreamField.RANGE,
+    ContentStreamField.REPOSITORY_ID,
+    ContentStreamField.DIGEST,
+    ContentStreamField.ARCHIVE_PATH
+];
+
+/**
+ * `DmsObject` is a business object of a type that  generally contain a document file in addition to its metadata.
+ *  Document file can be text documents, e-mails, image files, video, etc.
+ *  Each object type classifies the object and defines the properties that the object must have or is allowed to have.
+ */
+class DmsObject {
+    /**
+     * @ignore
+     */
+    constructor(searchResultItem) {
+        this.sots = [];
+        this.id = searchResultItem.fields.get(BaseObjectTypeField.OBJECT_ID);
+        this.version = searchResultItem.fields.get(BaseObjectTypeField.VERSION_NUMBER);
+        this.objectTypeId = searchResultItem.objectTypeId;
+        this.parentId = searchResultItem.fields.get(BaseObjectTypeField.PARENT_ID);
+        this.data = this.#generateData(searchResultItem.fields);
+        this.isFolder = searchResultItem.fields.get(BaseObjectTypeField.BASE_TYPE_ID) === SystemType.FOLDER;
+        // this.contentStreamAllowed = objectType.contentStreamAllowed;
+        this.created = {
+            on: searchResultItem.fields.get(BaseObjectTypeField.CREATION_DATE),
+            by: {
+                id: searchResultItem.fields.get(BaseObjectTypeField.CREATED_BY)
+            }
+        };
+        this.modified = {
+            on: searchResultItem.fields.get(BaseObjectTypeField.MODIFICATION_DATE),
+            by: {
+                id: searchResultItem.fields.get(BaseObjectTypeField.MODIFIED_BY)
+            }
+        };
+        if (searchResultItem.content) {
+            this.content = searchResultItem.content;
+        }
+        if (searchResultItem.permissions) {
+            this.permissions = {
+                readIndexData: searchResultItem.permissions.read && searchResultItem.permissions.read.includes('metadata'),
+                readContent: searchResultItem.permissions.read && searchResultItem.permissions.read.includes('content'),
+                writeIndexData: searchResultItem.permissions.write && searchResultItem.permissions.write.includes('metadata'),
+                writeContent: searchResultItem.permissions.write && searchResultItem.permissions.write.includes('content'),
+                deleteObject: searchResultItem.permissions.delete && searchResultItem.permissions.delete.includes('object'),
+                deleteContent: searchResultItem.permissions.delete && searchResultItem.permissions.delete.includes('content')
+            };
+        }
+        this.sots = searchResultItem.fields.get(BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS) || [];
+    }
+    // /**
+    //  * Get the value (state) of a certain tag
+    //  * @param name The tags name
+    //  * @returns The value of the tag or null if the tag does not exist
+    //  */
+    // getTag(name: string): any {
+    //   const tags: unknown[][] = this.data[BaseObjectTypeField.TAGS] as unknown[][];
+    //   const tag: unknown[] | null = tags ? (tags.find((t: any) => t[0] === name) as unknown[]) : null;
+    //   return tag ? tag[1] : null;
+    // }
+    // getRetentionState(): RetentionState {
+    //   if (this.data[RetentionField.RETENTION_START]) {
+    //     const retentionStart = new Date(this.data[RetentionField.RETENTION_START] as string);
+    //     const retentionEnd = new Date(this.data[RetentionField.RETENTION_END] as string);
+    //     const today = new Date();
+    //     return retentionStart <= today && today <= retentionEnd
+    //       ? RetentionState.ACTIVE
+    //       : today < retentionStart
+    //         ? RetentionState.INACTIVE
+    //         : RetentionState.DESTRUCT;
+    //   } else {
+    //     return RetentionState.NONE;
+    //   }
+    // }
+    #generateData(fields) {
+        const result = {};
+        for (const [key, val] of fields.entries()) {
+            result[key] = val;
+        }
+        return result;
+    }
+}
+
+/**
+ * @ignore
+ */
+class YuvError {
+    get name() {
+        return this._name || this.originalError.name || '';
+    }
+    get message() {
+        return this._message || this.originalError.message || '';
+    }
+    get stack() {
+        return this.originalError.stack;
+    }
+    get status() {
+        return this.originalError.status;
+    }
+    get url() {
+        return this.originalError.url;
+    }
+    get skipNotification() {
+        return this._skipNotification === undefined ? !!this.originalError.skipNotification : this._skipNotification;
+    }
+    get isHttpErrorResponse() {
+        return this.originalError.isHttpErrorResponse || this.originalError instanceof HttpErrorResponse;
+    }
+    constructor(originalError, _name, _message, _skipNotification = false) {
+        this.originalError = originalError;
+        this._name = _name;
+        this._message = _message;
+        this._skipNotification = _skipNotification;
+    }
+    toString() {
+        return this.originalError.toString();
+    }
+}
+
+/**
+ * User account configuration
+ */
+class YuvUser {
+    /**
+     * @ignore
+     */
+    constructor(json, userSettings) {
+        this.DEFAULT_USER_LOCALE = 'en';
+        this.id = json.id;
+        this.username = json.username;
+        this.firstname = json.firstname;
+        this.lastname = json.lastname;
+        this.email = json.email;
+        this.image = json.image;
+        this.tenant = json.tenant;
+        this.domain = json.domain;
+        this.authorities = json.authorities;
+        this.substituteOf = json.substituteOf;
+        this.enabled = json.enabled;
+        this.title = json.displayName || (this.firstname && this.lastname) ? `${this.lastname}, ${this.firstname} (${this.username})` : this.username;
+        this.userSettings = userSettings || { locale: this.DEFAULT_USER_LOCALE };
+    }
+    /**
+     * Gets the users configured client locale
+     * @returns locale string
+     */
+    getClientLocale(fallback) {
+        return this.userSettings?.locale || fallback || this.DEFAULT_USER_LOCALE;
+    }
+    getFullName() {
+        return `${this.lastname}, ${this.firstname}`;
+    }
+    getDisplayNameName() {
+        return `${this.lastname}, ${this.firstname} (${this.username})`;
+    }
+}
+
+var Sort;
+(function (Sort) {
+    Sort["ASC"] = "asc";
+    Sort["DESC"] = "desc";
+})(Sort || (Sort = {}));
+var ClassificationPrefix;
+(function (ClassificationPrefix) {
+    ClassificationPrefix["EMAIL"] = "mailto:";
+    ClassificationPrefix["EMAIL_ICON"] = "envelope";
+    ClassificationPrefix["PHONE"] = "tel:";
+    ClassificationPrefix["PHONE_ICON"] = "phone";
+    ClassificationPrefix["URL"] = "";
+    ClassificationPrefix["URL_ICON"] = "globe";
+})(ClassificationPrefix || (ClassificationPrefix = {}));
+
+class Utils {
+    static optionsToURLParams(options) {
+        if (options) {
+            const searchParams = new URLSearchParams();
+            Object.keys(options).map((k) => searchParams.append(k, options[k]));
+            return `?${searchParams.toString()}`;
+        }
+        return '';
+    }
+    /**
+     * Get all focusable child elements of a host element.
+     * @param host The host/parent element
+     * @returns Array of focusable child elements
+     */
+    static getFocusableChildren(host) {
+        return Array.from(host.querySelectorAll('a[href], button, input, textarea, select, details,[tabindex]:not([tabindex="-1"])')).filter((el) => !el.hasAttribute('disabled') && !el.getAttribute('aria-hidden'));
+    }
+    static hasProperty(o, property) {
+        if (typeof o !== 'object' || o === null) {
+            return false;
+        }
+        return Object.hasOwn(o, property);
+    }
+    static patternToRegExp(pattern) {
+        return new RegExp(pattern.replaceAll('*', '.*'));
+    }
+    /**
+     * Utility method for adding parameters to a given URI.
+     *
+     * @param uri The uri string to attach the parameters to
+     * @param params The object containing parameters to be appended
+     * @returns the given uri extended by the given parameters + remove empty parameters
+     */
+    static buildUri(uri, params) {
+        const q = Object.keys(params)
+            .filter((k) => !Utils.isEmptyOrFalse(params[k]))
+            .map((k) => k + '=' + encodeURIComponent(typeof params[k] === 'object' ? JSON.stringify(params[k]) : params[k]))
+            .join('&');
+        return uri + (q ? '?' + q : '');
+    }
+    static formatMailTo(value, isEmail) {
+        if (isEmail && !!value) {
+            if (Array.isArray(value)) {
+                return value.join().replace(/,/g, '; ');
+            }
+            else {
+                return value.replace(/,/g, '; ');
+            }
+        }
+        return value;
+    }
+    /**
+     * Creates a unique identifier.
+     * @returns A Universally Unique Identifier
+     */
+    static uuid() {
+        return Utils._p8() + Utils._p8(true) + Utils._p8(true) + Utils._p8();
+    }
+    /**
+     * Encode a filename safe for sending chars beyond ASCII-7bit using quoted printable encoding.
+     *
+     * @param filename The file name
+     * @returns The quoted printable filename
+     */
+    static encodeFileName(filename) {
+        const fileName = Utils.encodeToQuotedPrintable(Utils.encodeToUtf8(filename)).replace(/_/g, '=5F');
+        return `=?UTF-8?Q?${fileName}?=`;
+    }
+    /**
+     *
+     * @param boolean s
+     * @return string
+     */
+    static _p8(s) {
+        const p = (Math.random().toString(16) + '000000000').substr(2, 8);
+        return s ? `-${p.substr(0, 4)}-${p.substr(4, 4)}` : p;
+    }
+    /**
+     * Converts a javascript text to the utf-8 converted variant.
+     * See [unicode]{@link http://thlist.onlinehome.de/thomas_homepage/unicode/UTF-8%20Konvertierung%20mittels%20JavaScript.htm} for reference
+     *
+     * @param rawinput The input string
+     * @returns The utf-8 converted string
+     */
+    static encodeToUtf8(rawinput) {
+        /**
+         * Normalize line breaks
+         */
+        rawinput = rawinput.replace(/\r\n/g, '\n');
+        let utfreturn = '';
+        for (let n = 0; n < rawinput.length; n++) {
+            /**
+             * Unicode for current char
+             */
+            const c = rawinput.charCodeAt(n);
+            if (c < 128) {
+                /**
+                 * All chars range 0-127 => 1byte
+                 */
+                utfreturn += String.fromCharCode(c);
+            }
+            else if (c > 127 && c < 2048) {
+                /**
+                 * All chars range from 127 to 2047 => 2byte
+                 */
+                utfreturn += String.fromCharCode((c >> 6) | 192);
+                utfreturn += String.fromCharCode((c & 63) | 128);
+            }
+            else {
+                /**
+                 * All chars range from 2048 to 66536 => 3byte
+                 */
+                utfreturn += String.fromCharCode((c >> 12) | 224);
+                utfreturn += String.fromCharCode(((c >> 6) & 63) | 128);
+                utfreturn += String.fromCharCode((c & 63) | 128);
+            }
+        }
+        return utfreturn;
+    }
+    /**
+     * See [quoted-printable]{@link https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js}
+     **/
+    static quotedPrintable(symbol) {
+        if (symbol > '\xFF') {
+            throw RangeError('`encodeToQuotedPrintable` expects extended ASCII input only. Missing prior UTF-8 encoding?');
+        }
+        const codePoint = symbol.charCodeAt(0);
+        const hexadecimal = codePoint.toString(16).toUpperCase();
+        return '=' + ('0' + hexadecimal).slice(-2);
+    }
+    /**
+     * Encode symbols that are definitely unsafe (i.e. unsafe in any context). The regular expression describes these unsafe symbols.
+     *
+     * @param rawinput Input string to be encoded
+     * @returns The encoded string
+     */
+    static encodeToQuotedPrintable(rawinput) {
+        const encoded = rawinput.replace(/[\0-\b\n-\x1F=\x7F-\uD7FF\uDC00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF]/g, this.quotedPrintable);
+        return encoded;
+    }
+    /**
+     * Sorts An Array of Object by given key
+     * See [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param key
+     * @param order
+     * @param locales
+     * @param options
+     * @returns (a: any, b: any) => number
+     */
+    static sortValues(key = '', order = Sort.ASC, locales, options) {
+        const f = (a, b) => {
+            let comparison;
+            const varA = Utils.getProperty(a, key);
+            const varB = Utils.getProperty(b, key);
+            if (typeof varA === 'number' && typeof varB === 'number') {
+                comparison = varA - varB;
+            }
+            else if (varA instanceof Date && varB instanceof Date) {
+                comparison = new Date(varA).getTime() - new Date(varB).getTime();
+            }
+            else {
+                const stringA = varA || varA === 0 ? varA.toString() : '';
+                const stringB = varB || varB === 0 ? varB.toString() : '';
+                comparison = stringA.localeCompare(stringB, locales, options);
+            }
+            return order === Sort.DESC ? comparison * -1 : comparison;
+        };
+        return f;
+    }
+    /**
+     * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param object
+     * @param string key
+     * @returns any
+     */
+    static getProperty(object, key = '') {
+        const f = key ? key.split('.').reduce((o, k) => (o || {})[k], object) : object;
+        return f;
+    }
+    /**
+     * @param object
+     * @param key
+     * @param value
+     */
+    static setProperty(object, key = '', value) {
+        const [head, ...rest] = key.split('.');
+        !rest.length ? (object[head] = value) : Utils.setProperty(object[head] || (object[head] = {}), value, rest.join('.'));
+    }
+    /**
+     * Use on Observable.catch or Observable.subscribe to return empty value
+     * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param (error) => any callback
+     * @returns (error) => Observable<never>
+     */
+    static empty(callback) {
+        const f = () => {
+            return EMPTY;
+        };
+        return f;
+    }
+    // /**
+    //  * Use on Observable.catch with specific skipNotification function !!!
+    //  * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param skipNotification
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  */
+    // public static catchSkip(skipNotification?: (error: any) => any, callback?: (error: any) => any, name?: string, message?: string) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     const _skipNotification = skipNotification && skipNotification(error);
+    //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, _skipNotification));
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.catch !!!
+    //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => Observable<never>
+    //  */
+    // public static catch(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification));
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.subscribe !!!
+    //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => void
+    //  */
+    // public static throw(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     throw new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification);
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.subscribe only if you want to skip notification / toast!!!
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => void
+    //  */
+    // public static logError(callback?: (error: any) => any, name?: string, message?: string, skipNotification = true) {
+    //   return Utils.throw(callback, name, message, skipNotification);
+    // }
+    // /**
+    //  * Checks if element is visible
+    //  *
+    //  * @param elem
+    //  * @return boolean
+    //  */
+    // public static isVisible(elem: any): boolean {
+    //   return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
+    // }
+    static getBaseHref(removeTrailingSlash) {
+        const baseEl = document.getElementsByTagName('base')[0];
+        const baseHref = baseEl ? baseEl.getAttribute('href') : undefined;
+        return baseHref ? (removeTrailingSlash ? baseHref.substr(0, baseHref.length - 1) : baseHref) : '';
+    }
+    /**
+     * Truncate a string (first argument) if it is longer than the given maximum string length (second argument).
+     * Return the truncated string with a ... ending or whats provided.
+     *
+     * @param string str
+     * @param number num
+     */
+    static truncateString(str, num, ending = '...') {
+        if (str.length > num) {
+            if (num > 3) {
+                num -= 3;
+            }
+            str = `${str.substring(0, num)}${ending}`;
+        }
+        return str;
+    }
+    /**
+     * Get the TimeZone Offsest as minutes
+     */
+    static getTimezoneOffset() {
+        return new Date().getTimezoneOffset();
+    }
+    /**
+     * Transform to date with yyyy-mm-dd format
+     */
+    static transformDate(v) {
+        return v && new Date(new Date(v).getTime() - new Date(v).getTimezoneOffset() * 60 * 1000).toISOString().slice(0, 10);
+    }
+    static isEdge() {
+        return new RegExp('Edge', 'i').test(navigator.userAgent);
+    }
+    static isFirefox() {
+        return new RegExp('firefox', 'i').test(navigator.userAgent);
+    }
+    static isSafari() {
+        return new RegExp('^((?!chrome|android|crios|fxios).)*safari', 'i').test(navigator.userAgent);
+    }
+    static isEmpty(obj) {
+        if (obj == null || obj === '') {
+            return true;
+        }
+        if (typeof obj === 'number') {
+            return isNaN(obj);
+        }
+        return typeof obj === 'boolean' ? false : !Object.keys(obj).length;
+    }
+    static isEmptyOrFalse(val) {
+        return typeof val === 'boolean' ? !val : Utils.isEmpty(val);
+    }
+    static escapeHtml(str) {
+        str = str ? str : '';
+        const entityMap = {
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#39;',
+            '/': '&#x2F;'
+        };
+        return String(str).replace(/[&<>"'\/]/g, (s) => entityMap[s]);
+    }
+    static arrayToObject(arr = [], keyProperty, valueProperty) {
+        const key = typeof keyProperty === 'string' ? (o) => o[keyProperty] : keyProperty;
+        const value = typeof valueProperty === 'string' ? (o) => o[valueProperty] : valueProperty;
+        return arr.reduce((acc, cur, i) => {
+            acc[key ? key(cur) : i] = value ? value(cur) : cur;
+            return acc;
+        }, {});
+    }
+    // public static navigate(newTab: boolean, router: Router, commands: any[], navigationExtras?: NavigationExtras): Promise<any> {
+    //   if (newTab) {
+    //     return new Promise(() => Utils.openWindow(router.serializeUrl(router.createUrlTree(commands, navigationExtras))));
+    //   } else {
+    //     return router.navigate(commands, navigationExtras);
+    //   }
+    // }
+    // public static openWindow(url: string = '', target = '_blank', features?: string): Window | null {
+    //   return window.open(url.match(new RegExp('^/.+')) ? url.replace(new RegExp('^/'), '') : url, target, features); // relative to host
+    // }
+    static downloadBlob(content, mimeType, filename) {
+        const bom = new Uint8Array([0xef, 0xbb, 0xbf]); // FORM BOM
+        const blob = new Blob([bom, content], { type: 'octet/stream' });
+        const a = document.createElement('a');
+        const url = window.URL.createObjectURL(blob);
+        a.setAttribute('href', url);
+        a.setAttribute('download', filename);
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+}
+
+// enumeration of API endpoints provided by the backend
+var ApiBase;
+(function (ApiBase) {
+    ApiBase["core"] = "api";
+    ApiBase["apiWeb"] = "api-web/api";
+    ApiBase["predict"] = "predict-api/api";
+    // TODO: all custom services are deployed using this base
+    ApiBase["custom"] = "custom";
+    ApiBase["none"] = "";
+})(ApiBase || (ApiBase = {}));
+
+/**
+ * @ignore
+ */
+const CUSTOM_CONFIG = new InjectionToken('CUSTOM_CONFIG', {
+    factory: () => ({ main: ['assets/_yuuvis/config/main.json'], translations: ['assets/_yuuvis/i18n/'] })
+});
+const CORE_CONFIG = new InjectionToken('CORE_CONFIG');
+
+/**
+ * @ignore
+ */
+let CoreConfig = class CoreConfig {
+    constructor(__config) {
+        this.main = ['assets/_yuuvis/config/main.json'];
+        this.translations = ['assets/_yuuvis/i18n/'];
+        this.environment = { production: true };
+        Object.assign(this, __config);
+    }
+};
+CoreConfig = __decorate([
+    __param(0, Inject(CUSTOM_CONFIG)),
+    __metadata("design:paramtypes", [CoreConfig])
+], CoreConfig);
+
+class OidcService {
+    constructor(oAuthConfig, config, oauthService) {
+        this.oAuthConfig = oAuthConfig;
+        this.config = config;
+        this.oauthService = oauthService;
+    }
+    initOpenIdConnect(oidc) {
+        oidc = this.config.oidc = oidc || this.config.oidc;
+        if (oidc?.host) {
+            oidc.host = oidc.host.endsWith('/') ? oidc.host.substring(0, -1) : oidc.host;
+        }
+        else
+            return of(undefined);
+        this.oAuthConfig.resourceServer = {
+            sendAccessToken: true,
+            allowedUrls: [oidc.host]
+        };
+        const authConfig = {
+            strictDiscoveryDocumentValidation: false,
+            issuer: oidc.issuer,
+            redirectUri: oidc.redirectUri || window.location.origin + '/',
+            postLogoutRedirectUri: oidc.postLogoutRedirectUri || window.location.origin + '/',
+            clientId: oidc.clientId,
+            responseType: 'code',
+            scope: 'openid profile email offline_access',
+            showDebugInformation: false,
+            requireHttps: false,
+            disableAtHashCheck: true,
+            sessionCheckIntervall: 60000,
+            sessionChecksEnabled: true,
+            clearHashAfterLogin: false,
+            silentRefreshTimeout: 5000 // For faster testing
+        };
+        this.oauthService.configure(authConfig);
+        this.oauthService.setupAutomaticSilentRefresh();
+        return from(this.oauthService.loadDiscoveryDocumentAndLogin()).pipe(map(() => this.config.oidc));
+    }
+    logout() {
+        this.oauthService.logOut();
+    }
+    setupCookie(viewer, path, headers) {
+        return new Observable((subscriber) => {
+            let iframe = document.querySelector('body > iframe#__oidc');
+            if (!iframe) {
+                iframe = document.createElement('iframe');
+                iframe.style.display = 'none';
+                iframe.id = '__oidc';
+                iframe.onload = () => {
+                    iframe.subscriber.next({});
+                    iframe.subscriber.complete();
+                };
+            }
+            iframe.subscriber = subscriber;
+            iframe.setAttribute('src', `${viewer}/download?setCookie=/&path=${encodeURIComponent(path)}&headers=${encodeURIComponent(JSON.stringify(headers))}`);
+            document.body.appendChild(iframe);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, deps: [{ token: i1.OAuthModuleConfig, optional: true }, { token: CORE_CONFIG }, { token: i1.OAuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.OAuthModuleConfig, decorators: [{
+                    type: Optional
+                }] }, { type: CoreConfig, decorators: [{
+                    type: Inject,
+                    args: [CORE_CONFIG]
+                }] }, { type: i1.OAuthService }] });
+
+/**
+ * Load and provide configuration for hole apllication while application is inizialized.
+ */
+class ConfigService {
+    constructor() {
+        this.translate = inject(TranslateService);
+        this.oidcService = inject(OidcService);
+    }
+    static { this.GLOBAL_RESOURCES = '/resources/config/'; }
+    static PARSER(c) {
+        return c?.resolved || c?.tenant || c?.global || c || {};
+    }
+    static GLOBAL_MAIN_CONFIG(prefix = '') {
+        return ConfigService.GLOBAL_RESOURCES_PATH('main-config', prefix);
+    }
+    static GLOBAL_MAIN_CONFIG_LANG(iso = 'en', prefix = '') {
+        return ConfigService.GLOBAL_RESOURCES_PATH('main-config-language-' + iso, prefix);
+    }
+    static GLOBAL_RESOURCES_PATH(section = '', prefix = '') {
+        return (prefix ? `/${prefix}` : '') + ConfigService.GLOBAL_RESOURCES + encodeURIComponent(section) + '?filter=resolved';
+    }
+    get oidc() {
+        return this.oidcService.config?.oidc;
+    }
+    /**
+     * Set during app init (see CoreInit)
+     * @ignore
+     */
+    set(cfg) {
+        this.cfg = cfg;
+        const languages = this.getClientLocales().map((lang) => lang.iso);
+        this.translate.addLangs(languages);
+        const browserLang = this.translate.getBrowserLang();
+        const defaultLang = browserLang && languages.includes(browserLang) ? browserLang : this.getDefaultClientLocale();
+        this.translate.setDefaultLang(defaultLang);
+        this.translate.use(defaultLang);
+        this.extendTranslations(defaultLang);
+    }
+    get(configKey) {
+        return configKey ? Utils.getProperty(this.cfg, configKey) : null;
+    }
+    extendTranslations(translations, lang = this.translate.currentLang) {
+        const allKeys = translations && Object.keys(this.translate.store?.translations[lang] || {});
+        if (translations && !Object.keys(translations).every((k) => allKeys.includes(k))) {
+            this.translate.setTranslation(lang, translations, true);
+        }
+    }
+    extendConfig(configs) {
+        this.set(this._mergeConfigs(configs || []));
+    }
+    _mergeConfigs(configs) {
+        return configs.reduce((acc, x) => {
+            // merge object values on 2nd level
+            Object.keys(x).forEach((k) => (!acc[k] || Array.isArray(x[k]) || typeof x[k] !== 'object' ? (acc[k] = x[k]) : Object.assign(acc[k], x[k])));
+            return acc;
+        }, {});
+    }
+    authUsesOpenIdConnect() {
+        return !!this.oidc?.host && !!this.oidc?.tenant;
+    }
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders(authorization = false) {
+        if (this.authUsesOpenIdConnect()) {
+            let headers = new HttpHeaders().set(TENANT_HEADER, this.oidc.tenant);
+            if (authorization) {
+                headers = headers.set('authorization', 'Bearer ' + localStorage.getItem('access_token'));
+            }
+            return headers;
+        }
+        return new HttpHeaders();
+    }
+    /**
+     * Getter for the available client locales
+     * @returns available client locales
+     */
+    getClientLocales() {
+        return this._getCoreConfig('languages');
+    }
+    getApiBase(api = ApiBase.apiWeb, origin = false) {
+        api = api || ApiBase.none;
+        const href = api === ApiBase.none ? api : `/${api}`;
+        const host = this.oidc?.host || (origin && location.origin) || '';
+        return href.startsWith('http') ? href : host + href;
+    }
+    /**
+     * Get the default client locale
+     * @returns ISO string of the locale
+     */
+    getDefaultClientLocale() {
+        const lang = this.getClientLocales().find((_) => _.fallback);
+        return lang ? lang.iso : 'en';
+    }
+    _getCoreConfig(key) {
+        return this.cfg ? this.cfg.core[key] : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Set up the default logger.
+ * The default logger doesn't actually log anything;
+ * but, it provides the Dependency-Injection (DI) token that the rest of the
+ * application can use for dependency resolution. Each platform can then override
+ * this with a platform-specific logger implementation.
+ *
+ * @ignore
+ */
+class Logger {
+    error(...args) {
+        // ... the default logger does no work.
+    }
+    debug(...args) {
+        // ... the default logger does no work.
+    }
+    info(...args) {
+        // ... the default logger does no work.
+    }
+    log(...args) {
+        // ... the default logger does no work.
+    }
+    warn(...args) {
+        // ... the default logger does no work.
+    }
+}
+
+/**
+ * Service for providing an yuuvis Backend
+ */
+class BackendService {
+    constructor() {
+        this.#http = inject(HttpClient);
+        this.#logger = inject(Logger);
+        this.configService = inject(ConfigService);
+        this.#cache = new Map();
+        this.#temp = new Map();
+        this.#headers = new HttpHeaders({
+            'Content-Type': 'application/json'
+        });
+    }
+    #http;
+    #logger;
+    #cache;
+    #temp;
+    #headers;
+    authUsesOpenIdConnect() {
+        return this.configService.authUsesOpenIdConnect();
+    }
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders() {
+        return this.configService.getAuthHeaders();
+    }
+    /**
+     * Add a new header.
+     * @param key The headers name
+     * @param value The value to be added to the headers. Setting this to null
+     * will remove the header
+     */
+    setHeader(key, value) {
+        if (value && value.length) {
+            this.#headers = this.#headers.set(key, value);
+        }
+        else {
+            this.#headers = this.#headers.delete(key);
+        }
+    }
+    /**
+     * Wrapped HTTP GET method
+     * @param uri The REST URI to be queried
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The data retrieved from the given endpoint
+     */
+    get(uri, base, requestOptions) {
+        return this.#http.get(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP POST method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    post(uri, data, base, requestOptions) {
+        const baseUri = this.getApiBase(base);
+        const payload = data && typeof data === 'object' ? JSON.stringify(data) : data || '';
+        return this.#http.post(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Performs a multipart form data POST request.
+     * @param uri The target REST URI
+     * @param formData FormData to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    postMultiPart(uri, formData, base, requestOptions) {
+        return this.#http.post(`${this.getApiBase(base)}${uri}`, formData, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP PATCH method
+     * @param uri The target REST URI
+     * @param data Data to be 'patched'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PATCH endpoint
+     */
+    patch(uri, data, base, requestOptions) {
+        const baseUri = this.getApiBase(base);
+        const payload = data ? JSON.stringify(data) : '';
+        return this.#http.patch(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP PUT method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PUT endpoint
+     */
+    put(uri, data, base, requestOptions) {
+        return this.#http.put(this.getApiBase(base) + uri, data, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP DELETE method
+     * @param uri The target REST URI
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target DELETE endpoint
+     */
+    delete(uri, base, requestOptions) {
+        return this.#http.delete(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * @ignore
+     * Cache for small requests like icons and configs
+     *
+     * @param string uri
+     * @returns Observable<any>
+     */
+    getViaCache(uri) {
+        if (this.#cache.has(uri)) {
+            return of(this.#cache.get(uri));
+        }
+        else {
+            const requestOptions = {
+                responseType: 'text',
+                headers: this.getAuthHeaders()
+            };
+            return this.getViaTempCache(uri, () => this.#http.get(uri, requestOptions).pipe(tap((text) => this.#cache.set(uri, text))));
+        }
+    }
+    /**
+     * @ignore
+     * Temporary Cache for multiple identical requests
+     *
+     * @param string id
+     * @param Function request
+     * @returns Observable<any>
+     */
+    getViaTempCache(id, request) {
+        if (this.#temp.has(id)) {
+            return this.#temp.get(id);
+        }
+        else {
+            const resp = (request ? request() : this.get(id)).pipe(finalize(() => this.#temp.delete(id)), shareReplay(1));
+            this.#temp.set(id, resp);
+            return resp;
+        }
+    }
+    download(uri, filename) {
+        if (document && document.body) {
+            const a = document.createElement('a');
+            a.setAttribute('href', uri);
+            a.style.display = 'none';
+            a.setAttribute('download', filename || 'download');
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+        else {
+            this.#logger.error('Environment not supported. Downloading contents relies on a DOM being available.');
+        }
+    }
+    /**
+     * Gets the base URI for an API endpoint
+     * @param api The API to get the base URI for. Leaving this blank will return
+     * base URI for the web API
+     * @param origin The flag to include location origin
+     * @returns Base URI for the given API.
+     */
+    getApiBase(api = ApiBase.apiWeb, origin = false) {
+        return this.configService.getApiBase(api, origin);
+    }
+    /**
+     * @ignore
+     */
+    getHttpOptions(requestOptions) {
+        // Object.entries(this.getAuthHeaders()).forEach(([h, v]) => this.setHeader(h, v as string));
+        this.getAuthHeaders()
+            .keys()
+            .forEach((k) => this.setHeader(k, this.getAuthHeaders().get(k)));
+        return Object.assign({ headers: this.#headers }, requestOptions);
+    }
+    /**
+     * Batch service
+     */
+    batch(requests) {
+        const httpRequests = requests.map((r) => this[(r.method || 'get').toLowerCase()]
+            .apply(this, [r.uri, r.body, r.base, r.requestOptions].filter((a) => a))
+            .pipe(catchError((err) => of({ _error: err }))));
+        return forkJoin(httpRequests);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class SearchService {
+    #backend = inject(BackendService);
+    static { this.DEFAULT_QUERY_SIZE = 50; }
+    /**
+     * Execute a search query ans transform the result to a SearchResult object
+     * @param query The search query
+     * @returns Observable of a SearchResult
+     */
+    search(query) {
+        return this.searchRaw(query).pipe(map((res) => this.toSearchResult(res)));
+    }
+    /**
+     * Execute a raw search query and return the result as is.
+     * @param query The search query
+     * @returns Observable of the raw search result
+     */
+    searchRaw(query) {
+        if (!query.size)
+            query.size = SearchService.DEFAULT_QUERY_SIZE;
+        return this.#backend.post(`/dms/objects/search`, query);
+    }
+    /**
+     * Search for objects in the dms using CMIS like SQL syntax.
+     * @param statement The query statement
+     * @param size The number of items to return
+     * @returns Observable of a SearchResult
+     */
+    searchCmis(statement, size = 50) {
+        return this.#backend
+            .post('/dms/objects/search', {
+            query: {
+                statement,
+                skipCount: 0,
+                maxItems: size,
+                handleDeletedDocuments: 'DELETED_DOCUMENTS_EXCLUDE'
+            }
+        }
+        // Using API-WEB because it enriches the response with additional information (resolved user names, etc.)
+        // ApiBase.core
+        )
+            .pipe(map((res) => this.toSearchResult(res)));
+    }
+    /**
+     * Fetch aggragations for a given query.
+     * @param q The query
+     * @param aggregations List of aggregations to be fetched (e.g. `enaio:objectTypeId`
+     * to get an aggregation of object types)
+     */
+    aggregate(q, aggregations) {
+        q.aggs = aggregations;
+        return this.searchRaw(q).pipe(map((res) => this.#toAggregateResult(res, aggregations)));
+    }
+    /**
+     * Map search result from the backend to applications AggregateResult object
+     * @param searchResponse The backend response
+     * @param aggregations The aggregations to be fetched
+     */
+    #toAggregateResult(searchResponse, aggregations) {
+        const agg = [];
+        if (aggregations) {
+            aggregations.forEach((a) => {
+                const ag = {
+                    aggKey: a,
+                    entries: searchResponse.objects.map((o) => ({
+                        key: o.properties[a].value,
+                        count: o.properties['OBJECT_COUNT'].value
+                    }))
+                };
+                agg.push(ag);
+            });
+        }
+        return {
+            totalNumItems: searchResponse.totalNumItems,
+            aggregations: agg
+        };
+    }
+    /**
+     * Go to a page of a search result.
+     * @param searchResult The search result (that supports pagination)
+     * @param page The number of the page to go to
+     */
+    getPage(query, page) {
+        query.from = (page - 1) * (query.size || SearchService.DEFAULT_QUERY_SIZE);
+        return this.search(query);
+    }
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse) {
+        const resultListItems = [];
+        const objectTypes = [];
+        searchResponse.objects.forEach((o) => {
+            const fields = new Map();
+            // process properties section of result
+            Object.keys(o.properties).forEach((key) => {
+                let value = o.properties[key].value;
+                if (o.properties[key].clvalue) {
+                    // table fields will have a clientValue too ...
+                    value = o.properties[key].clvalue;
+                    // ... and also may contain values that need to be resolved
+                    if (o.properties[key].resolvedValues) {
+                        value.forEach((v) => {
+                            Object.keys(v).forEach((k) => {
+                                const resValue = Array.isArray(v[k]) ? v[k].map((i) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];
+                                if (resValue) {
+                                    v[`${k}_title`] = resValue;
+                                }
+                            });
+                        });
+                    }
+                }
+                fields.set(key, value);
+                if (o.properties[key].title) {
+                    fields.set(key + '_title', o.properties[key].title);
+                }
+            });
+            // process contentStreams section of result if available.
+            // Objects that don't have files attached won't have this section
+            let content;
+            if (o.contentStreams && o.contentStreams.length > 0) {
+                // we assume that each result object only has ONE file attached, altough
+                // this is an array and there may be more
+                const contentStream = o.contentStreams[0];
+                // also add contentstream related fields to the result fields
+                fields.set(ContentStreamField.LENGTH, contentStream.length);
+                fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);
+                fields.set(ContentStreamField.FILENAME, contentStream.fileName);
+                fields.set(ContentStreamField.ID, contentStream.contentStreamId);
+                fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);
+                fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);
+                fields.set(ContentStreamField.DIGEST, contentStream.digest);
+                fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);
+                content = {
+                    contentStreamId: contentStream.contentStreamId,
+                    repositoryId: contentStream.repositoryId,
+                    range: contentStream.range,
+                    digest: contentStream.digest,
+                    archivePath: contentStream.archivePath,
+                    fileName: contentStream.fileName,
+                    mimeType: contentStream.mimeType,
+                    size: contentStream.length
+                };
+            }
+            const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;
+            if (objectTypes.indexOf(objectTypeId) === -1) {
+                objectTypes.push(objectTypeId);
+            }
+            resultListItems.push({
+                objectTypeId,
+                content,
+                fields,
+                permissions: o.permissions
+            });
+        });
+        const result = {
+            hasMoreItems: searchResponse.hasMoreItems,
+            totalNumItems: searchResponse.totalNumItems,
+            items: resultListItems,
+            objectTypes
+        };
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+var Operator;
+(function (Operator) {
+    Operator["EQUAL"] = "eq";
+    Operator["EEQUAL"] = "eeq";
+    Operator["IN"] = "in";
+    Operator["GREATER_THAN"] = "gt";
+    Operator["GREATER_OR_EQUAL"] = "gte";
+    Operator["LESS_THAN"] = "lt";
+    Operator["LESS_OR_EQUAL"] = "lte";
+    Operator["INTERVAL"] = "gtlt";
+    Operator["INTERVAL_INCLUDE_BOTH"] = "gtelte";
+    Operator["INTERVAL_INCLUDE_TO"] = "gtlte";
+    Operator["INTERVAL_INCLUDE_FROM"] = "gtelt";
+    Operator["RANGE"] = "rg";
+    Operator["LIKE"] = "like";
+    Operator["CONTAINS"] = "contains"; // contains
+})(Operator || (Operator = {}));
+const OperatorLabel = {
+    /** equal */
+    EQUAL: '=',
+    /** exact equal */
+    EEQUAL: '==',
+    /** match at least one of the provided values (value has to be an array)  */
+    IN: '~',
+    /** greater than */
+    GREATER_THAN: '>',
+    /** greater than or equal */
+    GREATER_OR_EQUAL: '≽', //
+    LESS_THAN: '<', // less than
+    LESS_OR_EQUAL: '≼', // less than or equal
+    INTERVAL: '<>', // interval
+    INTERVAL_INCLUDE_BOTH: '-', // interval include left and right
+    INTERVAL_INCLUDE_TO: '>-', // interval include right
+    INTERVAL_INCLUDE_FROM: '-<', // interval include left
+    RANGE: '=', // aggegation ranges
+    LIKE: '~', // like
+    CONTAINS: '~' // contains
+};
+
+var Direction;
+(function (Direction) {
+    Direction["LTR"] = "ltr";
+    Direction["RTL"] = "rtl";
+})(Direction || (Direction = {}));
+
+/**
+ * Service for providing triggered events
+ */
+class EventService {
+    constructor() {
+        this.#eventSource = new Subject();
+        this.event$ = this.#eventSource.asObservable();
+    }
+    #eventSource;
+    /**
+     * Trigger an global event
+     * @param type Type/key of the event
+     * @param data Data to be send along with the event
+     */
+    trigger(type, data) {
+        this.#eventSource.next({ type, data });
+    }
+    /**
+     * Listen on a triggered event
+     * @param types Type/key of the event
+     */
+    on(...types) {
+        return this.event$.pipe(filter((event) => event && !!types.find((t) => t === event.type)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Events emitted by parts of the application
+ */
+var YuvEventType;
+(function (YuvEventType) {
+    YuvEventType["LOGOUT"] = "yuv.user.logout";
+    YuvEventType["CLIENT_LOCALE_CHANGED"] = "yuv.user.locale.client.changed";
+    YuvEventType["DMS_OBJECT_LOADED"] = "yuv.dms.object.loaded";
+    YuvEventType["DMS_OBJECT_CREATED"] = "yuv.dms.object.created";
+    YuvEventType["DMS_OBJECT_DELETED"] = "yuv.dms.object.deleted";
+    YuvEventType["DMS_OBJECT_UPDATED"] = "yuv.dms.object.updated";
+    YuvEventType["DMS_OBJECTS_MOVED"] = "yuv.dms.objects.moved";
+})(YuvEventType || (YuvEventType = {}));
+
+/**
+ * Service for saving or caching data on the users device. It uses the most efficient storage
+ * available  (IndexDB, localstorage, ...) on the device. Depending on the type of storage used,
+ * its limitations apply.
+ */
+class AppCacheService {
+    #storage = inject(StorageMap);
+    setItem(key, value) {
+        return this.#storage.set(key, value).pipe(map(() => true));
+    }
+    getItem(key) {
+        return this.#storage.get(key);
+    }
+    removeItem(key) {
+        return this.#storage.delete(key).pipe(map(() => true));
+    }
+    clear(filter) {
+        return filter
+            ? this.getStorageKeys().pipe(switchMap((keys) => {
+                const list = keys.filter((k) => filter(k)).map((k) => this.removeItem(k));
+                return list.length ? forkJoin(list).pipe(map(() => true)) : of(true);
+            }))
+            : this.#storage.clear().pipe(map(() => true));
+    }
+    getStorageKeys() {
+        return new Observable((observer) => {
+            const keys = [];
+            this.#storage.keys().subscribe({
+                next: (key) => keys.push(key),
+                complete: () => observer.next(keys)
+            });
+        }).pipe(first());
+    }
+    setStorage(options) {
+        return forkJoin(Object.keys(options || {}).map((k) => this.setItem(k, options[k])));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Providing system definitions.
+ */
+class SystemService {
+    constructor() {
+        this.#backend = inject(BackendService);
+        this.#appCache = inject(AppCacheService);
+        this.#logger = inject(Logger);
+        this.#STORAGE_KEY = 'yuv.core.system.definition';
+        this.#STORAGE_KEY_AUTH_DATA = 'yuv.core.auth.data';
+        // cached icons to avoid backend calls (session cache)
+        this.#iconCache = {};
+        this.#resolvedClassificationsCache = {};
+        this.#systemSource = new ReplaySubject();
+        this.system$ = this.#systemSource.asObservable();
+        // cache for resolved visible tags because they are used in lists and therefore should not be re-evaluated all the time
+        this.#visibleTagsCache = {};
+    }
+    #backend;
+    #appCache;
+    #logger;
+    #STORAGE_KEY;
+    #STORAGE_KEY_AUTH_DATA;
+    // cached icons to avoid backend calls (session cache)
+    #iconCache;
+    #resolvedClassificationsCache;
+    #systemSource;
+    // cache for resolved visible tags because they are used in lists and therefore should not be re-evaluated all the time
+    #visibleTagsCache;
+    #permissions;
+    /**
+     * Get all object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getObjectTypes(withLabels, situation) {
+        // Filter by user permissions based on situation
+        const objectTypes = this.#filterByPermissions([...this.system.objectTypes, ...this.system.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot))], situation);
+        return withLabels ? objectTypes.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : objectTypes;
+    }
+    #sotToGenericType(sot) {
+        return {
+            ...sot,
+            isFolder: false,
+            creatable: true,
+            secondaryObjectTypes: [],
+            isSot: true
+        };
+    }
+    /**
+     * Get all secondary object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getSecondaryObjectTypes(withLabels, situation) {
+        const sots = this.#filterByPermissions(this.system.secondaryObjectTypes.map((sot) => this.#sotToGenericType(sot)), situation);
+        return ((withLabels ? sots.map((t) => ({ ...t, label: this.getLocalizedResource(`${t.id}_label`) })) : sots)
+            // ignore
+            .filter((t) => t.id !== t.baseId && !t.id.startsWith('system:') && t.id !== 'appClientsystem:leadingType'));
+    }
+    #filterByPermissions(types, situation) {
+        if (!situation)
+            return types;
+        const allowedTypes = situation === 'search' ? this.#permissions.searchableObjectTypes : this.#permissions.createableObjectTypes;
+        return types.filter((t) => allowedTypes.includes(t.id));
+    }
+    /**
+     * Get a particular object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getObjectType(objectTypeId, withLabel) {
+        let objectType = objectTypeId === SystemType.OBJECT ? this.getBaseType() : this.system.objectTypes.find((ot) => ot.id === objectTypeId);
+        if (objectType && withLabel) {
+            objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectTypeId;
+        }
+        if (!objectType) {
+            // no 'real' object type found. Try to find a matching SOT and treat it like a real type
+            // by filling up the missing properties
+            const sot = this.getSecondaryObjectType(objectTypeId, withLabel);
+            if (sot) {
+                objectType = this.#sotToGenericType(sot);
+            }
+        }
+        return objectType;
+    }
+    /**
+     * Get a particular secondary object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getSecondaryObjectType(objectTypeId, withLabel) {
+        const objectType = this.system.secondaryObjectTypes.find((ot) => ot.id === objectTypeId);
+        if (objectType && withLabel) {
+            objectType.label = this.getLocalizedResource(`${objectType.id}_label`) || objectType.id;
+        }
+        return objectType;
+    }
+    /**
+     * Get the base document type all documents belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseDocumentType(withLabel) {
+        return this.getObjectType(SystemType.DOCUMENT, withLabel);
+    }
+    /**
+     * Get the base folder type all folders belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseFolderType(withLabel) {
+        return this.getObjectType(SystemType.FOLDER, withLabel);
+    }
+    /**
+     * Get the base object type all dms objects belong to
+     */
+    getBaseType() {
+        const sysFolder = this.getBaseFolderType();
+        const sysDocument = this.getBaseDocumentType();
+        // base type contains only fields that are shared by base document and base folder ...
+        const folderTypeFieldIDs = sysFolder.fields.map((f) => f.id);
+        const baseTypeFields = sysDocument.fields.filter((f) => folderTypeFieldIDs.includes(f.id));
+        return {
+            id: SystemType.OBJECT,
+            creatable: false,
+            isFolder: false,
+            secondaryObjectTypes: [],
+            fields: baseTypeFields
+            // rawFields: baseTypeFields
+        };
+    }
+    /**
+     * Get the resolved object type with all fields ( including fields from related secondary types )
+     */
+    getResolvedType(objectTypeId) {
+        const abstractTypes = Object.values(SystemType);
+        if (!objectTypeId || abstractTypes.includes(objectTypeId)) {
+            const baseType = this.getBaseType();
+            return { id: baseType.id, fields: baseType.fields };
+        }
+        const ot = this.getObjectType(objectTypeId);
+        if (!ot) {
+            const sot = this.getSecondaryObjectType(objectTypeId) || { id: objectTypeId, fields: [] };
+            const baseType = this.getBaseType();
+            return {
+                id: sot.id,
+                fields: [...sot.fields, ...baseType.fields]
+            };
+        }
+        return {
+            id: ot.id,
+            fields: ot.fields
+        };
+    }
+    /**
+     * Get the resolved object tags
+     */
+    getResolvedTags(objectTypeId) {
+        const vTags = this.getVisibleTags(objectTypeId);
+        return Object.keys(vTags).map((k) => ({
+            id: objectTypeId,
+            tagName: k,
+            tagValues: vTags[k],
+            fields: this.getBaseType().fields.filter((f) => f.id === BaseObjectTypeField.TAGS)
+        }));
+    }
+    /**
+     * Get a list of classifications for a given object type including the
+     * classifications of its static secondary object types
+     * @param objectTypeId ID of the object type
+     */
+    getResolvedClassifications(objectTypeId) {
+        return this.#resolvedClassificationsCache[objectTypeId] || this.#resolveClassifications(objectTypeId);
+    }
+    #resolveClassifications(objectTypeId) {
+        let classifications = [];
+        const ot = this.getObjectType(objectTypeId);
+        if (ot) {
+            classifications = ot.classification || [];
+            const staticSOTs = ot.secondaryObjectTypes ? ot.secondaryObjectTypes.filter((sot) => sot.static).map((sot) => sot.id) : [];
+            staticSOTs.forEach((id) => {
+                const sot = this.getSecondaryObjectType(id);
+                classifications = sot?.classification
+                    ? [
+                        ...classifications,
+                        ...sot.classification.filter((c) => {
+                            // also filter classifications that should not be inherited
+                            return c !== ObjectTypeClassification.CREATE_FALSE && c !== ObjectTypeClassification.SEARCH_FALSE;
+                        })
+                    ]
+                    : classifications;
+            });
+            this.#resolvedClassificationsCache[objectTypeId] = classifications;
+        }
+        return classifications;
+    }
+    /**
+     * Visible tags are defined by a classification on the object type (e.g. 'tag[tenkolibri:process,1,2,3]').
+     *
+     * The example will only return tags with the name 'tenkolibri:process'
+     * and values of either 1, 2 or 3. All other tags will be ignored.
+     *
+     * @param objectTypeId ID of the object type to get the visible tags for
+     * @returns object where the property name is the name of the tag and its value are the visible values
+     * for that tag (if values is emoty all values are allowed)
+     */
+    getVisibleTags(objectTypeId) {
+        return this.#visibleTagsCache[objectTypeId] || this.fetchVisibleTags(objectTypeId);
+    }
+    fetchVisibleTags(objectTypeId) {
+        const ot = this.getObjectType(objectTypeId) || this.getSecondaryObjectType(objectTypeId);
+        const tagClassifications = this.getResolvedClassifications(objectTypeId).filter((t) => t.startsWith('tag['));
+        const parentType = ot && ot.id;
+        const to = {};
+        (tagClassifications || []).forEach((tag) => {
+            const m = tag.match(/\[(.*)\]/i)[1].split(',');
+            const tagName = m.splice(0, 1)[0];
+            const tagValues = m.map((v) => parseInt(v.trim()));
+            to[tagName] = tagValues;
+        });
+        this.#visibleTagsCache[objectTypeId] = parentType ? { ...this.getVisibleTags(parentType), ...to } : to;
+        return this.#visibleTagsCache[objectTypeId];
+    }
+    filterVisibleTags(objectTypeId, tagsValue) {
+        if (!tagsValue)
+            return [];
+        const vTags = this.getVisibleTags(objectTypeId);
+        // Tag value looks like this: [tagName: string, state: number, date: Date, traceId: string]
+        return tagsValue.filter((v) => !!vTags[v[0]] && vTags[v[0]].includes(v[1]));
+    }
+    /**
+     * Get the icon for an object type. This will return an SVG as a string.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIcon(objectTypeId, fallback) {
+        if (this.#iconCache[objectTypeId] && this.#iconCache[objectTypeId].icon) {
+            return of(this.#iconCache[objectTypeId].icon);
+        }
+        else {
+            const iconUri = this.getObjectTypeIconUri(objectTypeId, fallback);
+            return this.#backend.get(iconUri).pipe(tap((icon) => (this.#iconCache[objectTypeId] = { uri: iconUri, icon })));
+        }
+    }
+    /**
+     * Get the URI of an object type icon.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIconUri(objectTypeId, fallback) {
+        if (this.#iconCache[objectTypeId]) {
+            return this.#iconCache[objectTypeId].uri;
+        }
+        else {
+            const ci = this.#getIconFromClassification(objectTypeId);
+            const fb = this.getFallbackIcon(objectTypeId, fallback);
+            const uri = `/resources/icons/${encodeURIComponent(ci || objectTypeId)}${fb ? `?fallback=${encodeURIComponent(fb)}` : ''}`;
+            this.#iconCache[objectTypeId] = { uri: `${this.#backend.getApiBase(ApiBase.apiWeb)}${uri}` };
+            return this.#iconCache[objectTypeId].uri;
+        }
+    }
+    getFallbackIcon(objectTypeId, fallback) {
+        const ot = this.getObjectType(objectTypeId);
+        if (ot && !fallback) {
+            // add default fallbacks for system:document and system:folder if now other fallback has been provided
+            fallback = ot.isFolder ? 'system:folder' : 'system:document';
+            // if (this.isFloatingObjectType(ot)) {
+            //   // types that do not have no object type assigned to them (primary FSOTs)
+            //   fallback = 'system:dlm';
+            // }
+        }
+        return fallback;
+    }
+    #getIconFromClassification(objectTypeId) {
+        const ce = this.getClassifications(this.getResolvedClassifications(objectTypeId));
+        return ce.has(ObjectTypeClassification.OBJECT_TYPE_ICON) ? ce.get(ObjectTypeClassification.OBJECT_TYPE_ICON).options[0] : null;
+    }
+    getLocalizedResource(key) {
+        return this.system.i18n[key];
+    }
+    getLocalizedLabel(id) {
+        return this.getLocalizedResource(`${id}_label`);
+    }
+    getLocalizedDescription(id) {
+        return this.getLocalizedResource(`${id}_description`);
+    }
+    /**
+     * Determine whether or not the given object type field is a system field
+     * @param field Object type field to be checked
+     */
+    isSystemProperty(field) {
+        return field.id.startsWith('system:');
+    }
+    /**
+     * Fetches the backends system definition and updates system$ Observable.
+     * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the
+     * system definition every time.
+     *
+     * @param user The user to load the system definition for
+     */
+    getSystemDefinition(authData) {
+        // TODO: Supposed to return 304 if nothing changes
+        return this.#fetchSystemDefinition(authData);
+        // TODO: remove when 304 is there???
+        // // try to fetch system definition from cache first
+        // return this.appCache.getItem(this.STORAGE_KEY).pipe(
+        //   switchMap(res => {
+        //     if (res) {
+        //       // check if the system definition from the cache is up to date
+        //       this.system = res;
+        //       this.systemSource.next(this.system);
+        //       return of(true);
+        //     } else {
+        //       // nothing cached so far
+        //       return this.fetchSystemDefinition();
+        //     }
+        //   })
+        // );
+    }
+    /**
+     * Actually fetch the system definition from the backend.
+     * @param user User to fetch definition for
+     */
+    #fetchSystemDefinition(authData) {
+        return (authData ? of(authData) : this.#appCache.getItem(this.#STORAGE_KEY_AUTH_DATA)).pipe(switchMap((data) => {
+            this.updateAuthData(data).subscribe();
+            const fetchTasks = [this.#backend.get('/dms/schema/native.json', ApiBase.core), this.#fetchLocalizations()];
+            return forkJoin(fetchTasks);
+        }), catchError((error) => {
+            this.#logger.error('Error fetching recent version of system definition from server.', error);
+            this.#systemSource.error('Error fetching recent version of system definition from server.');
+            return of(null);
+        }), map((data) => {
+            if (data?.length) {
+                this.setSchema(data[0], data[1]);
+            }
+            return !!data;
+        }));
+    }
+    setPermissions(p) {
+        this.#permissions = p;
+    }
+    /**
+     * Create the schema from the servers schema response
+     * @param schemaResponse Response from the backend
+     */
+    setSchema(schemaResponse, localizedResource = {}) {
+        // prepare a quick access object for the fields
+        const propertiesQA = {};
+        const orgTypeFields = [BaseObjectTypeField.MODIFIED_BY, BaseObjectTypeField.CREATED_BY];
+        schemaResponse.propertyDefinition.forEach((p) => {
+            p.classifications = p.classification;
+            // TODO: Remove once schema supports organization classification for base params
+            // map certain fields to organization type (fake it until you make it ;-)
+            if (orgTypeFields.includes(p.id)) {
+                p.classifications = [Classification.STRING_ORGANIZATION];
+            }
+            propertiesQA[p.id] = p;
+        });
+        // prepare a quick access object for object types (including secondary objects)
+        const objectTypesQA = {};
+        schemaResponse.typeFolderDefinition.forEach((ot) => {
+            objectTypesQA[ot.id] = ot;
+        });
+        schemaResponse.typeDocumentDefinition.forEach((ot) => {
+            objectTypesQA[ot.id] = ot;
+        });
+        schemaResponse.typeSecondaryDefinition.forEach((sot) => {
+            objectTypesQA[sot.id] = sot;
+        });
+        const objectTypes = [
+            // folder types
+            ...schemaResponse.typeFolderDefinition.map((fd) => ({
+                id: fd.id,
+                description: fd.description,
+                classification: fd.classification,
+                baseId: fd.baseId,
+                creatable: this.#isCreatable(fd.id),
+                contentStreamAllowed: ContentStreamAllowed.NOT_ALLOWED,
+                isFolder: true,
+                secondaryObjectTypes: fd.secondaryObjectTypeId ? fd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],
+                fields: this.#resolveObjectTypeFields(fd, propertiesQA, objectTypesQA)
+                // rawFields: this.resolveObjectTypeFields(fd, propertiesQA, objectTypesQA, true),
+            })),
+            // document types
+            ...schemaResponse.typeDocumentDefinition.map((dd) => ({
+                id: dd.id,
+                description: dd.description,
+                classification: dd.classification,
+                baseId: dd.baseId,
+                creatable: this.#isCreatable(dd.id),
+                contentStreamAllowed: dd.contentStreamAllowed,
+                isFolder: false,
+                secondaryObjectTypes: dd.secondaryObjectTypeId ? dd.secondaryObjectTypeId.map((t) => ({ id: t.value, static: t.static })) : [],
+                fields: this.#resolveObjectTypeFields(dd, propertiesQA, objectTypesQA)
+                // rawFields: this.resolveObjectTypeFields(dd, propertiesQA, objectTypesQA, true),
+            }))
+        ];
+        const secondaryObjectTypes = schemaResponse.typeSecondaryDefinition.map((std) => ({
+            id: std.id,
+            description: std.description,
+            classification: std.classification,
+            contentStreamAllowed: std.contentStreamAllowed,
+            baseId: std.baseId,
+            // TODO: Could a SOT be a folder too?
+            isFolder: false,
+            fields: this.#resolveObjectTypeFields(std, propertiesQA, objectTypesQA)
+        }));
+        this.system = {
+            version: schemaResponse.version,
+            lastModificationDate: schemaResponse.lastModificationDate,
+            objectTypes,
+            secondaryObjectTypes,
+            i18n: localizedResource,
+            allFields: propertiesQA
+        };
+        this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();
+        this.#systemSource.next(this.system);
+    }
+    /**
+     * Resolve all the fields for an object type. This also includes secondary object types and the fields inherited from
+     * the base type (... and of course the base type (and its secondary object types) of the base type and so on)
+     * @param schemaTypeDefinition object type definition from the native schema
+     * @param propertiesQA Quick access object of all properties
+     * @param objectTypesQA Quick access object of all object types
+     * @param raw If set to 'true' only the properties of the object type itself will be returned (without SOTs)
+     */
+    #resolveObjectTypeFields(schemaTypeDefinition, propertiesQA, objectTypesQA) {
+        const objectTypeFieldIDs = schemaTypeDefinition.propertyReference.map((pr) => pr.value);
+        if (schemaTypeDefinition.secondaryObjectTypeId) {
+            schemaTypeDefinition.secondaryObjectTypeId
+                .filter((sot) => sot.static)
+                .map((sot) => sot.value)
+                .forEach((sotID) => objectTypesQA[sotID].propertyReference.forEach((pr) => objectTypeFieldIDs.push(pr.value)));
+        }
+        let fields = objectTypeFieldIDs.map((id) => ({
+            ...propertiesQA[id],
+            _internalType: this.getInternalFormElementType(propertiesQA[id].propertyType, propertiesQA[id].classifications)
+        }));
+        // also resolve properties of the base type
+        if (schemaTypeDefinition.baseId !== schemaTypeDefinition.id && !!objectTypesQA[schemaTypeDefinition.baseId]) {
+            fields = fields.concat(this.#resolveObjectTypeFields(objectTypesQA[schemaTypeDefinition.baseId], propertiesQA, objectTypesQA));
+        }
+        return fields;
+    }
+    #isCreatable(objectTypeId) {
+        return ![SystemType.FOLDER, SystemType.DOCUMENT].includes(objectTypeId);
+    }
+    /**
+     * Fetch a collection of form models.
+     * @param objectTypeIDs Object type IDs to fetch form model for
+     * @param situation Form situation
+     * @returns Object where the object type id is key and the form model is the value
+     */
+    getObjectTypeForms(objectTypeIDs, situation) {
+        return forkJoin(objectTypeIDs.map((o) => this.getObjectTypeForm(o, situation).pipe(catchError((e) => of(null)), map((res) => ({
+            id: o,
+            formModel: res
+        }))))).pipe(map((res) => {
+            const resMap = {};
+            res.filter((r) => this.#formHasElements(r.formModel)).forEach((r) => (resMap[r.id] = r.formModel));
+            return resMap;
+        }));
+    }
+    /**
+     * Get the form model of an object type.
+     *
+     * @param objectTypeId ID of the object type to fetch the form for
+     * @param situation The form situation to be fetched
+     * @returns Form model
+     */
+    getObjectTypeForm(objectTypeId, situation) {
+        return this.#backend.get(Utils.buildUri(`/dms/forms/${objectTypeId}`, { situation }));
+    }
+    /**
+     * Check whether or not the model has at least one form element. Recursive.
+     * @param element Form element to check child elements for
+     */
+    #formHasElements(element) {
+        let hasElement = false;
+        element.elements?.forEach((e) => {
+            if (!['o2mGroup', 'o2mGroupStack'].includes(e.type)) {
+                hasElement = true;
+            }
+            else if (!hasElement) {
+                hasElement = this.#formHasElements(e);
+            }
+        });
+        return hasElement;
+    }
+    /**
+     * Generates an internal type for a given object type field.
+     * Adding this to a form element or object type field enables us to render forms
+     * based on object type fields in a more performant way. Otherwise we would
+     * have to evaluate the conditions for every form element on every digest cycle.
+     * @param type propertyType of the ObjectTypeField
+     * @param classifications classifications of the ObjectTypeField
+     */
+    getInternalFormElementType(type, classifications) {
+        const _classifications = this.getClassifications(classifications || []);
+        if (type === 'string' && _classifications.has(Classification.STRING_REFERENCE)) {
+            return InternalFieldType.STRING_REFERENCE;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION)) {
+            return InternalFieldType.STRING_ORGANIZATION;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_ORGANIZATION_SET)) {
+            return InternalFieldType.STRING_ORGANIZATION_SET;
+        }
+        else if (type === 'string' && _classifications.has(Classification.STRING_CATALOG)) {
+            return InternalFieldType.STRING_CATALOG;
+        }
+        else if (type === 'boolean' && _classifications.has(Classification.BOOLEAN_SWITCH)) {
+            return InternalFieldType.BOOLEAN_SWITCH;
+        }
+        else if (type === 'string' &&
+            (_classifications.has(Classification.STRING_CATALOG_DYNAMIC) || _classifications.has(Classification.STRING_CATALOG_CUSTOM))) {
+            return InternalFieldType.STRING_DYNAMIC_CATALOG;
+        }
+        else {
+            // if there are no matching conditions just return the original type
+            return type;
+        }
+    }
+    getObjectTypeField(id) {
+        const f = this.system?.allFields[id];
+        return f ? { ...f, _internalType: this.getInternalFormElementType(f.propertyType, f.classifications) } : undefined;
+    }
+    /**
+     * Extract classifications from object type fields classification
+     * string. This string may contain more than one classification entry.
+     *
+     * Classification is a comma separated string that may contain additional
+     * properties related to on classification entry. Example:
+     *
+     * `id:reference[system:folder], email`
+     *
+     * @param classifications Object type fields classification property (schema)
+     */
+    getClassifications(classifications) {
+        const res = new Map();
+        if (classifications) {
+            classifications.forEach((c) => {
+                const matches = c.match(/^([^\[]*)(\[(.*)\])?$/);
+                if (matches && matches.length) {
+                    res.set(matches[1], {
+                        classification: matches[1],
+                        options: matches[3] ? matches[3].split(',').map((o) => o.trim()) : []
+                    });
+                }
+            });
+        }
+        return res;
+    }
+    toFormElement(field) {
+        return { ...field, label: this.getLocalizedLabel(field.id), name: field.id, type: field.propertyType };
+    }
+    updateAuthData(data) {
+        this.authData = { ...this.authData, ...data };
+        this.#backend.setHeader('Accept-Language', this.authData.language);
+        return this.#appCache.setItem(this.#STORAGE_KEY_AUTH_DATA, this.authData);
+    }
+    updateLocalizations(iso) {
+        return this.updateAuthData({ language: iso }).pipe(switchMap(() => this.#fetchLocalizations()), tap((res) => {
+            this.system.i18n = res;
+            this.#appCache.setItem(this.#STORAGE_KEY, this.system).subscribe();
+            this.#systemSource.next(this.system);
+        }));
+    }
+    #fetchLocalizations() {
+        return this.#backend.get('/resources/text');
+    }
+    fetchResources(id) {
+        return this.#backend
+            .batch([
+            { uri: `/system/resources/${id}`, base: ApiBase.core },
+            { uri: `/admin/resources/${id}`, base: ApiBase.core }
+        ])
+            .pipe(map(([global, tenant]) => ({ global, tenant })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SystemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Service providing user account configurations.
+ */
+class UserService {
+    // #GLOBAL_SETTINGS = '/users/globalsettings/';
+    #USERS_SETTINGS;
+    #DEFAULT_SETTINGS;
+    #SETTINGS_SECTION_OBJECTCONFIG;
+    #user;
+    #userSource;
+    /**
+     * @ignore
+     */
+    constructor(backend, translate, logger, system, oidc, eventService, config) {
+        this.backend = backend;
+        this.translate = translate;
+        this.logger = logger;
+        this.system = system;
+        this.oidc = oidc;
+        this.eventService = eventService;
+        this.config = config;
+        // #GLOBAL_SETTINGS = '/users/globalsettings/';
+        this.#USERS_SETTINGS = '/users/settings/';
+        this.#DEFAULT_SETTINGS = '/users/settings';
+        this.#SETTINGS_SECTION_OBJECTCONFIG = 'object-config';
+        this.#userSource = new BehaviorSubject(this.#user);
+        this.user$ = this.#userSource.asObservable();
+        this.globalSettings = new Map();
+        this.canCreateObjects = false;
+    }
+    getUiDirection(iso) {
+        // languages that are read right to left
+        const rtlLanguages = ['ar', 'arc', 'dv', 'fa', 'ha', 'he', 'khw', 'ks', 'ku', 'ps', 'ur', 'yi'];
+        return rtlLanguages.indexOf(iso) === -1 ? Direction.LTR : Direction.RTL;
+    }
+    /**
+     * Set a new current user
+     * @param user The user to be set as current user
+     */
+    setCurrentUser(user) {
+        this.#user = user;
+        this.changeClientLocale('', false);
+        this.#userSource.next(this.#user);
+    }
+    getCurrentUser() {
+        return this.#user;
+    }
+    get hasAdminRole() {
+        return this.#user?.authorities?.includes(AdministrationRoles.ADMIN) || false;
+    }
+    get hasSystemRole() {
+        return this.#user?.authorities?.includes(AdministrationRoles.SYSTEM) || false;
+    }
+    get hasAdministrationRoles() {
+        return this.hasAdminRole || this.hasSystemRole;
+    }
+    get hasManageSettingsRole() {
+        const customRole = this.config.get('core.permissions.manageSettingsRole');
+        const manageSettingsRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(manageSettingsRole) || false;
+    }
+    get isAdvancedUser() {
+        const customRole = this.config.get('core.permissions.advancedUserRole');
+        const advancedUserRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(advancedUserRole) || false;
+    }
+    get isRetentionManager() {
+        const customRole = this.config.get('core.permissions.retentionManagerRole');
+        const retenetionManagerRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(retenetionManagerRole) || false;
+    }
+    /**
+     * Change the users client locale
+     * @param iso ISO locale string to be set as new client locale
+     */
+    changeClientLocale(iso, persist = true) {
+        if (this.#user) {
+            const languages = this.config.getClientLocales().map((lang) => lang.iso);
+            iso = iso || this.#user.getClientLocale(this.config.getDefaultClientLocale());
+            if (!languages.includes(iso)) {
+                iso = this.config.getDefaultClientLocale();
+            }
+            this.logger.debug("Changed client locale to '" + iso + "'");
+            this.backend.setHeader('Accept-Language', iso);
+            this.#user.uiDirection = this.getUiDirection(iso);
+            this.#user.userSettings.locale = iso;
+            if (this.translate.currentLang !== iso || this.system.authData?.language !== iso) {
+                const ob = persist
+                    ? forkJoin([
+                        this.translate.use(iso),
+                        this.system.updateLocalizations(iso),
+                        this.saveUserSettings(this.#user.userSettings).pipe(tap(() => {
+                            // this.#userSource.next(this.#user);
+                            this.logger.debug('Loading system definitions i18n resources for new locale.');
+                        }))
+                    ])
+                    : this.translate.use(iso);
+                ob.subscribe(() => this.eventService.trigger(YuvEventType.CLIENT_LOCALE_CHANGED, iso));
+            }
+        }
+    }
+    saveUserSettings(settings) {
+        if (this.#user) {
+            console.log(this.#user.userSettings);
+            this.#user.userSettings = { ...this.#user.userSettings, ...settings };
+            return this.backend.post(this.#DEFAULT_SETTINGS, this.#user.userSettings).pipe(tap(() => this.#userSource.next(this.#user)));
+        }
+        else
+            return of(null);
+    }
+    fetchUserSettings() {
+        return this.backend.get('/dms/permissions').pipe(catchError((e) => of(undefined)), switchMap((res) => {
+            this.setUserPermissions(res);
+            return this.backend.get(this.#DEFAULT_SETTINGS);
+        }));
+    }
+    setUserPermissions(res) {
+        this.userPermissions = {
+            create: this.mapPermissions('CREATE', res),
+            write: this.mapPermissions('WRITE', res),
+            read: this.mapPermissions('READ', res),
+            delete: this.mapPermissions('DELETE', res)
+        };
+        const sp = {
+            createableObjectTypes: [
+                ...this.userPermissions.create.folderTypes,
+                ...this.userPermissions.create.objectTypes,
+                ...this.userPermissions.create.secondaryObjectTypes
+            ],
+            searchableObjectTypes: [
+                ...this.userPermissions.read.folderTypes,
+                ...this.userPermissions.read.objectTypes,
+                ...this.userPermissions.read.secondaryObjectTypes
+            ]
+        };
+        this.system.setPermissions(sp);
+        this.canCreateObjects = sp.createableObjectTypes.length > 0;
+    }
+    mapPermissions(section, apiResponse) {
+        const res = apiResponse[section] || {};
+        return {
+            folderTypes: res['folderTypeIds'] || [],
+            objectTypes: res['objectTypeIds'] || [],
+            secondaryObjectTypes: res['secondaryObjectTypeIds'] || []
+        };
+    }
+    /**
+     * Search for a user based on a search term
+     * @param term Search term
+     * @param excludeMe whether or not to exclude myself from the result list
+     * @param roles narrow down the search results by certain roles
+     */
+    queryUser(term, excludeMe, roles) {
+        let params = new HttpParams().set('search', term).set('excludeMe', `${!!excludeMe}`);
+        roles?.length && roles.map((r) => (params = params.append(`roles`, r)));
+        return this.backend.get(`/idm/users?${params}`).pipe(map((users) => (!users ? [] : users.map((u) => new YuvUser(u)))));
+    }
+    getUserById(id) {
+        return this.backend.get(`/idm/users/${id}`).pipe(map((user) => new YuvUser(user, this.#user.userSettings)));
+    }
+    logout(redirRoute) {
+        if (this.backend.authUsesOpenIdConnect()) {
+            this.oidc.logout();
+        }
+        else {
+            const redir = redirRoute ? `?redir=${redirRoute}` : '';
+            window.location.href = `${this.backend.getApiBase('logout')}${redir}`;
+        }
+    }
+    getSettings(section) {
+        return this.#user ? this.backend.get(this.#USERS_SETTINGS + encodeURIComponent(section)) : of(null);
+    }
+    saveObjectConfig(objectConfigs) {
+        return this.backend.post(this.#USERS_SETTINGS + encodeURIComponent(this.#SETTINGS_SECTION_OBJECTCONFIG), objectConfigs);
+    }
+    loadObjectConfig() {
+        return this.getSettings(this.#SETTINGS_SECTION_OBJECTCONFIG).pipe(catchError(() => of(undefined)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, deps: [{ token: BackendService }, { token: i1$1.TranslateService }, { token: Logger }, { token: SystemService }, { token: OidcService }, { token: EventService }, { token: ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: BackendService }, { type: i1$1.TranslateService }, { type: Logger }, { type: SystemService }, { type: OidcService }, { type: EventService }, { type: ConfigService }] });
+
+/**
+ * Service providing access to the systems audit entries. Audits can be seen as the history of
+ * an object. Actions perormed on an object (eg. read, write, delete, ...) will be recorded during
+ * the objects lifecycle. Audits are provided based on a users permissions. Beside the audit entries
+ * visible to regular users there are more technical ones that will only be shown to users that
+ * have administrative role.
+ */
+class AuditService {
+    constructor() {
+        this.#searchService = inject(SearchService);
+        this.#userService = inject(UserService);
+        // default number of items to be fetched
+        this.DEFAULT_RES_SIZE = 20;
+        // audit action codes that should be visible to regular users
+        this.userAuditActions = [
+            100, // metadata created
+            101, // metadata created (with content)
+            110, // tag created
+            201, // content deleted
+            210, // tag deleted
+            300, // metadata updated
+            301, // content updated
+            302, // metadata and content updated
+            303, // content moved
+            310, // tag updated
+            325, // object restored form version
+            340, // object moved
+            10000 // custom audit entries
+        ];
+        // audit action codes that should be visible to admin users
+        this.adminAuditActions = [
+            202, // marked for delete
+            220, // version deleted
+            400, // content read
+            401, // metadata read
+            402, // rendition read (text)
+            403, // rendition read (pdf)
+            404 // rendition read (thumbnail)
+        ];
+    }
+    #searchService;
+    #userService;
+    /**
+     * Get audit entries of a dms object
+     */
+    getAuditEntries(id, options = {}) {
+        const auditActions = this.getAuditActions(!!options.allActions, options?.skipActions);
+        const q = {
+            size: this.DEFAULT_RES_SIZE,
+            types: [SystemType.AUDIT],
+            filters: [
+                {
+                    f: AuditField.REFERRED_OBJECT_ID,
+                    o: Operator.EQUAL,
+                    v1: id
+                },
+                {
+                    f: AuditField.ACTION,
+                    o: Operator.IN,
+                    v1: auditActions
+                }
+            ],
+            sort: [
+                {
+                    field: AuditField.CREATION_DATE,
+                    order: 'desc'
+                }
+            ]
+        };
+        return this.#fetchAudits(q);
+    }
+    /**
+     * Get an array of action codes that are provided by the service. Based on
+     * whether or not the user has admin permissions you'll get a different
+     * set of actions.
+     * @param skipActions codes of actions that should not be fetched
+     */
+    getAuditActions(allActions, skipActions) {
+        const actions = allActions || this.#userService.isAdvancedUser ? [...this.userAuditActions, ...this.adminAuditActions] : this.userAuditActions;
+        return actions.filter((a) => !skipActions || !skipActions.includes(a));
+    }
+    /**
+     * Get a certain page for a former audits query.
+     * @param auditsResult The result object of a former audits query
+     * @param page The page to load
+     */
+    getPage(auditsResult, page) {
+        const q = auditsResult.query;
+        q.from = (page - 1) * (q.size || this.DEFAULT_RES_SIZE);
+        return this.#fetchAudits(q);
+    }
+    #fetchAudits(q) {
+        return this.#searchService.searchRaw(q).pipe(map((res) => ({
+            query: q,
+            items: res.objects.map((o) => ({
+                action: o.properties[AuditField.ACTION].value,
+                actionGroup: this.#getActionGroup(o.properties[AuditField.ACTION].value),
+                detail: o.properties[AuditField.DETAIL].value,
+                subaction: o.properties[AuditField.SUBACTION] ? o.properties[AuditField.SUBACTION].value : null,
+                version: o.properties[AuditField.VERSION].value,
+                creationDate: o.properties[AuditField.CREATION_DATE].value,
+                createdBy: {
+                    id: o.properties[AuditField.CREATED_BY].value,
+                    title: o.properties[AuditField.CREATED_BY].title
+                }
+            })),
+            hasMoreItems: res.hasMoreItems,
+            page: !q.from ? 1 : q.from / q.size + 1
+        })));
+    }
+    #getActionGroup(action) {
+        try {
+            return parseInt(`${action}`.substr(0, 1));
+        }
+        catch {
+            return -1;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuditService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuditService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuditService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+var LoginStateName;
+(function (LoginStateName) {
+    LoginStateName["STATE_LOGIN_URI"] = "login.uri";
+    LoginStateName["STATE_DONE"] = "login.done";
+    LoginStateName["STATE_CANCELED"] = "login.canceled";
+})(LoginStateName || (LoginStateName = {}));
+
+/**
+ * Service managing the configuarions for object types.
+ * Configuration means that you can pick certain fields
+ * of an object type and assign them to a config object.
+ */
+class ObjectConfigService {
+    constructor() {
+        this.#system = inject(SystemService);
+        this.#user = inject(UserService);
+        this.OBJECT_CONFIG_STORAGE_KEY = 'yuv.framework.object-config';
+        this.#objectConfigsSource = new ReplaySubject();
+        this.#objectConfigs$ = this.#objectConfigsSource.asObservable();
+        this.#defaultObjectConfigs = {};
+        this.#registeredDefaultObjectConfigs = {
+            main: {},
+            buckets: []
+        };
+        this.#objectConfigs = {
+            main: {},
+            buckets: []
+        };
+    }
+    #system;
+    #user;
+    #objectConfigsSource;
+    #objectConfigs$;
+    #defaultObjectConfigs;
+    #registeredDefaultObjectConfigs;
+    #objectConfigs;
+    // called on core init (auth.service -> initApp)
+    init() {
+        console.log('ObjectConfigService.init', this.#user.getCurrentUser().userSettings);
+        return this.#user.loadObjectConfig().pipe(tap$1((res) => {
+            this.#getDefaultObjectConfig();
+            this.#objectConfigs = res || {
+                main: {},
+                buckets: []
+            };
+            this.#objectConfigsSource.next(this.#objectConfigs);
+        }));
+    }
+    getObjectConfigs$(bucket, includeDefaults) {
+        return this.#objectConfigs$.pipe(map$1((soc) => {
+            let ocr = soc.main;
+            const defaults = { ...this.#defaultObjectConfigs, ...this.#getRegisteredDefaults(bucket) };
+            if (bucket) {
+                const tileBucket = soc.buckets.find((b) => b.id === bucket);
+                if (tileBucket)
+                    ocr = tileBucket.configs;
+            }
+            return includeDefaults
+                ? {
+                    ...defaults,
+                    ...ocr
+                }
+                : { ...ocr };
+        }));
+    }
+    /**
+     * Register default object configs. Apps can pre-define how their
+     * objects should be rendered.
+     * @param bucket Name of a bucket to bind configs to (usually the ID of the app) to
+     * separate the configs from other apps. If not provided configs will be saved for
+     * the global scope
+     */
+    registerDefaults(configs, bucket) {
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs = {
+                    ...this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs,
+                    ...configs
+                };
+            }
+            else {
+                this.#registeredDefaultObjectConfigs.buckets.push({
+                    id: bucket,
+                    configs
+                });
+            }
+        }
+        else
+            this.#registeredDefaultObjectConfigs.main = { ...this.#registeredDefaultObjectConfigs.main, ...configs };
+    }
+    unregisterDefaults(configs, bucket) {
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#registeredDefaultObjectConfigs.buckets.splice(tileBucketIdx, 1);
+            }
+        }
+        else {
+            Object.keys(configs).forEach((key) => {
+                delete this.#registeredDefaultObjectConfigs.main[key];
+            });
+        }
+    }
+    #getRegisteredDefaults(bucket) {
+        if (bucket) {
+            const defaultTileBucket = this.#registeredDefaultObjectConfigs.buckets.find((b) => b.id === bucket);
+            return defaultTileBucket?.configs || {};
+        }
+        else
+            return this.#registeredDefaultObjectConfigs.main;
+    }
+    /**
+     * Get object config for an object type.
+     * @param objectTypeId ID of the object type to get the config for
+     * @param bucket Optional bucket ID to fetch the config from. Buckets
+     * define separated areas to store/receive those configs. This way
+     * components/apps can store different object configs than the ones
+     * used accross the whole client application.
+     */
+    getObjectConfig(type, bucket) {
+        const b = bucket ? this.#objectConfigs.buckets.find((b) => b.id === bucket) : undefined;
+        const otr = b ? b.configs : this.#objectConfigs.main;
+        const oc = otr[type.id];
+        return oc || this.#getRegisteredDefaults(bucket)[type.id];
+    }
+    saveObjectConfig(type, config, bucket) {
+        if (!this.#objectConfigs)
+            this.#objectConfigs = {
+                main: {},
+                buckets: []
+            };
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#objectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#objectConfigs.buckets[tileBucketIdx].configs[type.id] = config;
+            }
+            else {
+                const configs = {};
+                configs[type.id] = config;
+                this.#objectConfigs.buckets.push({
+                    id: bucket,
+                    configs
+                });
+            }
+        }
+        else {
+            this.#objectConfigs.main[type.id] = config;
+        }
+        this.#objectConfigsSource.next(this.#objectConfigs);
+        return this.#user.saveObjectConfig(this.#objectConfigs);
+    }
+    getDefaultConfig(objectTypeID) {
+        return this.#defaultObjectConfigs[objectTypeID];
+    }
+    getResolvedObjectConfig(data, type, bucket, includeDefaults) {
+        const defaultCfg = this.#defaultObjectConfigs[data[BaseObjectTypeField.OBJECT_TYPE_ID]];
+        let oc = this.getObjectConfig(type, bucket) || defaultCfg;
+        if (includeDefaults)
+            oc = { ...defaultCfg, ...oc };
+        const res = {
+            id: data[BaseObjectTypeField.OBJECT_ID],
+            objectTypeId: data[BaseObjectTypeField.OBJECT_TYPE_ID],
+            actions: oc.actions,
+            badges: oc.badges,
+            instanceData: data
+        };
+        if (oc.title)
+            res.title = {
+                propertyName: oc.title.propertyName,
+                value: data[oc.title.propertyName]
+            };
+        if (oc.description)
+            res.description = {
+                propertyName: oc.description.propertyName,
+                value: data[oc.description.propertyName]
+            };
+        if (oc.icon)
+            res.icon = {
+                propertyName: 'custom',
+                value: oc.icon.svg
+            };
+        if (oc.meta)
+            res.meta = {
+                propertyName: oc.meta.propertyName,
+                value: data[oc.meta.propertyName]
+            };
+        if (oc.aside)
+            res.aside = {
+                propertyName: oc.aside.propertyName,
+                value: data[oc.aside.propertyName]
+            };
+        return res;
+    }
+    /**
+     * Load default/fallbac configs based on the object types and
+     * their first properties
+     */
+    #getDefaultObjectConfig() {
+        this.#system.getObjectTypes(true).forEach((ot) => {
+            this.#defaultObjectConfigs[ot.id] = {
+                objectTypeId: ot.id,
+                title: this.#toObjectProperty(ot.fields[0]),
+                description: this.#toObjectProperty(ot.fields[1]),
+                meta: this.#toObjectProperty(ot.fields[2]),
+                aside: this.#toObjectProperty(ot.fields[3])
+            };
+        });
+    }
+    #toObjectProperty(field) {
+        return field
+            ? {
+                label: this.#system.getLocalizedLabel(field.id),
+                propertyName: field.id
+            }
+            : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Service handling authentication related issues.
+ */
+class AuthService {
+    #eventService;
+    #userService;
+    #objectConfigService;
+    #appCache;
+    #systemService;
+    #backend;
+    #INITAL_REQUEST_STORAGE_KEY;
+    #authenticated;
+    #authSource;
+    #authData;
+    constructor(coreConfig) {
+        this.coreConfig = coreConfig;
+        this.#eventService = inject(EventService);
+        this.#userService = inject(UserService);
+        this.#objectConfigService = inject(ObjectConfigService);
+        this.#appCache = inject(AppCacheService);
+        this.#systemService = inject(SystemService);
+        this.#backend = inject(BackendService);
+        this.#INITAL_REQUEST_STORAGE_KEY = 'yuv.core.auth.initialrequest';
+        this.USER_FETCH_URI = '/idm/whoami';
+        this.#authenticated = false;
+        this.#authSource = new BehaviorSubject(false);
+        this.authenticated$ = this.#authSource.asObservable();
+    }
+    isLoggedIn() {
+        return this.#authenticated;
+    }
+    /**
+     * Called while app/core is initialized (APP_INITIALIZER)
+     * @ignore
+     */
+    initUser() {
+        return this.fetchUser();
+    }
+    /**
+     * Get the current tenant or the previous one persisted locally
+     */
+    getTenant() {
+        return this.#authData?.tenant;
+    }
+    /**
+     * Fetch information about the user currently logged in
+     */
+    fetchUser() {
+        return this.#backend.get(this.USER_FETCH_URI).pipe(tap(() => {
+            this.#authenticated = true;
+            this.#authSource.next(this.#authenticated);
+        }), switchMap((userJson) => this.#initApp(userJson)));
+    }
+    /**
+     * Logs out the current user.
+     */
+    logout() {
+        this.#authenticated = false;
+        this.#authSource.next(this.#authenticated);
+        this.#eventService.trigger(YuvEventType.LOGOUT);
+    }
+    // called on core init
+    setInitialRequestUri() {
+        const ignore = ['/', '/index.html'];
+        let uri = `${location.pathname}${location.search}`.replace(Utils.getBaseHref(), '');
+        uri = !uri.startsWith('/') ? `/${uri}` : uri;
+        if (!ignore.includes(uri)) {
+            this.#appCache
+                .setItem(this.#INITAL_REQUEST_STORAGE_KEY, {
+                uri: uri,
+                timestamp: Date.now()
+            })
+                .subscribe();
+        }
+    }
+    /**
+     * Get the URL that entered the app. May be a deep link that could then be
+     * picked up again after user has been authenticated.
+     */
+    getInitialRequestUri() {
+        return this.#appCache.getItem(this.#INITAL_REQUEST_STORAGE_KEY);
+    }
+    resetInitialRequestUri() {
+        return this.#appCache.removeItem(this.#INITAL_REQUEST_STORAGE_KEY);
+    }
+    /**
+     * Initialize/setup the application for a given user. This involves fetching
+     * settings and schema information.
+     * @param userJson Data retrieved from the backend
+     */
+    #initApp(userJson) {
+        return this.#userService.fetchUserSettings().pipe(switchMap((userSettings) => {
+            const currentUser = new YuvUser(userJson, userSettings);
+            this.#userService.setCurrentUser(currentUser);
+            this.#authData = {
+                tenant: currentUser.tenant,
+                language: currentUser.getClientLocale()
+            };
+            return this.#systemService.getSystemDefinition(this.#authData).pipe(switchMap(() => this.#objectConfigService.init()), map(() => currentUser));
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, deps: [{ token: CORE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: CoreConfig, decorators: [{
+                    type: Inject,
+                    args: [CORE_CONFIG]
+                }] }] });
+
+const ProcessAction = {
+    complete: 'complete',
+    claim: 'claim',
+    delegate: 'delegate',
+    resolve: 'resolve',
+    save: 'save'
+};
+
+class BpmService {
+    #backend = inject(BackendService);
+    startProcess(payload) {
+        return this.#backend.post('/bpm/processes', payload, ApiBase.apiWeb);
+    }
+    /**
+     * Finsihes a task.
+     * @param taskId ID of the taks to finish
+     * @param payload Data to be send with the complete request (may contain attachments, a new subject or variables)
+     */
+    completeTask(taskId, payload) {
+        return this.#putTask(taskId, ProcessAction.complete, payload || {});
+    }
+    updateTask(taskId, payload) {
+        return this.#putTask(taskId, ProcessAction.save, payload || {});
+    }
+    //TODO: replace with propper service call
+    getProcessPoll() {
+        const random = Math.random();
+        console.log('getProcessPoll: ', { random });
+        return of([{ title: `task title ${random}`, duedate: new Date() }]);
+    }
+    getProcessInstance(processDefinitionKey, options) {
+        return this.#backend
+            .get(`/bpm/processes${Utils.optionsToURLParams({ ...options, processDefinitionKey })}`, ApiBase.apiWeb)
+            .pipe(map$1(({ objects }) => objects[0]));
+    }
+    deleteProcess(processInstanceId) {
+        return this.#backend.delete(`/bpm/processes/${processInstanceId}`, ApiBase.apiWeb);
+    }
+    #putTask(taskId, action, payload) {
+        const pl = { ...payload, action: action };
+        return this.#backend.put(`/bpm/tasks/${taskId}`, pl, ApiBase.apiWeb);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CatalogService {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CatalogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CatalogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CatalogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ClipboardService {
+    #emptyClipboard = {
+        buckets: undefined,
+        main: undefined
+    };
+    #clipboard = structuredClone(this.#emptyClipboard);
+    #clipboardSource = new ReplaySubject();
+    #clipboard$ = this.#clipboardSource.asObservable();
+    #pasteEvents = merge(fromEvent(window, 'keydown').pipe(filter$1((event) => event.ctrlKey && event.code === 'KeyV')), fromEvent(window, 'paste').pipe(filter$1((event) => !!event.clipboardData && event.clipboardData.files.length > 0)));
+    clipboard(bucket) {
+        return toSignal(this.clipboard$(bucket));
+    }
+    clipboard$(bucket) {
+        return this.#clipboard$.pipe(map$1((cs) => {
+            if (bucket) {
+                return cs.buckets ? cs.buckets[bucket] : undefined;
+            }
+            else
+                return cs.main;
+        }));
+    }
+    paste$(bucket) {
+        return this.#pasteEvents.pipe(map$1((e) => {
+            let cd;
+            if (e instanceof ClipboardEvent) {
+                const fileList = e.clipboardData.files;
+                const files = [];
+                for (let i = 0; i < fileList.length; i++) {
+                    files.push(fileList.item(i));
+                }
+                cd = files.length
+                    ? {
+                        files
+                    }
+                    : undefined;
+            }
+            else {
+                cd = bucket ? (this.#clipboard.buckets ? this.#clipboard.buckets[bucket] : undefined) : this.#clipboard.main;
+            }
+            return cd;
+        }), filter$1((cd) => cd !== undefined && (cd.files || cd.objects)), map$1((cd) => cd));
+    }
+    getClipboardData(bucket) {
+        if (bucket) {
+            return this.#clipboard.buckets ? this.#clipboard.buckets[bucket] : undefined;
+        }
+        else
+            return this.#clipboard.main;
+    }
+    /**
+     * Add objects to the clipboard
+     * @param bucket Buckets are ways to separate data from the global scope.
+     * If you have an app that would like to have a separate section in the clipboard
+     * you'll use a unique bucket to store your stuff. When observing chages to the
+     * clipboard you couls as well provide the bucket and you will only get
+     */
+    addObjects(objects, mode, bucket) {
+        const cd = { mode, objects };
+        if (bucket) {
+            if (!this.#clipboard.buckets)
+                this.#clipboard.buckets = {};
+            this.#clipboard.buckets[bucket] = cd;
+        }
+        else
+            this.#clipboard.main = cd;
+        this.#clipboardSource.next(this.#clipboard);
+    }
+    clear(bucket) {
+        if (bucket && this.#clipboard.buckets) {
+            delete this.#clipboard.buckets[bucket];
+        }
+        else {
+            this.#clipboard = structuredClone(this.#emptyClipboard);
+        }
+        this.#clipboardSource.next(this.#clipboard);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ClipboardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ClipboardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * This service is used for connecting and initializing in the client
+ */
+class ConnectionService {
+    /**
+     * @ignore
+     */
+    constructor() {
+        this.currentState = {
+            isOnline: window.navigator.onLine
+        };
+        this.connectionStateSource = new ReplaySubject();
+        this.connection$ = this.connectionStateSource.asObservable();
+        this.connectionStateSource.next(this.currentState);
+        fromEvent(window, 'online').subscribe(() => {
+            this.currentState.isOnline = true;
+            this.connectionStateSource.next(this.currentState);
+        });
+        fromEvent(window, 'offline').subscribe(() => {
+            this.currentState.isOnline = false;
+            this.connectionStateSource.next(this.currentState);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Providing functions,that are are injected at application startup and executed during app initialization.
+ */
+function init_moduleFnc(coreConfig, deviceService, logger, http, configService, authService) {
+    return () => {
+        authService.setInitialRequestUri();
+        deviceService.init();
+        return coreConfig.main
+            ? !Array.isArray(coreConfig.main)
+                ? of([coreConfig.main])
+                : forkJoin([...coreConfig.main].map((uri) => http.get(`${Utils.getBaseHref()}${uri}`).pipe(catchError((e) => {
+                    logger.error('failed to catch config file', e);
+                    return of({});
+                }), map((res) => res)))).pipe(
+                // switchMap((configs: YuvConfig[]) => configService.extendConfig(configs)),
+                tap((configs) => configService.extendConfig(configs)), switchMap(() => authService.initUser().pipe(catchError((e) => {
+                    authService.initError = {
+                        status: e.status,
+                        key: e.error.error
+                    };
+                    return of(true);
+                }))))
+            : of(false);
+    };
+}
+
+var DeviceScreenOrientation;
+(function (DeviceScreenOrientation) {
+    DeviceScreenOrientation["PORTRAIT"] = "portrait";
+    DeviceScreenOrientation["LANDSCAPE"] = "landscape";
+})(DeviceScreenOrientation || (DeviceScreenOrientation = {}));
+
+/**
+ * This service is used to adapt styles and designs of the client to
+ * different devices and screen sizes.
+ *
+ * Using `screenChange$` observable you are able to monitor changes to
+ * the screen size and act upon it.
+ *
+ * This service will also adds attributes to the body tag that reflect the
+ * current screen/device state. This way you can apply secific styles in your
+ * css files for different screen resolutions and orientations.
+ *
+ * Attributes applied to the body tag are:
+ *
+ * - `data-screen` - [s, m, l, xl] - for different screen sizes
+ * (s: for mobile phone like screen sizes, m: for tablet like screen
+ * sizes, 'l': for desktop like screen sizes, 'xl': for screen sizes exceeding
+ * the desktop screen size).
+ *
+ * - `data-orientation` - [portrait, landscape] - for the current screen orientation
+ *
+ * - `data-touch-enabled` - [true] - if the device has touch capabilities (won't be added if the device doesn't have touch capabilities)
+ *
+ * ```html
+ * <body data-screen-size="s" data-screen-orientation="portrait" data-touch-enabled="true">
+ * ...
+ * </body>
+ * ```
+ */
+class DeviceService {
+    #deviceDetectorService;
+    #upperScreenBoundary;
+    #resize$;
+    #screen;
+    #screenSource;
+    constructor() {
+        this.#deviceDetectorService = inject(DeviceDetectorService);
+        this.#upperScreenBoundary = {
+            small: 600,
+            mediumPortrait: 900,
+            mediumLandscape: 1200,
+            large: 1800
+        };
+        this.#resize$ = fromEvent(window, 'resize').pipe(debounceTime(this.#getDebounceTime()));
+        this.#screenSource = new ReplaySubject(1);
+        this.screenChange$ = this.#screenSource.asObservable();
+        /**
+         * if the device is a mobile device (android / iPhone / windows-phone etc)
+         */
+        this.isMobile = this.#deviceDetectorService.isMobile();
+        /**
+         *  if the device us a tablet (iPad etc)
+         */
+        this.isTablet = this.#deviceDetectorService.isTablet();
+        /**
+         * if the app is running on a Desktop browser
+         */
+        this.isDesktop = this.#deviceDetectorService.isDesktop();
+        this.info = this.#deviceDetectorService.getDeviceInfo();
+        this.isTouchEnabled = this.#isTouchEnabled();
+        this.#resize$.subscribe((e) => {
+            this.#setScreen();
+        });
+    }
+    init() {
+        this.#setScreen();
+    }
+    #isTouchEnabled() {
+        return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+    }
+    #setScreen() {
+        const bounds = {
+            width: window.innerWidth,
+            height: window.innerHeight
+        };
+        let orientation = bounds.width >= bounds.height ? DeviceScreenOrientation.LANDSCAPE : DeviceScreenOrientation.PORTRAIT;
+        if (this.isMobile && window.screen['orientation']) {
+            const screenOrientation = window.screen['orientation'].type;
+            if (screenOrientation === 'landscape-primary' || screenOrientation === 'landscape-secondary') {
+                orientation = DeviceScreenOrientation.LANDSCAPE;
+            }
+            else if (screenOrientation === 'portrait-primary' || screenOrientation === 'portrait-secondary') {
+                orientation = DeviceScreenOrientation.PORTRAIT;
+            }
+        }
+        this.#screen = {
+            size: this.#getScreenSize(bounds, orientation),
+            orientation,
+            width: bounds.width,
+            height: bounds.height
+        };
+        this.#screenSource.next(this.#screen);
+        this.#setupDOM(this.#screen);
+        // force change detection because resize will not be recognized by Angular in some cases
+        // TODO: check: causes recursive ticks in some cases ...
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        setTimeout(() => { }, 0);
+    }
+    #setupDOM(screen) {
+        const body = document.querySelector('body');
+        body.setAttribute('data-screen-size', screen.size);
+        body.setAttribute('data-screen-orientation', screen.orientation);
+        if (this.isTouchEnabled)
+            body.setAttribute('data-touch-enabled', 'true');
+        else
+            body.removeAttribute('data-touch-enabled');
+    }
+    #getScreenSize(bounds, orientation) {
+        if (this.#isBelow(this.#upperScreenBoundary.small, bounds)) {
+            return 's';
+        }
+        else if (this.#isBelow(orientation === 'landscape' ? this.#upperScreenBoundary.mediumLandscape : this.#upperScreenBoundary.mediumPortrait, bounds)) {
+            return 'm';
+        }
+        else if (this.#isBelow(this.#upperScreenBoundary.large, bounds)) {
+            return 'l';
+        }
+        else {
+            return 'xl';
+        }
+    }
+    #isBelow(size, bounds) {
+        const landscape = bounds.width < this.#upperScreenBoundary.large ? bounds.width >= bounds.height : false;
+        return (landscape && bounds.height < size) || (!landscape && bounds.width < size);
+    }
+    #getDebounceTime() {
+        // on mobile devices resize only happens when rotating the device or when
+        // keyboard appears, so we dont't need to debounce
+        return this.isMobile ? 0 : 500;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DeviceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DeviceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DeviceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+const transformResponse = () => map((res) => (res && res.body ? res.body.objects.map((val) => val) : null));
+/**
+ * Service for providing upload of different object types into a client.
+ */
+class UploadService {
+    constructor() {
+        this.#backend = inject(BackendService);
+        this.#http = inject(HttpClient);
+        this.#logger = inject(Logger);
+        this.#status = { err: 0, items: [] };
+        this.#statusSource = new ReplaySubject();
+        this.status$ = this.#statusSource.pipe(scan((acc, newVal) => ({ ...acc, ...newVal }), this.#status));
+        this.#uploadStatus = new BehaviorSubject(null);
+        this.uploadStatus$ = this.#uploadStatus.asObservable();
+    }
+    #backend;
+    #http;
+    #logger;
+    #status;
+    #statusSource;
+    #uploadStatus;
+    /**
+     * Upload a file.
+     * @param url The URL to upload the file to
+     * @param file The file to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    upload(url, file, label, silent) {
+        return this.#executeUpload(url, file, label || file.name, silent);
+    }
+    /**
+     * Upload files using multipart upload.
+     * @param url The URL to upload the files to
+     * @param files The files to be uploaded
+     * @param data Data to be send along with the files
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    uploadMultipart(url, files, data, label, silent) {
+        return this.#executeMultipartUpload(url, files, label || 'Upload', data, silent);
+    }
+    createDocument(url, data) {
+        const formData = this.#createFormData({ data });
+        const request = this.#createHttpRequest(url, { formData }, false);
+        return this.#http.request(request).pipe(filter((obj) => obj && obj.body), transformResponse(), catchError((err) => throwError(() => err)));
+    }
+    /**
+     * Cancels an upload request and removes it from the list of files being uploaded.
+     * @param id ID of the UploadItem to be canceled
+     */
+    cancelItem(id) {
+        if (id) {
+            const match = this.#status.items.find((i) => i.id === id);
+            if (match) {
+                match.subscription.unsubscribe();
+                this.#status.items = this.#status.items.filter((i) => i.id !== id);
+            }
+        }
+        else {
+            this.#status.items.forEach((element) => element.subscription.unsubscribe());
+            this.#status.items = [];
+        }
+        this.#status.err = this.#status.items.filter((i) => i.err).length;
+        this.#statusSource.next(this.#status);
+    }
+    /**
+     * Prepares Formdata for multipart upload.
+     * @param from contains form and or file
+     */
+    #createFormData({ file, data }) {
+        const formData = new FormData();
+        (file || []).forEach((f) => formData.append('files', f, f.name));
+        data ? formData.append('data', new Blob([JSON.stringify(data)], { type: 'application/json' })) : null;
+        return formData;
+    }
+    /**
+     * Prepares Http Request.
+     * @param url The URL to upload the file to
+     * @param content formdata or single file
+     * @param reportProgress Request should report upload progress
+     * @param method Request method
+     */
+    #createHttpRequest(url, content, reportProgress, method = 'POST') {
+        const { formData, file } = content;
+        // add request param to bypass the serviceworker
+        url += `${url.indexOf('?') === -1 ? '?' : '&'}ngsw-bypass=1`;
+        let headers = this.#backend.getAuthHeaders();
+        if (file) {
+            headers = headers.set('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(file.name)}`);
+        }
+        return new HttpRequest(method, url, file || formData, { headers, reportProgress });
+    }
+    /**
+     * Prepares single file POST upload.
+     * @param url The URL to upload the file to
+     * @param file The file to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    #executeUpload(url, file, label, silent = false) {
+        const request = this.#createHttpRequest(url, { file }, true);
+        return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());
+    }
+    /**
+     * Prepare multipart upload.
+     * @param url The URL to upload the file to
+     * @param file Array of files to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     * @param data Data to be send along with the files
+     */
+    #executeMultipartUpload(url, file, label, data, silent = false) {
+        const formData = this.#createFormData({ file, data });
+        const request = this.#createHttpRequest(url, { formData }, true);
+        return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());
+    }
+    #generateResult(result) {
+        const objects = result.body?.objects;
+        if (objects && objects.length > 1) {
+            const data = objects[0];
+            // const bp = this.#system.getBaseProperties();
+            // const label = data.properties[bp.title] ? data.properties[bp.title].value : '...';
+            // TODO: Get the label from somewhere
+            const label = '...';
+            return [
+                {
+                    objectId: objects.map((val) => val.properties[BaseObjectTypeField.OBJECT_ID].value),
+                    contentStreamId: data.contentStreams[0]?.contentStreamId,
+                    filename: data.contentStreams[0]?.fileName,
+                    label: `(${objects.length}) ${label}`
+                }
+            ];
+        }
+        else {
+            return result.body.objects.map((o) => ({
+                objectId: o.properties[BaseObjectTypeField.OBJECT_ID].value,
+                contentStreamId: o.contentStreams[0]?.contentStreamId,
+                filename: o.contentStreams[0]?.fileName,
+                // label: o.properties[bp.title] ? o.properties[bp.title].value : o.contentStreams![0]?.fileName
+                // TODO: Get the label from somewhere
+                label: o.contentStreams[0]?.fileName
+            }));
+        }
+    }
+    #createProgressStatus(event, progress, id) {
+        if (event.type === HttpEventType.UploadProgress) {
+            const percentDone = Math.round((100 * event.loaded) / event.total);
+            progress.next(percentDone);
+        }
+        else if (event instanceof HttpResponse) {
+            progress.complete();
+            // add upload response
+            // this.status.items = this.status.items.filter(s => s.id !== id);
+            const idx = this.#status.items.findIndex((s) => s.id === id);
+            if (idx !== -1) {
+                this.#status.items[idx].result = this.#generateResult(event);
+                this.#statusSource.next(this.#status);
+            }
+        }
+    }
+    #createUploadError(err, progress, id) {
+        const statusItem = this.#status.items.find((s) => s.id === id);
+        statusItem.err = {
+            code: err.status,
+            message: err.error ? err.error.errorMessage : err.message
+        };
+        this.#logger.error('upload failed', statusItem);
+        this.#status.err++;
+        this.#statusSource.next(this.#status);
+        progress.next(0);
+        return throwError(() => new Error(err.message));
+    }
+    /**
+     * Actually starts the upload process.
+     * @param request Request to be executed
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    #startUploadWithFile(request, label) {
+        return new Observable((o) => {
+            const id = Utils.uuid();
+            const progress = new Subject();
+            let result;
+            // Create a subscription from the http request that will be applied to the upload
+            // status item in order to be able to cancel the request later on.
+            this.#uploadStatus.next(false);
+            const subscription = this.#http
+                .request(request)
+                .pipe(catchError((err) => this.#createUploadError(err, progress, id)), tap((event) => this.#createProgressStatus(event, progress, id)))
+                // actual return value of this function
+                .subscribe({
+                next: (res) => (res.status ? (result = res) : null),
+                error: (err) => {
+                    o.error(err);
+                    this.#uploadStatus.next(true);
+                    o.complete();
+                },
+                complete: () => {
+                    o.next(result);
+                    this.#uploadStatus.next(true);
+                    o.complete();
+                }
+            });
+            this.#status.items.push({
+                id,
+                filename: label,
+                progress: progress.asObservable(),
+                subscription,
+                err: undefined
+            });
+            this.#statusSource.next(this.#status);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Service for working with dms objects: create them, delete, etc.
+ */
+class DmsService {
+    #searchService = inject(SearchService);
+    #backend = inject(BackendService);
+    #eventService = inject(EventService);
+    #uploadService = inject(UploadService);
+    // general trigger operator to handle all dms events
+    triggerEvent(event, id, silent = false) {
+        return (stream) => stream.pipe(
+        // update does not return permissions, so we need to re-load the whole dms object
+        // TODO: Remove once permissions are provided
+        switchMap((res) => (!id ? of(res) : this.getDmsObject(id))), 
+        // TODO: enable once permissions are provided
+        // map((res) => this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0])),
+        tap((res) => !silent && this.#eventService.trigger(event, res)));
+    }
+    // general trigger operator to handle all dms events
+    #triggerEvents(event, ids, silent = false) {
+        return (stream) => stream.pipe(
+        // update does not return permissions, so we need to re-load the whole dms object
+        // TODO: Remove once permissions are provided
+        switchMap((res) => (!ids ? of(res) : this.getDmsObjects(ids))), 
+        // TODO: enable once permissions are provided
+        // map((_res: any[]) => _res.map((res, i) => res?._error ? { ...res, id: ids?[i] } : this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0]))),
+        map((_res) => _res.map((res, i) => (res?._error && ids ? { ...res, id: ids[i] } : res))), tap((res) => !silent && res.forEach((o) => o && this.#eventService.trigger(event, o))));
+    }
+    /**
+     * Create new dms object(s). Providing an array of files here instead of one will create
+     * a new dms object for every file. In this case indexdata will shared across all files.
+     * @param objectTypeId The ID of the object type to be created
+     * @param indexdata Indexdata for the new object(s)
+     * @param files File(s) to create dms objects content(s) with
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     *
+     * @returns Array of IDs of the objects that have been created
+     */
+    createDmsObject(objectTypeId, indexdata, files, label, silent = false) {
+        const url = `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects`;
+        const data = indexdata;
+        data[BaseObjectTypeField.OBJECT_TYPE_ID] = objectTypeId;
+        const upload = files.length ? this.#uploadService.uploadMultipart(url, files, data, label, silent) : this.#uploadService.createDocument(url, data);
+        return upload
+            .pipe(map((res) => res.map((r) => r.properties[BaseObjectTypeField.OBJECT_ID].value)), 
+        // TODO: Replace by proper solution
+        // Right now there is a gap between when the object was
+        // created and when it is indexed. So delaying here will
+        // give backend time to get its stuff together.
+        delay(1000))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_CREATED, '', silent));
+    }
+    /**
+     * Delete a dms object.
+     * @param id ID of the object to be deleted
+     */
+    deleteDmsObject(id, silent = false) {
+        const url = `/dms/objects/${id}`;
+        return this.#backend
+            .delete(url, ApiBase.apiWeb)
+            .pipe(map(() => ({ id })))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_DELETED, '', silent));
+    }
+    /**
+     * Restore older version of a dms object.
+     * @param id ID of the object to be restored
+     * @param version version of the object to be restored
+     */
+    restoreDmsObject(id, version, silent = false) {
+        const url = `/dms/objects/${id}/versions/${version}/actions/restore?waitForSearchConsistency=true&restoreParentId=false`;
+        return this.#backend.post(url, {}, ApiBase.apiWeb).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Upload (add/replace) content to a dms object.
+     * @param objectId ID of the dms object to upload the file to
+     * @param file The file to be uploaded
+     */
+    uploadContent(objectId, file) {
+        return this.#uploadService.upload(this.getContentPath(objectId), file).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, objectId));
+    }
+    /**
+     * Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     */
+    getContentPath(objectId, version) {
+        return `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects/${objectId}/contents/file${version ? '?version=' + version : ''}`;
+    }
+    /**
+     * Original API Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     * @param rendition should return rendition path of the dms object
+     */
+    getFullContentPath(objectId, version, rendition = false) {
+        return `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}${version ? '/versions/' + version : ''}/contents/${rendition ? 'renditions/pdf' : 'file'}`;
+    }
+    getSlideURI(objectId, mimeType) {
+        const supportedMimeTypes = ['*/*'];
+        let supported = false;
+        if (mimeType) {
+            // check if mime type supports slides
+            supportedMimeTypes.forEach((p) => (supported = supported || Utils.patternToRegExp(p).test(mimeType)));
+        }
+        return !mimeType || supported ? `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}/contents/renditions/slide` : undefined;
+    }
+    /**
+     * Downloads the content of dms objects.
+     *
+     * @param DmsObject[] dmsObjects Array of dms objects to be downloaded
+     * @param withVersion should download specific version of the object
+     */
+    downloadContent(objects, withVersion) {
+        objects.forEach((object, i) => setTimeout(() => {
+            const uri = `${this.getContentPath(object?.id, withVersion ? object?.version : undefined)}`;
+            this.#backend.download(uri);
+        }, Utils.isSafari() ? i * 1000 : 0 // Safari does not allow multi download
+        ));
+    }
+    /**
+     * Fetch a dms object.
+     * @param id ID of the object to be retrieved
+     * @param version Desired version of the object
+     */
+    getDmsObject(id, version, silent = false, requestOptions) {
+        return this.#backend
+            .get(`/dms/objects/${id}${version ? '/versions/' + version : ''}`, undefined, requestOptions)
+            .pipe(map((res) => {
+            const item = this.#searchService.toSearchResult(res).items[0];
+            return this.#searchResultToDmsObject(item);
+        }))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_LOADED, '', silent));
+    }
+    /**
+     * Updates a tag on a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    setDmsObjectTag(id, tag, value, silent = false) {
+        return this.#backend
+            .post(`/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`, {}, ApiBase.core)
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Deletes a tag from a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be deleted
+     */
+    deleteDmsObjectTag(id, tag, silent = false) {
+        return this.#backend.delete(`/dms/objects/${id}/tags/${tag}`, ApiBase.core).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Update indexdata of a dms object.
+     * @param id ID of the object to apply the data to
+     * @param data Indexdata to be applied
+     * @param silent flag to trigger DMS_OBJECT_UPDATED event
+     */
+    updateDmsObject(id, data, silent = false) {
+        return this.#backend.patch(`/dms/objects/${id}`, data).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Updates given objects.
+     * @param objects the objects to updated
+     */
+    updateDmsObjects(objects, silent = false) {
+        return this.#backend
+            .patch(`/dms/objects`, {
+            patches: objects.map((o) => ({
+                id: o.id,
+                data: o.data
+            }))
+        })
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_UPDATED, objects.map((o) => o.id), silent));
+    }
+    /**
+     * Updates a tag on a dms object.
+     * @param ids List of IDs of objects
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    updateDmsObjectsTag(ids, tag, value, silent = false) {
+        return this.batchUpdateTag(ids, tag, value).pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_UPDATED, ids, silent));
+    }
+    /**
+     * Moves given objects to a different folder.
+     * @param folderId the id of the new parent folder
+     * @param objects objects to be moved
+     * @param options options for the move operation
+     */
+    moveDmsObjects(targetFolderId, objects, options) {
+        return this.updateDmsObjects(objects.map((o) => ({ id: o.id, data: { [BaseObjectTypeField.PARENT_ID]: targetFolderId } }), true)).pipe(tap((res) => !options?.silent && this.#eventService.trigger(YuvEventType.DMS_OBJECTS_MOVED, res)));
+    }
+    /**
+     * Copy given objects to a different folder. The objects will be copied with their indexdata referencing
+     * the existing content of the source object.
+     * @param targetFolderId The ID of the target folder
+     * @param objects The objects to be copied
+     * @param options options for the copy operation
+     */
+    copyDmsObjects(targetFolderId, objects, options) {
+        const excludeProperties = [
+            BaseObjectTypeField.OBJECT_ID,
+            BaseObjectTypeField.CREATED_BY,
+            BaseObjectTypeField.CREATION_DATE,
+            BaseObjectTypeField.MODIFIED_BY,
+            BaseObjectTypeField.MODIFICATION_DATE,
+            BaseObjectTypeField.VERSION_NUMBER,
+            BaseObjectTypeField.TRACE_ID,
+            BaseObjectTypeField.PARENT_OBJECT_TYPE_ID,
+            BaseObjectTypeField.PARENT_VERSION_NUMBER
+        ];
+        const mappedObjects = objects.map((o) => {
+            o.data[BaseObjectTypeField.PARENT_ID] = targetFolderId;
+            // Remove properties that are not allowed to be copied.
+            // This also includes content stream fields bundled into the objects data field.
+            // Properties ending with '_title' are also excluded as they are enrichment values
+            // provided by API-Web.
+            Object.keys(o.data)
+                .filter((key) => key.endsWith('_title') || excludeProperties.includes(key) || Object.values(ContentStreamField).includes(key))
+                .forEach((key) => Reflect.deleteProperty(o.data, key));
+            // map filtered data field to data format required by the Core-API
+            const properties = Object.keys(o.data).reduce((acc, key) => {
+                acc[key] = { value: o.data[key] };
+                return acc;
+            }, {});
+            return {
+                properties: properties,
+                objectTypeId: o.objectTypeId,
+                ...(o.content
+                    ? {
+                        contentStreams: [o.content]
+                    }
+                    : {})
+            };
+        });
+        const query = options
+            ? Object.keys(options)
+                .map((key) => `${key}=${options[key]}`)
+                .join('&')
+            : '';
+        return this.#backend.post(`/dms/objects?${query}}`, { objects: mappedObjects }, ApiBase.core);
+    }
+    /**
+     * Get a bunch of dms objects.
+     * @param ids List of IDs of objects to be retrieved
+     */
+    getDmsObjects(ids, silent = false) {
+        return this.batchGet(ids)
+            .pipe(map((_res) => _res.map((res, i) => (res?._error ? { ...res, id: ids[i] } : this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])))))
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_LOADED, undefined, silent));
+    }
+    /**
+     * Delete a bunch of dms objects.
+     * @param ids List of IDs of objects to be deleted
+     * @param options Options for the delete operation
+     * @returns Array of delete results.
+     */
+    deleteDmsObjects(objects, options) {
+        const queryParams = options
+            ? `?${Object.keys(options)
+                .filter((k) => ['waitForSearchConsistency', 'greedy'].includes(k))
+                .map((k) => `${k}=${options[k]}`)
+                .join('&')}`
+            : '';
+        return this.#backend
+            .delete(`/dms/objects${queryParams}`, ApiBase.core, {
+            body: {
+                objects: objects.map((o) => ({
+                    properties: typeof o === 'string'
+                        ? {
+                            'system:objectId': {
+                                value: o
+                            }
+                        }
+                        : {
+                            'system:objectId': { value: o.id },
+                            subject: { value: o.subject }
+                        }
+                }))
+            }
+        })
+            .pipe(map((res) => res?.objects?.map((r) => {
+            const v = r.options?.[SystemResult.DELETE];
+            return {
+                id: r.properties?.[BaseObjectTypeField.OBJECT_ID]?.value,
+                properties: r.properties,
+                ...(v?.httpStatusCode >= 400 ? { _error: { status: v.httpStatusCode, message: v.message } } : {})
+            };
+        })))
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_DELETED, undefined, options?.silent));
+    }
+    /**
+     * Fetch a dms object versions.
+     * @param id ID of the object to be retrieved
+     */
+    getDmsObjectVersions(id) {
+        return this.#backend.get('/dms/objects/' + id + '/versions').pipe(map((res) => {
+            const items = this.#searchService.toSearchResult(res).items || [];
+            return items.map((item) => this.#searchResultToDmsObject(item));
+        }), map((res) => res.sort(Utils.sortValues('version', Sort.DESC))));
+    }
+    getDmsObjectVersion(id, version) {
+        return this.#backend
+            .get(`/dms/objects/${id}/versions/${version}`)
+            .pipe(map((res) => this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])));
+    }
+    coreApiResponseToDmsObject(res) {
+        return this.#searchResultToDmsObject({
+            objectTypeId: res.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value,
+            fields: new Map(Object.entries(res.properties)),
+            content: res.contentStreams?.[0]
+        });
+    }
+    #searchResultToDmsObject(resItem) {
+        return new DmsObject(resItem);
+    }
+    batchUpdateTag(ids, tag, value) {
+        return this.#backend.batch(ids.map((id) => ({
+            method: 'POST',
+            uri: `/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`,
+            base: ApiBase.core,
+            body: {}
+        })));
+    }
+    batchDeleteTag(ids, tag) {
+        return this.#backend.batch(ids.map((id) => ({
+            method: 'DELETE',
+            uri: `/dms/objects/${id}/tags/${tag}`,
+            base: ApiBase.core
+        })));
+    }
+    batchDelete(ids) {
+        return this.#backend.batch(ids.map((id) => ({ method: 'DELETE', uri: `/dms/objects/${id}` })));
+    }
+    batchGet(ids) {
+        return this.#backend.batch(ids.map((id) => ({ method: 'GET', uri: `/dms/objects/${id}` })));
+    }
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse) {
+        const resultListItems = [];
+        const objectTypes = [];
+        searchResponse.objects.forEach((o) => {
+            const fields = new Map();
+            // process properties section of result
+            Object.keys(o.properties).forEach((key) => {
+                let value = o.properties[key].value;
+                if (o.properties[key].clvalue) {
+                    // table fields will have a clientValue too ...
+                    value = o.properties[key].clvalue;
+                    // ... and also may contain values that need to be resolved
+                    if (o.properties[key].resolvedValues) {
+                        value.forEach((v) => {
+                            Object.keys(v).forEach((k) => {
+                                const resValue = Array.isArray(v[k]) ? v[k].map((i) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];
+                                if (resValue) {
+                                    v[`${k}_title`] = resValue;
+                                }
+                            });
+                        });
+                    }
+                }
+                fields.set(key, value);
+                if (o.properties[key].title) {
+                    fields.set(key + '_title', o.properties[key].title);
+                }
+            });
+            // process contentStreams section of result if available.
+            // Objects that don't have files attached won't have this section
+            let content;
+            if (o.contentStreams && o.contentStreams.length > 0) {
+                // we assume that each result object only has ONE file attached, altough
+                // this is an array and there may be more
+                const contentStream = o.contentStreams[0];
+                // also add contentstream related fields to the result fields
+                fields.set(ContentStreamField.LENGTH, contentStream.length);
+                fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);
+                fields.set(ContentStreamField.FILENAME, contentStream.fileName);
+                fields.set(ContentStreamField.ID, contentStream.contentStreamId);
+                fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);
+                fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);
+                fields.set(ContentStreamField.DIGEST, contentStream.digest);
+                fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);
+                content = {
+                    contentStreamId: contentStream.contentStreamId,
+                    repositoryId: contentStream.repositoryId,
+                    range: contentStream.range,
+                    digest: contentStream.digest,
+                    archivePath: contentStream.archivePath,
+                    fileName: contentStream.fileName,
+                    mimeType: contentStream.mimeType,
+                    size: contentStream.length
+                };
+            }
+            const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;
+            if (objectTypes.indexOf(objectTypeId) === -1) {
+                objectTypes.push(objectTypeId);
+            }
+            resultListItems.push({
+                objectTypeId,
+                content,
+                fields,
+                permissions: o.permissions
+            });
+        });
+        const result = {
+            hasMoreItems: searchResponse.hasMoreItems,
+            totalNumItems: searchResponse.totalNumItems,
+            items: resultListItems,
+            objectTypes
+        };
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class IdmService {
+    #backend = inject(BackendService);
+    queryOrganizationEntity(term, targetTypes, size) {
+        return this.#backend.get(`/idm/search?search=${term}${size ? `&size=${size}` : ''}`).pipe(map$1((res) => [
+            ...(targetTypes.includes('user')
+                ? res.users.map((u) => ({
+                    id: u.id,
+                    title: `${u.lastname}, ${u.firstname} (${u.username})`, // TODO: u.title,
+                    type: 'user'
+                }))
+                : []),
+            ...(targetTypes.includes('role')
+                ? res.roles.map((u) => ({
+                    id: u.name,
+                    title: u.name,
+                    type: 'role'
+                }))
+                : [])
+        ]));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Shows a message after completing each action.
+ */
+class NotificationService {
+    #toastService;
+    #authService;
+    #eventService;
+    constructor() {
+        this.#toastService = inject(ToastService);
+        this.#authService = inject(AuthService);
+        this.#eventService = inject(EventService);
+        /**
+         * Set to true to suppress any notifications
+         */
+        this.silent = false;
+        /**
+         * Default Notofication Options
+         *
+         */
+        this.options = {
+            position: 'bottom-end'
+        };
+        this.#authService.authenticated$.subscribe((a) => (this.silent = !a));
+        this.#eventService.on(YuvEventType.LOGOUT).subscribe(() => (this.silent = true));
+    }
+    /**
+     * Show info colored massage (blue)
+     *
+     * @param string title
+     * @param string msg
+     */
+    info(title, msg) {
+        this.toast(title, msg);
+    }
+    /**
+     * Show success colored massage (green)
+     * @param string title
+     * @param string msg
+     */
+    success(title, msg) {
+        this.toast(title, msg, 'success');
+    }
+    /**
+     * can not be in use
+     *
+     * @param string title
+     * @param string msg
+     */
+    wait(title, msg) {
+        this.toast(title, msg, 'wait');
+    }
+    /**
+     * Show error colored massage (red)
+     *
+     * @param string title
+     * @param string msg
+     */
+    error(title, msg) {
+        this.toast(title, msg, 'error', {
+            duration: 5
+        });
+    }
+    /**
+     * Show warning colored massage (yellow)
+     *
+     * @param string title
+     * @param string msg
+     */
+    warning(title, msg) {
+        this.toast(title, msg, 'warning');
+    }
+    /**
+     * Public wrapper for accessing the Toastr
+     *
+     * @param string title
+     * @param string msg
+     * @param string mode
+     * @param _options
+     */
+    toast(title, msg, mode, _options) {
+        this.doToast(title, msg, { ...this.options, ..._options }, mode);
+    }
+    /**
+     * Accessing the toastr service
+     *
+     * @param string msg
+     * @param string title
+     * @param options
+     * @param string mode
+     */
+    doToast(title, msg, options, mode) {
+        if (this.silent)
+            return;
+        switch (mode) {
+            case 'success': {
+                this.#toastService.success(title, msg, options);
+                break;
+            }
+            case 'error': {
+                this.#toastService.error(title, msg, options);
+                break;
+            }
+            case 'warning': {
+                this.#toastService.warning(title, msg, options);
+                break;
+            }
+            case 'confirm': {
+                this.#toastService.info(title, msg, options);
+                break;
+            }
+            default: {
+                this.#toastService.info(title, msg, options);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * EditingObserver service is used to track changes made inside the application, that should prevent
+ * doing something or going somewhere before the changes are persisted or ignored. For example when
+ * the user starts editing form data and tries to navigate away before saving the changes, this service
+ * will take care of notifying the user.
+ *
+ * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component
+ * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.
+ *
+ * Other components can ask the service for pending tasks to know whether or not to execute an action
+ * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)
+ *
+ * app.component will prevent relevant route changes while tasks are pending.
+ */
+class PendingChangesService {
+    constructor() {
+        this.#logger = inject(Logger);
+        this.#tasks = [];
+        this.#tasksSource = new ReplaySubject();
+        this.tasks$ = this.#tasksSource.asObservable();
+        // private customMsg = '';
+        this.#defaultMsg = 'You are currently editing the index data of a form that has not been saved. Unsaved data will be lost.';
+    }
+    #logger;
+    #tasks;
+    #tasksSource;
+    // private customMsg = '';
+    #defaultMsg;
+    /**
+     * Registers a task to be pending.
+     * @param message alert message
+     * @returns Unique id to be used for finishing this task
+     */
+    startTask(message) {
+        const taskId = Utils.uuid();
+        this.#tasks.push({ id: taskId, message: message });
+        this.#logger.debug('started pending task: ' + taskId);
+        this.#tasksSource.next(this.#tasks);
+        return taskId;
+    }
+    /**
+     * Finishes a task
+     * @param id The id of the task to be finished. This is the one the component got from startTask()
+     */
+    finishTask(id) {
+        if (id) {
+            this.#tasks = this.#tasks.filter((t) => t.id !== id);
+            this.#tasksSource.next(this.#tasks);
+            this.#logger.debug('finished pending task: ' + id);
+        }
+    }
+    /**
+     * Returns whether or not the service has pending tasks.
+     * If an id is provided, the method will check existence of one specific task.
+     *
+     * @param id The id of the task to be checked
+     * @returns
+     */
+    hasPendingTask(id) {
+        return !id ? !!this.#tasks.length : Array.isArray(id) ? this.#tasks.some((value) => id.includes(value.id)) : this.#tasks.map((t) => t.id).includes(id);
+    }
+    /**
+     * Returns whether or not the component|service has pending tasks.
+     * Checks via confirm dialog
+     * @param component
+     * @returns
+     */
+    check(component) {
+        if (component && component.hasPendingChanges ? !component.hasPendingChanges() : !this.hasPendingTask()) {
+            return false;
+        }
+        else {
+            const confirmed = confirm(this.#getConfirmMessage());
+            if (confirmed) {
+                this.clear();
+            }
+            return !confirmed;
+        }
+    }
+    checkForPendingTasks(taskIds) {
+        if (this.hasPendingTask(taskIds)) {
+            const confirmed = confirm(this.#getConfirmMessage());
+            if (confirmed) {
+                this.clear();
+            }
+            return !confirmed;
+        }
+        else {
+            return false;
+        }
+    }
+    #getConfirmMessage() {
+        let msg = '';
+        this.#tasks.forEach((t) => {
+            // do not apply messages twice
+            if (msg.indexOf(t.message || this.#defaultMsg) === -1) {
+                msg = `${msg}${msg.length > 0 ? '\n---\n' : ''}${t.message || this.#defaultMsg}`;
+            }
+        });
+        return msg;
+    }
+    /**
+     * Clear list of pending tasks
+     */
+    clear() {
+        this.#tasks = [];
+        this.#tasksSource.next(this.#tasks);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Providing a `PendingChangesComponent`.
+ */
+class PendingChangesGuard {
+    constructor(pendingChanges) {
+        this.pendingChanges = pendingChanges;
+    }
+    canDeactivate(component) {
+        // if there are no pending changes, just allow deactivation; else confirm first
+        return !this.pendingChanges.check(component);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, deps: [{ token: PendingChangesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: PendingChangesService }] });
+
+class PredictionService {
+    #backend = inject(BackendService);
+    classify(objectIDs, schemaObjectTypeId = 'CLASSIFICATION') {
+        const objects = objectIDs.map((objectID) => ({
+            properties: {
+                [BaseObjectTypeField.OBJECT_ID]: {
+                    value: objectID
+                }
+            }
+        }));
+        return this.#backend.post(`/classification?schemaObjectTypeId=${schemaObjectTypeId}`, { objects }, ApiBase.predict).pipe(map((res) => res.predictions.reduce((acc, curr) => ({
+            ...acc,
+            [curr[BaseObjectTypeField.OBJECT_ID].value]: {
+                objectId: curr[BaseObjectTypeField.OBJECT_ID].value,
+                properties: Object.keys(curr.properties).map((type) => ({
+                    type,
+                    probability: curr.properties[type].probability
+                }))
+            }
+        }), {})));
+    }
+    /**
+     * @param schemaObjectTypeId
+     * @param objectIDs
+     * @returns  Observable<Record<string, PredictionClassifyResult>> string is objectID
+     */
+    extract(schemaObjectTypeId, objectIDs) {
+        const searchParams = new URLSearchParams();
+        searchParams.append('schemaObjectTypeId', schemaObjectTypeId);
+        const objects = objectIDs.map((objectID) => ({
+            properties: {
+                [BaseObjectTypeField.OBJECT_ID]: {
+                    value: objectID
+                }
+            }
+        }));
+        return this.#backend.post(`/extraction?${searchParams.toString()}`, { objects }, ApiBase.predict).pipe(map((res) => res.predictions.reduce((acc, curr) => ({
+            ...acc,
+            [curr[BaseObjectTypeField.OBJECT_ID].value]: {
+                objectId: curr[BaseObjectTypeField.OBJECT_ID].value,
+                properties: curr.properties
+            }
+        }), {})));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SessionStorageService {
+    #TEMP_STORAGE_ENTRIES_KEY = 'yuv.core.sessionstorage.entries';
+    constructor() {
+        this.#clearTemporaryStorageEntries();
+    }
+    /**
+     * Add a reference to a temporary localstorage entry that should be cleared when a
+     * new browser session starts. In context of forms this will be used to cleanup the
+     * layout state of forms (selected tabs etc.) that are stored locally but should only
+     * be pesisted for one browser session.
+     * @param storageKey Key of the localstorage item
+     */
+    addTemporaryStorageEntry(storageKey) {
+        // entries will themselves be stored in localstorage so we can check for entries
+        // to be removed once the application starts
+        const current = this.#getTemporaryStorageEntries();
+        if (!current.includes(storageKey))
+            localStorage.setItem(this.#TEMP_STORAGE_ENTRIES_KEY, JSON.stringify([...current, storageKey]));
+    }
+    #clearTemporaryStorageEntries() {
+        this.#getTemporaryStorageEntries().forEach((e) => localStorage.removeItem(e));
+        localStorage.removeItem(this.#TEMP_STORAGE_ENTRIES_KEY);
+    }
+    #getTemporaryStorageEntries() {
+        let res = [];
+        const i = localStorage.getItem(this.#TEMP_STORAGE_ENTRIES_KEY);
+        if (i) {
+            try {
+                const entries = JSON.parse(i);
+                if (Array.isArray(entries))
+                    res = entries;
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return res;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Prevent app from running into 401 issues related to gateway timeouts.
+ */
+class AuthInterceptor {
+    /**
+     * @ignore
+     */
+    #userService = inject(UserService);
+    #auth = inject(AuthService);
+    #backend = inject(BackendService);
+    // readonly #oauthService = inject(OAuthService);
+    intercept(request, next) {
+        return next.handle(request).pipe(tap({
+            next: (event) => {
+                if (event instanceof HttpResponse) {
+                    // do stuff with response if you want
+                }
+            },
+            error: (error) => {
+                if (error instanceof HttpErrorResponse || error.isHttpErrorResponse) {
+                    if (error.status === 401) {
+                        if (this.#backend.authUsesOpenIdConnect()) {
+                            // this.#oauthService.initLoginFlow();
+                        }
+                        else {
+                            this.#auth.logout();
+                            this.#userService.logout();
+                        }
+                    }
+                }
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ *  Http Offline interceptor trys to serving offline content for method/url
+ */
+class OfflineInterceptor {
+    constructor(connectionService) {
+        this.connectionService = connectionService;
+        this.offline = false;
+        this.connectionService.connection$.subscribe((connectionState) => {
+            this.offline = !connectionState.isOnline;
+        });
+    }
+    intercept(request, next) {
+        return next.handle(request);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OfflineInterceptor, deps: [{ token: ConnectionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OfflineInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OfflineInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ConnectionService }] });
+
+/**
+ * Handles missing translations
+ * @ignore
+ */
+class EoxMissingTranslationHandler {
+    handle(params) {
+        return '!missing key: ' + params.key;
+    }
+}
+
+/**
+ * Loader that fetches translations based on the configured locations
+ * @ignore
+ */
+let EoxTranslateJsonLoader = class EoxTranslateJsonLoader {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        registerLocaleData(localeDe, 'de', localeExtraDe); // German
+        registerLocaleData(localeAr, 'ar', localeExtraAr); // Arabic
+        registerLocaleData(localeEs, 'es', localeExtraEs); // Spanish
+        registerLocaleData(localePt, 'pt', localeExtraPt); // Portuguese
+        registerLocaleData(localeFr, 'fr', localeExtraFr); // French
+        registerLocaleData(localeZh, 'zh', localeExtraZh); // Chinese
+        registerLocaleData(localeLv, 'lv', localeExtraLv); // Latvian
+        registerLocaleData(localeRu, 'ru', localeExtraRu); // Russian
+        registerLocaleData(localeIt, 'it', localeExtraIt); // Italian
+        registerLocaleData(localeSk, 'sk', localeExtraSk); // Slovak
+        registerLocaleData(localePl, 'pl', localeExtraPl); // Polish
+        registerLocaleData(localeUk, 'uk', localeExtraUk); // Ukrainian
+        registerLocaleData(localeJa, 'ja', localeExtraJa); // Japanese
+        registerLocaleData(localeKo, 'ko', localeExtraKo); // Korean
+        registerLocaleData(localeHi, 'hi', localeExtraHi); // Hindi
+        registerLocaleData(localeBn, 'bn', localeExtraBn); // Bengalese
+        registerLocaleData(localeVi, 'vi', localeExtraVi); // Vietnamese
+        registerLocaleData(localeTr, 'tr', localeExtraTr); // Turkish
+        registerLocaleData(localeNl, 'nl', localeExtraNl); // Dutch
+        registerLocaleData(localeNb, 'nb', localeExtraNb); // Norwegian
+        registerLocaleData(localeTh, 'th', localeExtraTh); // Thai
+        registerLocaleData(localeFi, 'fi', localeExtraFi); // Finnish
+        registerLocaleData(localeSv, 'sv', localeExtraSv); // Swedish
+        registerLocaleData(localeDeCh, 'de-CH', localeExtraDeCh); // German Swiss
+    }
+    /**
+     *
+     * @param string lang
+     * @returns Observable<Object>
+     */
+    getTranslation(lang) {
+        const t = this.config.translations.map((path) => this.loadTranslationFile(path, lang));
+        return forkJoin(t).pipe(map((res) => res.reduce((acc, x) => Object.assign(acc, x), {})));
+    }
+    loadTranslationFile(path, lang) {
+        return this.http.get(`${Utils.getBaseHref()}${path}${lang}.json`).pipe(catchError((e) => {
+            // ISO codes with more than 2 characters are sub-languages like de-CH.
+            // If there is no translation file for that sub-language we'll try to load
+            // the file for the base language (in this case de).
+            return lang.length > 2 ? this.loadTranslationFile(path, lang.substring(0, 2)) : of({});
+        }));
+    }
+};
+EoxTranslateJsonLoader = __decorate([
+    __param(1, Inject(CORE_CONFIG)),
+    __metadata("design:paramtypes", [HttpClient, CoreConfig])
+], EoxTranslateJsonLoader);
+
+/**
+ * @ignore
+ */
+class LoggerConsoleService {
+    constructor(config) {
+        this.config = config;
+        this.styles = {
+            info: 'color:blue',
+            debug: 'background: orange',
+            warn: 'background: rgba(255,0,0,.2);color: red',
+            error: 'background: red; color: #fff'
+        };
+    }
+    apply(fn, args) {
+        args = [`%c${fn}:`, 'font-family: monospace; font-size: 10px; padding: 2px 4px;' + this.styles[fn], ...args];
+        return this.shouldLog(fn) ? console && console[fn] && console[fn](...args) : null;
+    }
+    debug(...args) {
+        this.apply('debug', args);
+    }
+    error(...args) {
+        this.apply('error', args);
+    }
+    info(...args) {
+        this.apply('info', args);
+    }
+    log(...args) {
+        this.apply('log', args);
+    }
+    warn(...args) {
+        this.apply('warn', args);
+    }
+    shouldLog(level) {
+        let should = false;
+        const cfg = this.config.get('core.logging');
+        if (!cfg || !cfg.level)
+            return false;
+        switch (cfg.level) {
+            case 'debug': {
+                should = true;
+                break;
+            }
+            case 'error': {
+                should = ['error'].includes(level);
+                break;
+            }
+            case 'warn': {
+                should = ['warn', 'error'].includes(level);
+                break;
+            }
+            case 'info': {
+                should = ['info', 'warn', 'error'].includes(level);
+                break;
+            }
+            default: {
+            }
+        }
+        return should;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, deps: [{ token: ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ConfigService }] });
+
+function storageFactory() {
+    return localStorage;
+}
+/**
+ * `YuvClientCoreModule` provides a bunch of services to interact with a yuuvis backend.
+ *
+ *
+ */
+class YuvClientCoreModule {
+    /**
+     * @ignore
+     */
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error('YuvClientCoreModule is already loaded.');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreModule, deps: [{ token: YuvClientCoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreModule, imports: [i1.OAuthModule, i1$1.TranslateModule], exports: [YuvClientCoreSharedModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreModule, providers: [
+            { provide: Logger, useClass: LoggerConsoleService },
+            { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
+            { provide: HTTP_INTERCEPTORS, useClass: OfflineInterceptor, multi: true },
+            { provide: CORE_CONFIG, useClass: CoreConfig, deps: [CUSTOM_CONFIG] },
+            {
+                provide: APP_INITIALIZER,
+                useFactory: init_moduleFnc,
+                multi: true,
+                deps: [CORE_CONFIG, DeviceService, Logger, HttpClient, ConfigService, AuthService]
+            },
+            /**
+             * overriding translate modules defaults
+             * this works because providers are singletons
+             */
+            {
+                provide: TranslateLoader,
+                useClass: EoxTranslateJsonLoader,
+                deps: [HttpClient, CORE_CONFIG]
+            },
+            {
+                provide: MissingTranslationHandler,
+                useClass: EoxMissingTranslationHandler
+            },
+            { provide: OAuthStorage, useFactory: storageFactory },
+            provideHttpClient(withInterceptorsFromDi())
+        ], imports: [OAuthModule.forRoot({
+                resourceServer: {
+                    sendAccessToken: false,
+                    allowedUrls: []
+                }
+            }),
+            TranslateModule.forRoot(), YuvClientCoreSharedModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: YuvClientCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [YuvClientCoreSharedModule],
+                    imports: [OAuthModule.forRoot({
+                            resourceServer: {
+                                sendAccessToken: false,
+                                allowedUrls: []
+                            }
+                        }),
+                        TranslateModule.forRoot()], providers: [
+                        { provide: Logger, useClass: LoggerConsoleService },
+                        { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: OfflineInterceptor, multi: true },
+                        { provide: CORE_CONFIG, useClass: CoreConfig, deps: [CUSTOM_CONFIG] },
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: init_moduleFnc,
+                            multi: true,
+                            deps: [CORE_CONFIG, DeviceService, Logger, HttpClient, ConfigService, AuthService]
+                        },
+                        /**
+                         * overriding translate modules defaults
+                         * this works because providers are singletons
+                         */
+                        {
+                            provide: TranslateLoader,
+                            useClass: EoxTranslateJsonLoader,
+                            deps: [HttpClient, CORE_CONFIG]
+                        },
+                        {
+                            provide: MissingTranslationHandler,
+                            useClass: EoxMissingTranslationHandler
+                        },
+                        { provide: OAuthStorage, useFactory: storageFactory },
+                        provideHttpClient(withInterceptorsFromDi())
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: YuvClientCoreModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }] });
+
+/**
+ * @ignore
+ */
+class LocaleDecimalPipe extends DecimalPipe {
+    constructor(translate) {
+        super(translate.currentLang || 'en');
+        this.translate = translate;
+    }
+    transform(value, digits, locale) {
+        return super.transform(value, digits, locale || this.translate.currentLang || 'en');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleDecimalPipe, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocaleDecimalPipe, isStandalone: true, name: "localeDecimal" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleDecimalPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeDecimal',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+/**
+ * @ignore
+ */
+class LocalePercentPipe extends PercentPipe {
+    constructor(translate) {
+        super(translate.currentLang || 'en');
+        this.translate = translate;
+    }
+    transform(value, digits, locale) {
+        return super.transform(value, digits, locale || this.translate.currentLang || 'en');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalePercentPipe, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocalePercentPipe, isStandalone: true, name: "localePercent", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalePercentPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localePercent',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+/**
+ * @ignore
+ */
+class LocaleCurrencyPipe extends CurrencyPipe {
+    constructor(translate) {
+        super(translate.currentLang || 'en');
+        this.translate = translate;
+    }
+    transform(value, currencyCode, display, digits, locale) {
+        return super.transform(value, currencyCode, display, digits, locale || this.translate.currentLang || 'en');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleCurrencyPipe, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocaleCurrencyPipe, isStandalone: true, name: "localeCurrency" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeCurrency',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+class LocaleNumberPipe {
+    constructor(translate) {
+        this.translate = translate;
+        this.decimalSeparator = '.';
+        this.separator = ',';
+        this.decimalPipe = new LocaleDecimalPipe(this.translate);
+        this.updateSeparators(this.translate.currentLang);
+    }
+    transform(value, grouping, pattern, scale, digits, locale) {
+        value = Array.isArray(value) ? value[0] : value;
+        let number = this.decimalPipe.transform(value, digits, locale);
+        if (number && !grouping) {
+            number = number.replace(new RegExp('\\' + this.separator, 'g'), '');
+        }
+        return number ? (pattern || '{{number}}').replace('{{number}}', number) : number;
+    }
+    updateSeparators(lang) {
+        if (lang) {
+            const pattern = this.decimalPipe.transform(1111.11, '1.2-2', lang);
+            this.decimalSeparator = pattern[5];
+            this.separator = pattern[1];
+        }
+    }
+    stringToNumber(value) {
+        value = (value || '').replace(new RegExp('\\' + this.separator + "|\\s|'| ", 'g'), '').replace(this.decimalSeparator, '.');
+        if (typeof value === 'string' && !isNaN(Number(value) - parseFloat(value))) {
+            return Number(value);
+        }
+        return NaN;
+    }
+    numberToString(value, grouping, pattern, scale) {
+        value = Array.isArray(value) ? value[0] : value;
+        scale = typeof scale === 'number' ? scale : 2;
+        return this.transform(value, grouping, pattern, scale, `1.${scale}-${scale}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleNumberPipe, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocaleNumberPipe, isStandalone: true, name: "localeNumber" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeNumber',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+
+/**
+ * This pipe transforms its input (supposed to be a file size in bytes) into a more
+ * human readable format like for example 1MB or 200KB.
+ *
+ * @example
+ * <div *ngFor="let size of file | fileSize">...</div>
+ */
+class FileSizePipe extends LocaleNumberPipe {
+    constructor() {
+        super(...arguments);
+        this.k = 1024;
+        this.sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    }
+    transform(bytes = 0) {
+        if (bytes <= 1) {
+            return bytes === 1 ? '1 Byte' : '0 Bytes';
+        }
+        let i = Math.floor(Math.log(bytes) / Math.log(this.k));
+        return super.transform(parseFloat((bytes / Math.pow(this.k, i)).toFixed(2))) + ' ' + this.sizes[i];
+    }
+    stringToNumber(value) {
+        const sizes = this.sizes.map((s) => s.toLowerCase());
+        const match = value.toLowerCase().match(new RegExp(`(.*)(${sizes.join('|')})`));
+        const number = super.stringToNumber((match ? match[1] : value).trim());
+        return isNaN(number) ? number : Math.round(number * Math.pow(1024, match ? sizes.indexOf(match[2]) : 0));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileSizePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FileSizePipe, isStandalone: true, name: "fileSize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'fileSize', standalone: true }]
+        }] });
+
+const predefinedFormats = {
+    short: {
+        timeStyle: 'short',
+        dateStyle: 'short'
+    },
+    medium: {
+        timeStyle: 'medium',
+        dateStyle: 'medium'
+    },
+    shortDate: {
+        dateStyle: 'short'
+    }
+};
+class LocaleDatePipe {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    transform(value, format = 'short') {
+        if (!value)
+            return '';
+        else {
+            try {
+                return new Intl.DateTimeFormat(this.translate.currentLang, predefinedFormats[format]).format(!(value instanceof Date) ? new Date(value) : value);
+            }
+            catch (e) {
+                console.error(e);
+                return '';
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleDatePipe, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocaleDatePipe, isStandalone: true, name: "localeDate" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocaleDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeDate',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+
+/**
+ * This pipe bypass security and trust the given value to be safe HTML.
+ * Only use this when the bound HTML is unsafe (e.g. contains script tags and the code should be executed.).
+ * @example
+ * <div [innerHtml]="value | safeHtml"></div>
+ */
+class SafeHtmlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(style) {
+        return this.sanitizer.bypassSecurityTrustHtml(style);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1$2.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'safeHtml', standalone: true }]
+        }], ctorParameters: () => [{ type: i1$2.DomSanitizer }] });
+/**
+ * This pipe bypass security and trust the given value to be a safe style URL, i.e. a value that can be used in hyperlinks or img src.
+ * @example
+ * <iframe [src]="previewSrc | safeUrl"></iframe>
+ */
+class SafeUrlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustResourceUrl(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SafeUrlPipe, deps: [{ token: i1$2.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: SafeUrlPipe, isStandalone: true, name: "safeUrl" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SafeUrlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'safeUrl', standalone: true }]
+        }], ctorParameters: () => [{ type: i1$2.DomSanitizer }] });
+
+/**
+ * @ignore
+ */
+class KeysPipe {
+    transform(value) {
+        return Object.keys(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KeysPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: KeysPipe, isStandalone: true, name: "keys", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KeysPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'keys', pure: false, standalone: true }]
+        }] });
+
+class NativeNotificationService {
+    requestPermission() {
+        if ('Notification' in window) {
+            Notification.requestPermission().then((permission) => {
+                if (permission === 'granted') {
+                    console.log('Notification permission granted.');
+                }
+                else {
+                    console.log('Notification permission denied.');
+                }
+            });
+        }
+        else {
+            console.log('Notifications are not supported in this browser.');
+        }
+    }
+    showNotification(title, options) {
+        const preventBecauseTabActive = options?.preventOnTabActive && document.visibilityState === 'visible';
+        if ('Notification' in window && Notification.permission === 'granted' && !preventBecauseTabActive) {
+            const n = new Notification(title, options?.options);
+            n.onclick = (e) => {
+                window.focus();
+                if (options?.onClick)
+                    options.onClick();
+                n.close();
+            };
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NativeNotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NativeNotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NativeNotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+// TOKENS
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AFO_STATE, AdministrationRoles, ApiBase, AppCacheService, AuditField, AuditService, AuthService, BackendService, BaseObjectTypeField, BpmService, CORE_CONFIG, CUSTOM_CONFIG, CatalogService, Classification, ClassificationPrefix, ClientDefaultsObjectTypeField, ClipboardService, ColumnConfigSkipFields, ConfigService, ConnectionService, ContentStreamAllowed, ContentStreamField, CoreConfig, DeviceScreenOrientation, DeviceService, Direction, DmsObject, DmsService, EventService, FileSizePipe, IdmService, InternalFieldType, KeysPipe, LocaleCurrencyPipe, LocaleDatePipe, LocaleDecimalPipe, LocaleNumberPipe, LocalePercentPipe, Logger, LoginStateName, NativeNotificationService, NotificationService, ObjectConfigService, ObjectTag, ObjectTypeClassification, ObjectTypePropertyClassification, OidcService, Operator, OperatorLabel, ParentField, PendingChangesGuard, PendingChangesService, PredictionService, ProcessAction, RetentionField, RetentionState, SafeHtmlPipe, SafeUrlPipe, SearchService, SecondaryObjectTypeClassification, SessionStorageService, Situation, Sort, SystemResult, SystemSOT, SystemService, SystemType, TENANT_HEADER, UploadService, UserRoles, UserService, Utils, YuvClientCoreModule, YuvClientCoreSharedModule, YuvError, YuvEventType, YuvUser, init_moduleFnc, storageFactory };
+//# sourceMappingURL=yuuvis-client-core.mjs.map