@yuuvis/client-core 2.20.0 → 3.0.0-beta.20.0

package/index.d.ts

@@ -1,69 +1,3256 @@
+import { TranslateService } from '@ngx-translate/core';
 export { TranslateDirective, TranslateLoader, TranslateModule, TranslatePipe, TranslateService } from '@ngx-translate/core';
-export * from './lib/model/dms-object.interface';
-export * from './lib/model/dms-object.model';
-export * from './lib/model/object-flavor.interface';
-export * from './lib/model/range-value.interface';
-export * from './lib/model/yuv-error.model';
-export * from './lib/model/yuv-user.model';
-export * from './lib/service/audit/audit.interface';
-export * from './lib/service/audit/audit.service';
-export * from './lib/service/auth/auth.interface';
-export * from './lib/service/auth/auth.service';
-export * from './lib/service/backend/api.enum';
-export * from './lib/service/backend/backend.interface';
-export * from './lib/service/backend/backend.service';
-export * from './lib/service/bpm/bpm.interface';
-export * from './lib/service/bpm/bpm.service';
-export * from './lib/service/cache/app-cache.service';
-export * from './lib/service/catalog/catalog.interface';
-export * from './lib/service/catalog/catalog.service';
-export * from './lib/service/client-cache/client-cache.interface';
-export * from './lib/service/client-cache/client-cache.service';
-export * from './lib/service/clipboard/clipboard.interface';
-export * from './lib/service/clipboard/clipboard.service';
-export * from './lib/service/config/config.interface';
-export * from './lib/service/config/config.service';
-export * from './lib/service/config/core-config';
-export * from './lib/service/config/core-config.tokens';
-export * from './lib/service/connection/connection.service';
-export * from './lib/service/core-init/core-init.service';
-export * from './lib/service/device/device.interface';
-export * from './lib/service/device/device.service';
-export * from './lib/service/dms/dms.service';
-export * from './lib/service/dms/dms.service.interface';
-export * from './lib/service/event/event.interface';
-export * from './lib/service/event/event.service';
-export * from './lib/service/event/events';
-export * from './lib/service/idm/idm.service';
-export * from './lib/service/idm/models';
-export * from './lib/service/logger/logger.interface';
-export * from './lib/service/logger/logger.service';
-export * from './lib/service/notification/notification.service';
-export * from './lib/service/object-config/object-config.interface';
-export * from './lib/service/object-config/object-config.service';
-export * from './lib/service/object-form/object-form.interface';
-export * from './lib/service/object-form/object-form.model';
-export * from './lib/service/pending-changes';
-export * from './lib/service/prediction/prediction.interface';
-export * from './lib/service/prediction/prediction.service';
-export * from './lib/service/retention/retention.interface';
-export * from './lib/service/retention/retention.service';
-export * from './lib/service/search/search.service';
-export * from './lib/service/search/search.service.interface';
-export * from './lib/service/search/search.utils';
-export * from './lib/service/session-storage/session-storage.service';
-export * from './lib/service/system/system.enum';
-export * from './lib/service/system/system.interface';
-export * from './lib/service/system/system.service';
-export * from './lib/service/toast/toast.interface';
-export * from './lib/service/toast/toast.service';
-export * from './lib/service/upload/upload.interface';
-export * from './lib/service/upload/upload.service';
-export * from './lib/service/user/user-storage.service';
-export * from './lib/service/user/user.providers';
-export * from './lib/service/user/user.service';
-export * from './lib/util/utils';
-export * from './lib/util/utils.helper.enum';
-export * from './lib/common/pipes';
-export * from './lib/common/services/native-notifications';
-export * from './lib/provider';
+import * as i0 from '@angular/core';
+import { Type, Signal, InjectionToken, DoCheck, Provider, PipeTransform, EnvironmentProviders } from '@angular/core';
+import { Router, CanDeactivate } from '@angular/router';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import * as _yuuvis_client_core from '@yuuvis/client-core';
+import { DeviceInfo } from 'ngx-device-detector';
+import { FormControl, FormGroup } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { DecimalPipe, CurrencyPipe, PercentPipe } from '@angular/common';
+import { DomSanitizer, SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
+
+interface DmsObjectPermissions {
+    readIndexData: boolean;
+    readContent: boolean;
+    writeIndexData: boolean;
+    writeContent: boolean;
+    deleteObject: boolean;
+    deleteContent: boolean;
+}
+interface DmsObjectAuditInfo {
+    on: Date;
+    by: {
+        id: string;
+        title?: string;
+        name?: string;
+    };
+}
+interface DmsObjectTag {
+    name: string;
+    state: number;
+    creationDate: Date;
+    traceId: string;
+}
+
+interface ObjectOptions {
+    waitForSearchConsistency?: boolean;
+    scope?: string;
+}
+interface ObjectDeleteOptions extends ObjectOptions {
+    silent?: boolean;
+    greedy?: boolean;
+}
+interface ObjectDeleteResult {
+    id: string;
+    properties?: {
+        [key: string]: {
+            value: any;
+        };
+    };
+    _error?: ObjectDeleteError;
+}
+interface ObjectDeleteError {
+    status: number;
+    message: string;
+}
+interface ObjectMoveOptions extends ObjectOptions {
+    silent?: boolean;
+}
+interface ObjectCopyOptions extends ObjectOptions {
+}
+interface CoreApiObject {
+    properties: Record<string, CoreApiObjectProperty>;
+    contentStreams?: Partial<ContentStream$1>[];
+}
+interface CoreApiObjectProperty {
+    value: unknown;
+}
+interface ContentStream$1 {
+    contentStreamId: string;
+    repositoryId: string;
+    digest: string;
+    fileName: string;
+    size: number;
+    archivePath?: string;
+    range?: string;
+    mimeType: string;
+}
+interface CoreApiBatchResponse {
+    hasMoreItems: boolean;
+    numItems: number;
+    objects: CoreApiResponse[];
+    totalNumItems: number;
+}
+interface CoreApiResponse {
+    properties: Record<string, CoreApiObjectProperty>;
+    contentStreams?: ContentStream$1[];
+    options: {
+        'system:response': {
+            httpStatusCode: number;
+            serviceErrorCode?: number;
+            message: string;
+        };
+    };
+}
+
+type DateRange = 'today' | 'yesterday' | 'thisWeek' | 'lastWeek' | 'thisMonth' | 'lastMonth' | 'thisYear' | 'lastYear';
+type FilesizeRange = 'small' | 'medium' | 'large' | 'verylarge';
+interface SearchQuery {
+    term?: string;
+    scope?: 'metadata' | 'content';
+    size?: number;
+    from?: number;
+    fields?: string[];
+    aggs?: string[];
+    types?: string[];
+    filters?: SearchFilter[];
+    tableFilters?: TableFilter[];
+    sort?: SortOption[];
+    includePermissions?: boolean;
+}
+interface SortOption {
+    field: string;
+    order: 'asc' | 'desc';
+}
+interface SearchFilter {
+    f: string;
+    o: Operator;
+    v1: unknown;
+    v2?: unknown;
+    useNot?: boolean;
+}
+interface TableFilter {
+    table: string;
+    columnFilters: SearchFilter[];
+}
+declare enum Operator {
+    EQUAL = "eq",// equal
+    EEQUAL = "eeq",// exact equal
+    IN = "in",// match at least one of the provided values (value has to be an array)
+    GREATER_THAN = "gt",// greater than
+    GREATER_OR_EQUAL = "gte",// greater than or equal
+    LESS_THAN = "lt",// less than
+    LESS_OR_EQUAL = "lte",// less than or equal
+    INTERVAL = "gtlt",// interval
+    INTERVAL_INCLUDE_BOTH = "gtelte",// interval include left and right
+    INTERVAL_INCLUDE_TO = "gtlte",// interval include right
+    INTERVAL_INCLUDE_FROM = "gtelt",// interval include left
+    RANGE = "rg",// aggegation ranges
+    LIKE = "like",// like
+    CONTAINS = "contains"
+}
+declare const OperatorLabel: {
+    /** equal */
+    EQUAL: string;
+    /** exact equal */
+    EEQUAL: string;
+    /** match at least one of the provided values (value has to be an array)  */
+    IN: string;
+    /** greater than */
+    GREATER_THAN: string;
+    /** greater than or equal */
+    GREATER_OR_EQUAL: string;
+    LESS_THAN: string;
+    LESS_OR_EQUAL: string;
+    INTERVAL: string;
+    INTERVAL_INCLUDE_BOTH: string;
+    INTERVAL_INCLUDE_TO: string;
+    INTERVAL_INCLUDE_FROM: string;
+    RANGE: string;
+    LIKE: string;
+    CONTAINS: string;
+};
+interface SearchResponse {
+    hasMoreItems: boolean;
+    numItems: number;
+    totalNumItems: number;
+    objects: CoreApiObject[];
+}
+/**
+ * Interface providing a search service
+ */
+interface SearchResult {
+    hasMoreItems: boolean;
+    totalNumItems: number;
+    items: SearchResultItem[];
+    objectTypes: string[];
+    paging?: {
+        page: number;
+        totalPages: number;
+    };
+}
+/**
+ * Interface for the item of search results
+ */
+interface SearchResultItem {
+    objectTypeId: string;
+    content?: SearchResultContent;
+    permissions?: SearchResultPermissions;
+    fields: Map<string, any>;
+}
+interface SearchResultPermissions {
+    read: Array<'metadata' | 'content'>;
+    write: Array<'metadata' | 'content'>;
+    delete: Array<'object' | 'content'>;
+}
+type SearchResultContent = ContentStream$1;
+/**
+ * Interface providing the estimated result of the current query.
+ */
+interface AggregateResult {
+    /**
+     * number of results found
+     */
+    totalNumItems: number;
+    aggregations: Aggregation[];
+}
+interface AggregationEntry {
+    key: string;
+    count: number;
+}
+/**
+ * Property of a one search query aggregation
+ */
+interface Aggregation {
+    aggKey: string;
+    entries: AggregationEntry[];
+}
+
+/**
+ * `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.
+ */
+declare class DmsObject {
+    #private;
+    id: string;
+    parentId: string;
+    content?: ContentStream$1;
+    data: Record<string, unknown>;
+    isFolder: boolean;
+    objectTypeId: string;
+    permissions?: DmsObjectPermissions;
+    version: number;
+    created: DmsObjectAuditInfo;
+    modified: DmsObjectAuditInfo;
+    sots: string[];
+    /**
+     * @ignore
+     */
+    constructor(searchResultItem: SearchResultItem);
+}
+
+interface FlavoredDmsObject {
+    object: DmsObject;
+    flavors: ObjectTypeFlavor[];
+}
+interface ObjectTypeFlavor {
+    id: string;
+    icon?: string;
+    svgIcon?: boolean;
+    sot: string;
+    applicableTo?: {
+        mimeTypes?: string[];
+        folders?: boolean;
+        documents?: boolean;
+    };
+    preventApply?: boolean;
+    preventRemove?: boolean;
+}
+/**
+ * Create flavors can be used to provide a specific way of creating objects.
+ */
+interface ObjectCreateFlavor {
+    id: string;
+    descriptionKey?: string;
+    icon?: string;
+    withFileUpload?: {
+        applicableTo?: {
+            mimeTypes: string[];
+        };
+        multiple?: boolean;
+    };
+    sot?: string;
+    getCreateData?: (files?: File[]) => Record<string, unknown>;
+    afterCreate?: (ids: string[], router: Router) => void;
+    applyComponent?: Type<any>;
+    applyComponentDialogConfig?: {
+        width?: string;
+        height?: string;
+        minWidth?: number | string;
+        minHeight?: number | string;
+        maxWidth?: number | string;
+        maxHeight?: number | string;
+    };
+}
+
+/**
+ * Value class to be used with form elements that support ranges
+ */
+interface RangeValue<T = unknown> {
+    operator: Operator;
+    firstValue: T;
+    secondValue?: T;
+}
+
+/**
+ * @ignore
+ */
+declare class YuvError implements Error {
+    originalError: any | Error;
+    private _name?;
+    private _message?;
+    private _skipNotification;
+    get name(): any;
+    get message(): any;
+    get stack(): any;
+    get status(): any;
+    get url(): any;
+    get skipNotification(): boolean;
+    get isHttpErrorResponse(): any;
+    constructor(originalError: any | Error, _name?: string | undefined, _message?: string | undefined, _skipNotification?: boolean);
+    toString(): any;
+}
+
+/**
+ * Represents an entry in the organization set, which can be either a user or a role.
+ * Used in search results and organization entity queries.
+ */
+interface OrganizationSetEntry {
+    /** The unique identifier of the user or role */
+    id: string;
+    /** The display title/name for the entry */
+    title: string;
+    /** The type of organization entity */
+    type: 'user' | 'role';
+}
+
+/**
+ * Represents the user data structure returned from the IDM API.
+ * Contains all essential user information including authentication and authorization details.
+ */
+interface IdmUserResponse {
+    /** The unique username for login */
+    username: string;
+    /** The unique user identifier */
+    id: string;
+    /** The user's email address */
+    email: string;
+    /** The user's first name */
+    firstname: string;
+    /** The user's last name */
+    lastname: string;
+    /** Whether the user account is enabled/active */
+    enabled: boolean;
+    /** The tenant identifier this user belongs to */
+    tenant: string;
+    /** Array of granted authorities/permissions for the user */
+    authorities: string[];
+    /** The formatted display name for the user */
+    displayName: string;
+}
+
+/**
+ * Represents a cached user entry with expiration timestamp.
+ * Used internally by IdmService to manage user data caching.
+ */
+interface IdmCachedUser {
+    /** Timestamp when the cache expires (Date.now() + TTL) */
+    expires: number;
+    /** The cached user data from the IDM API */
+    user: IdmUserResponse;
+}
+
+/**
+ * Dictionary/map structure for storing cached user data.
+ * Keys are user IDs and values are cached user entries with expiration.
+ */
+interface IdmUserCache {
+    /** Map of user IDs to their cached user data */
+    [userId: string]: IdmCachedUser;
+}
+
+/**
+ * User account configuration
+ */
+declare class YuvUser {
+    private DEFAULT_USER_LOCALE;
+    id: string;
+    username: string;
+    firstname: string;
+    lastname: string;
+    title: string;
+    email: string;
+    tenant: string;
+    authorities: string[];
+    enabled: boolean;
+    /**
+     * User settings
+     */
+    uiDirection?: string;
+    /**
+     * User settings
+     */
+    userSettings: UserSettings;
+    /**
+     * @ignore
+     */
+    constructor(json: IdmUserResponse, userSettings?: UserSettings);
+    /**
+     * Gets the users configured client locale
+     * @returns locale string
+     */
+    getClientLocale(fallback?: string): string;
+    getFullName(): string;
+    getDisplayNameName(): string;
+}
+/**
+ * Interface for user settings
+ */
+interface UserSettings {
+    locale: string;
+    clientAppSettings?: Record<string, any>;
+}
+
+/**
+ * Is a part of `AuditQueryResult` interface
+ */
+interface AuditEntry {
+    action: number;
+    actionGroup: number;
+    detail: string;
+    subaction?: number;
+    creationDate: Date;
+    version: number;
+    createdBy: {
+        id: string;
+        title: string;
+    };
+    more?: string;
+}
+/**
+ * Interface for a result object of a former audits query
+ */
+interface AuditQueryResult {
+    /**
+     * the original query, needed for later on paging requests
+     */
+    query: SearchQuery;
+    items: AuditEntry[];
+    hasMoreItems: boolean;
+    /**
+     * the page of the current result (in case of multi-page results, otherwise 1)
+     */
+    page: number;
+}
+interface AuditQueryOptions {
+    /**
+     * List of actions (codes) to restricts the audits to
+     */
+    actions?: string[];
+    /**
+     * Actions that should explicitly NOT be fetched
+     */
+    skipActions?: number[];
+    /**
+     * Whether or not to query all audit entries, without the user
+     * or admin filter conditions
+     */
+    allActions?: boolean;
+}
+
+/**
+ * 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.
+ */
+declare class AuditService {
+    #private;
+    private DEFAULT_RES_SIZE;
+    private userAuditActions;
+    private adminAuditActions;
+    /**
+     * Get audit entries of a dms object
+     * @param id The id of the object to get the audit entries for
+     * @param options Options
+     */
+    getAuditEntries(id: string, options?: AuditQueryOptions): Observable<AuditQueryResult>;
+    /**
+     * 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: boolean, skipActions?: number[]): number[];
+    /**
+     * 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: AuditQueryResult, page: number): Observable<AuditQueryResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditService>;
+}
+
+/**
+ * Result when calling loginDevice endpoint in cloud environment
+ * when using device flow
+ */
+interface LoginDeviceResult {
+    user_code: string;
+    device_code: string;
+    interval: number;
+    verification_uri: string;
+    expires_in: number;
+}
+/**
+ * @ignore
+ */
+interface StoredToken {
+    accessToken: string;
+    tenant: string;
+}
+/**
+ * State emitted by the login function when using the device flow
+ */
+interface LoginState {
+    name: LoginStateName;
+    data: any;
+}
+declare enum LoginStateName {
+    STATE_LOGIN_URI = "login.uri",
+    STATE_DONE = "login.done",
+    STATE_CANCELED = "login.canceled"
+}
+interface YuvInitError {
+    status: number;
+    key: string;
+}
+
+/**
+ * Interface for the applications main config file
+ * @ignore
+ */
+interface YuvConfig {
+    core: {
+        languages: YuvConfigLanguages[];
+        logging?: {
+            level: 'debug' | 'error' | 'warn' | 'info';
+        };
+        permissions?: {
+            retentionManagerRole?: string;
+            advancedUserRole?: string;
+            manageSettingsRole?: string;
+        };
+    };
+    location?: {
+        hostname?: string;
+        port?: number;
+    };
+}
+/**
+ * interface providing localization of application
+ */
+interface YuvConfigLanguages {
+    iso: string;
+    label: string;
+    dir?: Direction;
+    fallback?: boolean;
+}
+declare enum Direction {
+    LTR = "ltr",
+    RTL = "rtl"
+}
+
+/**
+ * @ignore
+ */
+declare class CoreConfig {
+    main?: YuvConfig | string[];
+    translations?: string[];
+    environment?: {
+        production: boolean;
+    };
+    constructor(__config: CoreConfig);
+}
+
+/**
+ * Service handling authentication related issues.
+ */
+declare class AuthService {
+    #private;
+    coreConfig: CoreConfig;
+    authenticated$: Observable<boolean>;
+    initError?: YuvInitError;
+    constructor(coreConfig: CoreConfig);
+    isLoggedIn(): boolean;
+    /**
+     * Called while app/core is initialized (APP_INITIALIZER)
+     * @ignore
+     */
+    initUser(): Observable<YuvUser>;
+    /**
+     * Get the current tenant or the previous one persisted locally
+     */
+    getTenant(): string;
+    /**
+     * Fetch information about the user currently logged in
+     */
+    fetchUser(): Observable<YuvUser>;
+    /**
+     * Logs out the current user.
+     */
+    logout(): void;
+    /**
+     * Persists the initial request URI. This is nessesary to be able to
+     * redirect the user to the requested page after authentication.
+     * This is done on app initialization (core-init).
+     */
+    setInitialRequestUri(): Observable<boolean>;
+    /**
+     * 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(): Observable<{
+        uri: string;
+        timestamp: number;
+    }>;
+    resetInitialRequestUri(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+interface AuthData {
+    tenant: string;
+    language: string;
+}
+
+declare enum ApiBase {
+    core = "api",
+    apiWeb = "api-web/api",
+    predict = "predict-api/api",
+    custom = "custom",
+    none = ""
+}
+
+/**
+ * HttpOptions for http request
+ * @param observe: 'body' | 'events' | 'response'
+ * @param responseType: 'arraybuffer' | 'blob' | 'json' | 'text'
+ */
+interface HttpOptions {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    observe?: any;
+    params?: HttpParams | {
+        [param: string]: string | string[];
+    };
+    reportProgress?: boolean;
+    responseType?: any;
+    withCredentials?: boolean;
+}
+interface HttpDeleteOptions extends HttpOptions {
+    body?: any;
+}
+
+/**
+ * Load and provide configuration for hole apllication while application is inizialized.
+ */
+declare class ConfigService {
+    private translate;
+    static GLOBAL_RESOURCES: string;
+    static PARSER(c: any): any;
+    static GLOBAL_MAIN_CONFIG(prefix?: 'system' | 'admin' | ''): string;
+    static GLOBAL_MAIN_CONFIG_LANG(iso?: string, prefix?: 'system' | 'admin' | ''): string;
+    static GLOBAL_RESOURCES_PATH(section?: string, prefix?: 'system' | 'admin' | ''): string;
+    private cfg?;
+    /**
+     * Set during app init (see CoreInit)
+     * @ignore
+     */
+    set(cfg: YuvConfig): void;
+    get(configKey: string): any;
+    extendTranslations(translations: any, lang?: string): void;
+    extendConfig(configs: YuvConfig[]): void;
+    private _mergeConfigs;
+    /**
+     * Getter for the available client locales
+     * @returns available client locales
+     */
+    getClientLocales(): YuvConfigLanguages[];
+    getApiBase(api?: string, origin?: boolean): string;
+    /**
+     * Get the default client locale
+     * @returns ISO string of the locale
+     */
+    getDefaultClientLocale(): string;
+    private _getCoreConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+
+/**
+ * Service for HTTP communication with the yuuvis Momentum backend.
+ *
+ * This service wraps Angular's HttpClient and provides:
+ * - Automatic base URI management for different backend services
+ * - Centralized header management (authorization, content-type, etc.)
+ * - Response caching with configurable TTL
+ * - HTTP activity tracking for session management
+ * - Standardized error handling and logging
+ *
+ * **Why Use This Service:**
+ * Applications should use BackendService instead of HttpClient directly because
+ * required headers (authentication, content-type) are automatically managed,
+ * and apps don't have to handle backend URL construction and prerequisites.
+ *
+ * **HTTP Activity Tracking:**
+ * All HTTP requests emit events via `httpCommunicationOccurred$`, which is used by
+ * SessionService and other consumers to detect user activity and keep sessions alive.
+ *
+ * @see {@link SessionService} for session management integration (Task HAR-2975)
+ */
+declare class BackendService {
+    #private;
+    configService: ConfigService;
+    httpCommunicationOccurred$: Observable<void>;
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders(): HttpHeaders;
+    /**
+     * 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: string, value: string): void;
+    /**
+     * Performs an HTTP GET request against a yuuvis Momentum backend endpoint.
+     *
+     * Automatically prepends the resolved base URI (via {@link getApiBase}) to the given `uri`,
+     * applies centralized headers (authorization, content-type) and emits an event on
+     * `httpCommunicationOccurred$` after each successful response — used by SessionService
+     * to keep the session alive.
+     *
+     * @param uri REST URI relative to the selected backend service base. Must start with `/`,
+     *   e.g. `/api/dms/objects/{objectId}`.
+     * @param base Selects which backend service base URL to use.
+     * @param requestOptions Optional Angular `HttpClient` options (headers, params, responseType, etc.)
+     *   merged on top of the default headers set by this service.
+     * @returns An `Observable<T>` that emits the deserialized response body and completes.
+     *   Unsubscribing before completion cancels the underlying HTTP request.
+     */
+    get<T = any>(uri: string, base?: string, requestOptions?: HttpOptions): Observable<T>;
+    /**
+     * 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<T = any>(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<T>;
+    /**
+     * 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 (see HttpRequest for details)
+     * @returns The return value of the target POST endpoint
+     */
+    postMultiPart(uri: string, formData: FormData, base?: string, requestOptions?: any): Observable<any>;
+    /**
+     * 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<T = any>(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<T>;
+    /**
+     * 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<T = any>(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<T>;
+    /**
+     * 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<T = any>(uri: string, base?: string, requestOptions?: HttpDeleteOptions): Observable<T>;
+    /**
+     * @ignore
+     * Cache for small requests like icons and configs
+     *
+     * @param string uri
+     * @returns Observable<any>
+     */
+    getViaCache(uri: string): Observable<any>;
+    /**
+     * @ignore
+     * Temporary Cache for multiple identical requests
+     *
+     * @param string id
+     * @param Function request
+     * @returns Observable<any>
+     */
+    getViaTempCache(id: string, request?: () => Observable<object>): Observable<any>;
+    download(uri: string, filename?: string): void;
+    /**
+     * 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?: string, origin?: boolean): string;
+    /**
+     * @ignore
+     */
+    getHttpOptions(requestOptions?: HttpOptions): HttpOptions;
+    /**
+     * Batch service
+     */
+    batch(requests: {
+        method?: string;
+        uri: string;
+        body?: any;
+        base?: string;
+        requestOptions?: HttpOptions;
+    }[]): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackendService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BackendService>;
+}
+
+declare const ProcessAction: {
+    complete: string;
+    claim: string;
+    delegate: string;
+    resolve: string;
+    save: string;
+};
+interface Process {
+    id: string;
+    attachments: string[];
+    businessKey: string;
+    deleteReason: string;
+    durationInMillis: number;
+    endActivityId: string;
+    endTime: Date;
+    initiator: ProcessUser;
+    name: string;
+    processDefinition: {
+        description: string;
+        id: string;
+        idPrefix: string;
+        name: string;
+    };
+    startActivityId: string;
+    startTime: Date;
+    startUserId: string;
+    suspended?: boolean;
+    variables: ProcessVariable[];
+}
+interface ProcessCreatePayload extends ProcessPostPayload {
+    processDefinitionKey: string;
+    name?: string;
+    businessKey?: string;
+    returnVariables?: boolean;
+}
+interface ProcessPostPayload {
+    variables?: ProcessVariable[];
+    attachments?: string[];
+    subject?: string;
+}
+interface ProcessVariable {
+    name: string;
+    type?: string;
+    value: any;
+    readonly?: boolean;
+    scope?: string;
+}
+/**
+ * Tasks are basically activities defined by a process.
+ * Processes may contain several tasks.
+ */
+interface InboxTask {
+    id: string;
+    processInstanceId: string;
+    assignee: ProcessUser;
+    claimTime: Date;
+    createTime: Date;
+    dueDate: Date;
+    description: string;
+    delegationState?: string;
+    formKey: string;
+    initiator: ProcessUser;
+    name: string;
+    owner: ProcessUser;
+    parentTaskId: string;
+    processDefinition: {
+        id: string;
+        idPrefix: string;
+    };
+    subject: string;
+    suspended: false;
+    variables: ProcessVariable[];
+    resolvedValues?: {
+        [id: string]: string;
+    };
+    attachments: string[];
+}
+interface ProcessUser {
+    id: string;
+    title: string;
+}
+interface FetchTaskOptions {
+    businessKey?: string;
+    includeProcessVar?: boolean;
+    isCompleted?: boolean;
+    processDefinitionKey?: string;
+}
+
+declare class BpmService {
+    #private;
+    startProcess(payload: ProcessCreatePayload): Observable<any>;
+    /**
+     * 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: string, payload?: ProcessPostPayload): Observable<any>;
+    updateTask(taskId: string, payload?: ProcessPostPayload): Observable<any>;
+    getProcessPoll(): Observable<any>;
+    getProcessInstance(processDefinitionKey: string, options?: FetchTaskOptions): Observable<Process>;
+    deleteProcess(processInstanceId: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BpmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BpmService>;
+}
+
+/**
+ * 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.
+ */
+declare class AppCacheService {
+    #private;
+    /**
+     * Set item in storage.
+     * @param key The key under which the value is stored.
+     * @param value The value to store.
+     * @returns An Observable that emits true when the operation is successful.
+     */
+    setItem<T = any>(key: string, value: T): Observable<boolean>;
+    /**
+     * Get item from storage.
+     * @param key The key of the item to retrieve.
+     * @returns An Observable that emits the retrieved value.
+     */
+    getItem<T = any>(key: string): Observable<T>;
+    /**
+     * Remove item from storage.
+     * @param key The key of the item to remove.
+     * @returns An Observable that emits true when the operation is successful.
+     */
+    removeItem(key: string): Observable<boolean>;
+    /**
+     * Clear storage, optionally filtered by a function.
+     * @param filter A function to filter which keys to clear.
+     * @returns An Observable that emits true when the operation is successful.
+     */
+    clear(filter?: (key: any) => boolean): Observable<boolean>;
+    /**
+     * Get all storage keys.
+     * @returns An Observable that emits an array of all storage keys.
+     */
+    getStorageKeys(): Observable<string[]>;
+    setStorage(options: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppCacheService>;
+}
+
+interface BaseCatalog {
+    entries: CatalogEntry[];
+    readonly?: boolean;
+}
+interface Catalog extends BaseCatalog {
+    qname: string;
+    tenant?: string;
+}
+interface CatalogEntry {
+    name: string;
+    disabled?: boolean;
+}
+
+declare class CatalogService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogService>;
+}
+
+interface CacheEntry<T> {
+    expires?: number;
+    id: string;
+    data: T;
+}
+
+/**
+ * Service for client-side caching of data with expiry handling.
+ * Provides methods to get, update, and invalidate cache entries.
+ */
+declare class ClientCacheService {
+    #private;
+    /**
+     * Get cached entry by ID.
+     * @param id  The ID of the cache entry.
+     * @param keepIfExpired Whether to return/keep the entry even if it is expired.
+     * @returns The cached data or null if not found/expired.
+     */
+    getFromCache<T>(id: string, keepIfExpired?: boolean): Observable<T | null>;
+    /**
+     * Update or add cache entry.
+     * @param id The ID of the cache entry.
+     * @param data The data to cache.
+     * @param ttl TimeToLeave - The cache expiry time in milliseconds (how long to keep the cache entry valid).
+     */
+    updateCache<T>(id: string, data: T, ttl?: number): Observable<CacheEntry<T>>;
+    /**
+     * Invalidate cache entry by ID. This will remove the entry from the cache.
+     * @param id The ID of the cache entry to invalidate.
+     */
+    invalidateCache(id: string): Observable<boolean>;
+    /**
+     * Clear all client cache entries.
+     */
+    clear(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientCacheService>;
+}
+
+interface ClipboardStore {
+    buckets?: Record<string, ClipboardData>;
+    main?: ClipboardData;
+}
+interface ClipboardData {
+    mode?: ClipboardDataMode;
+    files?: File[];
+    objects?: DmsObject[];
+}
+type ClipboardDataMode = 'copy' | 'cut';
+
+declare class ClipboardService {
+    #private;
+    clipboard(bucket?: string): Signal<ClipboardData | undefined>;
+    clipboard$(bucket?: string): Observable<ClipboardData | undefined>;
+    paste$(bucket?: string): Observable<ClipboardData>;
+    getClipboardData(bucket?: string): ClipboardData | undefined;
+    /**
+     * 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: DmsObject[], mode: ClipboardDataMode, bucket?: string): void;
+    clear(bucket?: string): void;
+    addToNavigatorClipBoard(data: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}
+
+/**
+ * @ignore
+ */
+declare const CUSTOM_CONFIG: InjectionToken<CoreConfig>;
+declare const CORE_CONFIG: InjectionToken<CoreConfig>;
+
+/**
+ * Service to monitor the online/offline state of the application.
+ * It listens to the browser's online and offline events and provides an observable
+ * to track the current connection state.
+ *
+ * An observable `connection$` is provided which emits the current connection state
+ * whenever the online or offline state changes. The initial state is determined by
+ * the `window.navigator.onLine` property.
+ */
+declare class ConnectionService {
+    private currentState;
+    private connectionStateSource;
+    connection$: Observable<ConnectionState>;
+    /**
+     * @ignore
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionService>;
+}
+/**
+ * Check a connection state of a client
+ */
+interface ConnectionState {
+    /**
+     * whether or not the application is online.
+     */
+    isOnline: boolean;
+}
+
+/**
+ * Providing functions,that are are injected at application startup and executed during app initialization.
+ */
+declare const init_moduleFnc: () => rxjs.Observable<boolean | _yuuvis_client_core.YuvUser | YuvConfig[]>;
+
+declare enum DeviceScreenOrientation {
+    PORTRAIT = "portrait",
+    LANDSCAPE = "landscape"
+}
+interface DeviceScreen {
+    size: ScreenSize;
+    orientation: DeviceScreenOrientation;
+    width: number;
+    height: number;
+}
+interface DeviceScreenBounds {
+    width: number;
+    height: number;
+}
+type ScreenSize = 's' | 'm' | 'l' | 'xl';
+
+/**
+ * @deprecated This service is deprecated. Please use the DeviceService from the `@yuuvis/material` package instead.
+ *
+ * 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>
+ * ```
+ */
+declare class DeviceService {
+    #private;
+    screenChange$: Observable<DeviceScreen>;
+    /**
+     * Signal to indicate if the screen size is small (e.g. mobile phone).
+     * This will only be triggered if `supportsSmallScreens` is set to true.
+     * Major components will use this metric to adapt to 'small screen behavior' and so can you
+     */
+    smallScreenLayout: i0.WritableSignal<boolean>;
+    /**
+     * if the device is a mobile device (android / iPhone / windows-phone etc)
+     */
+    isMobile: boolean;
+    /**
+     *  if the device us a tablet (iPad etc)
+     */
+    isTablet: boolean;
+    /**
+     * if the app is running on a Desktop browser
+     */
+    isDesktop: boolean;
+    info?: DeviceInfo;
+    isTouchEnabled: boolean;
+    constructor();
+    init(supportsSmallScreens?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceService>;
+}
+
+interface FileUploadOptions {
+    label?: string;
+    silent?: boolean;
+    scope?: string;
+}
+
+/**
+ * Service for working with dms objects: create them, delete, etc.
+ */
+declare class DmsService {
+    #private;
+    /**
+     * 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: string, indexdata: any, files: File[], label?: string, silent?: boolean, options?: ObjectOptions): Observable<string[]>;
+    /**
+     * Delete a dms object.
+     * @param id ID of the object to be deleted
+     */
+    deleteDmsObject(id: string, silent?: boolean): Observable<any>;
+    /**
+     * 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: string, version: number, silent?: boolean): Observable<any>;
+    /**
+     * 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
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     *
+     * @deprecated use uploadFileContent instead. Provide label and silent through `options`
+     */
+    uploadContent(objectId: string, file: File, label?: string, silent?: boolean): Observable<any>;
+    /**
+     * Uploads a file as the content of an existing DMS object, replacing or setting its content stream.
+     *
+     * This is the preferred alternative to the legacy `uploadContent()` method. It accepts a typed
+     * `FileUploadOptions` object instead of individual parameters, which enables full control over
+     * the upload label, silent mode, and scope-based progress visibility.
+     *
+     * After a successful upload, a `DMS_OBJECT_UPDATED` event is triggered automatically so that
+     * any subscribed parts of the application can react to the change (e.g. refreshing a preview).
+     *
+     * **Behavior:**
+     * - Targets the content endpoint of the given DMS object: `/dms/objects/{objectId}/contents/file`
+     * - `options.label` is shown in the upload progress indicator; falls back to `file.name` if omitted
+     * - If `options.silent` is `true`, the upload runs in the background with no UI feedback
+     *   and no `DMS_OBJECT_UPDATED` event is emitted
+     * - `options.scope` tags the upload so that only the `UploadProgressComponent` instance
+     *   configured with the same scope will display progress for this upload
+     *
+     * @param objectId - ID of the DMS object whose content should be uploaded or replaced
+     * @param file - The `File` object to upload as the new content stream
+     * @param options - Upload configuration: label, silent mode, and optional scope
+     * @returns An `Observable` that emits the updated DMS object on completion
+     *
+     * @example
+     * ```typescript
+     * // Replace content with a visible progress indicator
+     * this.dmsService.uploadFileContent(objectId, file, { label: 'Uploading contract.pdf' }).subscribe();
+     *
+     * // Silent replacement (no UI feedback, no event emitted)
+     * this.dmsService.uploadFileContent(objectId, file, { label: 'report.pdf', silent: true }).subscribe();
+     *
+     * // Scoped upload — only UploadProgressComponent with scope 'detail-panel' will show this
+     * this.dmsService
+     *   .uploadFileContent(objectId, file, { label: 'photo.jpg', scope: 'detail-panel' })
+     *   .subscribe();
+     * ```
+     */
+    uploadFileContent(objectId: string, file: File, options: FileUploadOptions): Observable<unknown>;
+    /**
+     * Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     */
+    getContentPath(objectId: string, version?: number): string;
+    /**
+     * 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: string, version?: number, rendition?: boolean): string;
+    getSlideURI(objectId: string, mimeType?: string): string | 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: DmsObject[], withVersion?: boolean): void;
+    /**
+     * Fetch a dms object.
+     * @param id ID of the object to be retrieved
+     * @param version Desired version of the object
+     */
+    getDmsObject(id: string, version?: number, silent?: boolean, requestOptions?: HttpOptions): Observable<DmsObject>;
+    /**
+     * Get tags of a dms object.
+     * @param objectData  Data field of the dms object
+     */
+    getDmsObjectTags(objectData: Record<string, unknown>): DmsObjectTag[];
+    /**
+     * 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: string, tag: string, value: any, silent?: boolean): Observable<any>;
+    /**
+     * Deletes a tag from a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be deleted
+     */
+    deleteDmsObjectTag(id: string, tag: string, silent?: boolean): Observable<any>;
+    /**
+     * 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: string, data: any, silent?: boolean, options?: ObjectOptions): Observable<DmsObject>;
+    /**
+     * Updates given objects.
+     * @param objects the objects to updated
+     */
+    updateDmsObjects(objects: {
+        id: string;
+        data: {
+            [key: string]: any;
+        };
+    }[], silent?: boolean, options?: ObjectOptions): Observable<DmsObject[]>;
+    /**
+     * 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: string[], tag: string, value: any, silent?: boolean): Observable<any>;
+    /**
+     * 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: string | null, objects: DmsObject[], options?: ObjectMoveOptions): Observable<any>;
+    /**
+     * 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: string | null, objects: DmsObject[], options?: ObjectCopyOptions): Observable<CoreApiResponse>;
+    /**
+     * Get a bunch of dms objects.
+     * @param ids List of IDs of objects to be retrieved
+     */
+    getDmsObjects(ids: string[], silent?: boolean): Observable<DmsObject[]>;
+    /**
+     * 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: string[] | {
+        id: string;
+        subject: string;
+    }[], options?: ObjectDeleteOptions): Observable<ObjectDeleteResult[]>;
+    /**
+     * Fetch a dms object versions.
+     * @param id ID of the object to be retrieved
+     */
+    getDmsObjectVersions(id: string): Observable<DmsObject[]>;
+    getDmsObjectVersion(id: string, version: number): Observable<DmsObject>;
+    coreApiResponseToDmsObject(res: CoreApiResponse): DmsObject;
+    /**
+     * Transforms a plain data object to a DmsObject.
+     * @param data The plain data object
+     * @returns DmsObject
+     */
+    toDmsObject(data: Record<string, unknown>): DmsObject;
+    batchUpdateTag(ids: string[], tag: string, value: any): Observable<any[]>;
+    batchDeleteTag(ids: string[], tag: string): Observable<any[]>;
+    batchDelete(ids: string[]): Observable<any[]>;
+    batchGet(ids: string[]): Observable<any[]>;
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse: SearchResponse): SearchResult;
+    private triggerEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DmsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DmsService>;
+}
+
+/**
+ * Triggerable and Subscribable events
+ * 1 & T creates an intersection of the literal type 1 and type T, this results in never since nothing can be both 1 and string except for any.
+ * 0 dose not extends never or 1, so if T is any, the condition resolves to true.
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+interface YuvEvent<D = any> {
+    /**
+     * type
+     */
+    type: string;
+    /**
+     * data to be passed along with the event if T is 'any' data is optional
+     */
+    data: IsAny<D> extends true ? D | undefined : D;
+}
+/**
+ * Mandatory Custom event prefix for all custom YUV events
+ */
+declare const CUSTOM_YUV_EVENT_PREFIX = "yuv.";
+/**
+ * Message event interface for postMessage events
+ */
+interface YuvMessage {
+    type: string;
+    data: any;
+    timestamp: number;
+    source: string;
+}
+/**
+ * Generic call-signature for triggering events.
+ * - If `T` is `string`, the `type` parameter will be that string literal type.
+ * - If `T` is `any`, the `data` parameter will be optional.
+ * - Otherwise `data` is required.
+ */
+type Trigger = <T = any>(type: T extends string ? T : string, ...data: IsAny<T> extends true ? [data?: T] : [data: T]) => void;
+
+/**
+ * Service for providing triggered events
+ */
+declare class EventService {
+    #private;
+    event$: Observable<YuvEvent>;
+    constructor();
+    /**
+     * Triggers a postMessage event that will be sent to the yuuvis global event Trigger
+     * @param type Type/key of the event
+     * @param data Data to be sent along with the event
+     */
+    triggerPostMessageEvent(type: string, data?: any): void;
+    /**
+     * Trigger an global event
+     * @param type Type/key of the event
+     * @param data Data to be send along with the event
+     */
+    trigger<T extends string = any, D = any>(type: IsAny<T> extends true ? string : T, ...args: IsAny<D> extends true ? [data?: D] : [data: D]): void;
+    /**
+     * Listen on a triggered event
+     * @param types Type/key of the event
+     */
+    on<T extends string = any, D = any>(...types: (IsAny<T> extends true ? string : T)[]): Observable<YuvEvent<D>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventService>;
+}
+
+/**
+ * Events emitted by parts of the application
+ */
+declare enum YuvEventType {
+    LOGOUT = "yuv.user.logout",
+    CLIENT_LOCALE_CHANGED = "yuv.user.locale.client.changed",
+    DMS_OBJECT_LOADED = "yuv.dms.object.loaded",
+    DMS_OBJECT_CREATED = "yuv.dms.object.created",
+    DMS_OBJECT_DELETED = "yuv.dms.object.deleted",
+    DMS_OBJECT_UPDATED = "yuv.dms.object.updated",
+    DMS_OBJECT_CONTENT_UPDATED = "yuv.dms.object.content.updated",
+    DMS_OBJECTS_MOVED = "yuv.dms.objects.moved",
+    RELATIONSHIP_CREATED = "yuv.dms.relationship.created",
+    RELATIONSHIP_DELETED = "yuv.dms.relationship.deleted"
+}
+interface YuvEventDeletedData {
+    id: string;
+    properties: Record<string, unknown>;
+}
+type YuvEventUpdatedData = DmsObject;
+type YuvEventCreatedData = string[];
+
+/**
+ * Service for managing Identity Management (IDM) operations.
+ * Provides functionality for querying users, roles, and organization entities,
+ * with built-in caching mechanisms to optimize performance.
+ */
+declare class IdmService {
+    #private;
+    userCache: IdmUserCache;
+    constructor();
+    /**
+     * Queries organization entities (users and/or roles) based on search term.
+     *
+     * @param term - The search term to filter entities
+     * @param targetTypes - Array of entity types to search for ('user', 'role')
+     * @param size - Optional maximum number of results to return
+     * @returns Observable array of organization set entries matching the search criteria
+     */
+    queryOrganizationEntity(term: string, targetTypes: string[], size?: number): Observable<OrganizationSetEntry[]>;
+    /**
+     * Retrieves available roles, optionally filtered by a search term.
+     *
+     * @param role - Optional search term to filter roles by name
+     * @returns Observable array of role objects containing name and description
+     */
+    getRoles(role?: string): Observable<{
+        name: string;
+        description: string;
+    }[]>;
+    /**
+     * Retrieves user information by user ID with automatic caching.
+     * Uses a 1-hour TTL cache to minimize backend requests.
+     *
+     * @param id - The unique identifier of the user
+     * @returns Observable of YuvUser object or null if user is not found
+     */
+    getUserById(id: string): Observable<YuvUser | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdmService>;
+}
+
+/**
+ * Interface providing a default logger, that is used for the Dependency-Injection (DI) token.
+ */
+interface ILogger {
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+}
+
+/**
+ * @ignore
+ */
+declare class Logger implements ILogger {
+    private config;
+    constructor(config: ConfigService);
+    private styles;
+    private apply;
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    private shouldLog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Logger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Logger>;
+}
+
+/**
+ * Shows a message after completing each action.
+ */
+declare class NotificationService {
+    #private;
+    /**
+     * Set to true to suppress any notifications
+     */
+    silent: boolean;
+    /**
+     * Default Notofication Options
+     *
+     */
+    private options;
+    constructor();
+    /**
+     * Show info colored massage (blue)
+     *
+     * @param string title
+     * @param string msg
+     */
+    info(title: string, msg?: string): void;
+    /**
+     * Show success colored massage (green)
+     * @param string title
+     * @param string msg
+     */
+    success(title: string, msg?: string): void;
+    /**
+     * can not be in use
+     *
+     * @param string title
+     * @param string msg
+     */
+    wait(title: string, msg?: string): void;
+    /**
+     * Show error colored massage (red)
+     *
+     * @param string title
+     * @param string msg
+     */
+    error(title: string, msg?: string): void;
+    /**
+     * Show warning colored massage (yellow)
+     *
+     * @param string title
+     * @param string msg
+     */
+    warning(title: string, msg?: string): void;
+    /**
+     * Public wrapper for accessing the Toastr
+     *
+     * @param string title
+     * @param string msg
+     * @param string mode
+     * @param _options
+     */
+    private toast;
+    /**
+     * Accessing the toastr service
+     *
+     * @param string msg
+     * @param string title
+     * @param options
+     * @param string mode
+     */
+    private doToast;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare const TENANT_HEADER = "X-ID-TENANT-NAME";
+declare enum Situation {
+    EDIT = "EDIT",
+    CREATE = "CREATE",
+    SEARCH = "SEARCH"
+}
+declare const SystemType: {
+    OBJECT: string;
+    DOCUMENT: string;
+    FOLDER: string;
+    AUDIT: string;
+    ITEM: string;
+    RELATIONSHIP: string;
+    SOT: string;
+};
+declare const SystemResult: {
+    DELETE: string;
+};
+declare const AdministrationRoles: {
+    ADMIN: string;
+    SYSTEM: string;
+    MANAGE_SETTINGS: string;
+};
+declare const UserRoles: {
+    MULTI_TENANT: string;
+};
+declare const SystemSOT: {
+    DESTRUCTION_RETENTION: string;
+};
+declare const RetentionField: {
+    RETENTION_END: string;
+    RETENTION_START: string;
+    DESTRUCTION_DATE: string;
+};
+declare const RelationshipTypeField: {
+    SOURCE_ID: string;
+    TARGET_ID: string;
+};
+declare const BaseObjectTypeField: {
+    PARENT_ID: string;
+    PARENT_OBJECT_TYPE_ID: string;
+    PARENT_VERSION_NUMBER: string;
+    TENANT: string;
+    ACL: string;
+    TRACE_ID: string;
+    SECONDARY_OBJECT_TYPE_IDS: string;
+    BASE_TYPE_ID: string;
+    TAGS: string;
+    OBJECT_ID: string;
+    RETENTION_END: string;
+    RETENTION_START: string;
+    DESTRUCTION_DATE: string;
+    OBJECT_TYPE_ID: string;
+    VERSION_NUMBER: string;
+    CREATION_DATE: string;
+    CREATED_BY: string;
+    MODIFICATION_DATE: string;
+    MODIFIED_BY: string;
+};
+declare const ClientDefaultsObjectTypeField: {
+    TITLE: string;
+    DESCRIPTION: string;
+};
+declare const ContentStreamField: {
+    LENGTH: string;
+    MIME_TYPE: string;
+    FILENAME: string;
+    ID: string;
+    RANGE: string;
+    REPOSITORY_ID: string;
+    DIGEST: string;
+    ARCHIVE_PATH: string;
+};
+declare const AuditField: {
+    REFERRED_OBJECT_ID: string;
+    CREATION_DATE: string;
+    VERSION: string;
+    DETAIL: string;
+    CREATED_BY: string;
+    ACTION: string;
+    SUBACTION: string;
+};
+declare const ParentField: {
+    asvaktenzeichen: string;
+    asvaktenzeichentext: string;
+    asvsichtrechte: string;
+    asvvorgangsname: string;
+    asvvorgangsnummer: string;
+};
+declare enum ContentStreamAllowed {
+    ALLOWED = "allowed",
+    NOT_ALLOWED = "notallowed",
+    REQUIRED = "required"
+}
+declare enum Classification {
+    STRING_CATALOG_I18N = "i18n:catalog",
+    STRING_CATALOG_CUSTOM = "custom:catalog",
+    STRING_CATALOG_DYNAMIC = "dynamic:catalog",
+    STRING_CATALOG = "catalog",
+    STRING_ORGANIZATION = "id:organization",
+    STRING_ORGANIZATION_SET = "id:organization:set",
+    STRING_REFERENCE = "id:reference",
+    STRING_EMAIL = "email",
+    STRING_URL = "url",
+    STRING_PHONE = "phone",
+    NUMBER_FILESIZE = "filesize",
+    NUMBER_DIGIT = "digit",
+    BOOLEAN_SWITCH = "switch",
+    SYSTEM_SOT = "systemsot",
+    PREDICTION_CLASSIFY = "prediction:classify",
+    TABLE_SORTABLE = "sortable"
+}
+declare enum ObjectTypeClassification {
+    SEARCH_FALSE = "appClient:search:false",
+    CREATE_FALSE = "appClient:create:false",
+    OBJECT_TYPE_ICON = "appClient:icon"
+}
+declare enum ObjectTypePropertyClassification {
+    SUMMARY_HIDDEN = "appClient:summary:hidden"
+}
+declare enum SecondaryObjectTypeClassification {
+    REQUIRED = "appClient:required",
+    PRIMARY = "appClient:primary",
+    EXTENSION_ADD_FALSE = "appClient:extension:add:false",
+    EXTENSION_REMOVE_FALSE = "appClient:extension:remove:false"
+}
+declare enum InternalFieldType {
+    STRING_ORGANIZATION_SET = "string:organization:set",
+    STRING_ORGANIZATION = "string:organization",
+    STRING_REFERENCE = "string:reference",
+    STRING_CATALOG = "string:catalog",
+    STRING_CATALOG_I18N = "string:catalog:i18n",
+    STRING_DYNAMIC_CATALOG = "string:catalog:dynamic",
+    BOOLEAN_SWITCH = "boolean:switch"
+}
+declare enum ObjectTag {
+    AFO = "appclient:dlm:prepare"
+}
+declare const AFO_STATE: {
+    IN_PROGRESS: number;
+    READY: number;
+};
+declare const ColumnConfigSkipFields: string[];
+
+/**
+ * Virtual object types.
+ * They are a combination of an object type ID and/or a list of SOTs
+ */
+interface VirtualObjectType {
+    id: string;
+    icon?: string;
+    objectType?: string;
+    sots?: string[];
+}
+/**
+ * Interface providing system definition
+ */
+interface SystemDefinition {
+    version: number;
+    lastModificationDate: unknown;
+    objectTypes: ObjectType[];
+    secondaryObjectTypes: SecondaryObjectType[];
+    relationships: Relationship[];
+    i18n: Localization;
+    allFields: Record<string, SchemaResponseFieldDefinition>;
+}
+interface GenericObjectType extends ObjectType {
+    isSot?: boolean;
+}
+interface _ObjectTypeBase {
+    id: string;
+    label?: string;
+    classification?: string[];
+    description?: string;
+    baseId?: string;
+    contentStreamAllowed?: string;
+    fields: ObjectTypeField[];
+}
+/**
+ * Object Type interface
+ */
+interface ObjectType extends _ObjectTypeBase {
+    isFolder: boolean;
+    creatable: boolean;
+    secondaryObjectTypes: {
+        id: string;
+        static?: boolean;
+    }[];
+}
+interface Relationship {
+    id: string;
+    label?: string;
+    allowedSourceTypes: string[];
+    allowedTargetTypes: string[];
+    fields: ObjectTypeField[];
+}
+/**
+ * Interface providing secondary object type
+ */
+type SecondaryObjectType = _ObjectTypeBase;
+interface _ObjectTypeFieldBase {
+    id: string;
+    name: string;
+    description?: string;
+    propertyType: ObjectTypeFieldType;
+    cardinality: 'single' | 'multi';
+    required: boolean;
+    updatability?: 'readonly' | 'readwrite' | 'oncreate' | 'byhooks';
+    queryable?: boolean;
+    classifications?: string[];
+    resolution?: string;
+    columnDefinitions?: SchemaResponseFieldDefinition[];
+}
+/**
+ * Interface for a secondary object type field
+ */
+interface ObjectTypeField extends _ObjectTypeFieldBase {
+    /**
+     * Internal type that is generated by the system service
+     * when schema is fetched. Most of the time this will match
+     * the propertyType
+     */
+    _internalType: ObjectTypeFieldInternalType;
+    label?: string;
+}
+interface VisibleObjectTag {
+    tagName: string;
+    tagValues?: unknown[];
+}
+/**
+ * Base definition of the kind of data we'll receive
+ * from the backend asking for native schema
+ */
+interface SchemaResponse {
+    version: number;
+    lastModificationDate: string;
+    propertyDefinition: SchemaResponseFieldDefinition[];
+    typeDocumentDefinition: SchemaResponseDocumentTypeDefinition[];
+    typeFolderDefinition: SchemaResponseFolderTypeDefinition[];
+    typeSecondaryDefinition: SchemaResponseDocumentTypeDefinition[];
+    typeRelationshipDefinition: SchemaResponseRelationDefinition[];
+}
+/**
+ * Interface for create the schema from the servers schema type definition response
+ */
+interface SchemaResponseTypeDefinition {
+    id: string;
+    description?: string;
+    baseId: string;
+    propertyReference: {
+        value: string;
+    }[];
+    secondaryObjectTypeId: {
+        value: string;
+        static?: boolean;
+    }[];
+    classification: string[];
+}
+interface SchemaResponseRelationDefinition extends SchemaResponseTypeDefinition {
+    allowedSourceType: {
+        objectTypeReference: string;
+    }[];
+    allowedTargetType: {
+        objectTypeReference: string;
+    }[];
+}
+type SchemaResponseFolderTypeDefinition = SchemaResponseTypeDefinition;
+interface SchemaResponseDocumentTypeDefinition extends SchemaResponseTypeDefinition {
+    contentStreamAllowed?: string;
+}
+/**
+ * Interface for create the schema from the servers schema field definition response
+ */
+interface SchemaResponseFieldDefinition extends _ObjectTypeFieldBase {
+    columnDefinitions?: SchemaResponseFieldDefinition[];
+}
+/**
+ * Object type fields classification property (schema)
+ */
+interface ClassificationEntry {
+    classification: string;
+    options: string[];
+}
+/**
+ * Secondary object types that could be applied to a particular dms object
+ */
+interface ApplicableSecondaries {
+    primarySOTs: SecondaryObjectType[];
+    extendingSOTs: SecondaryObjectType[];
+}
+interface Localization {
+    [key: string]: string;
+}
+interface UserPermissions {
+    create: UserPermissionsSection;
+    read: UserPermissionsSection;
+    write: UserPermissionsSection;
+    delete: UserPermissionsSection;
+}
+interface UserPermissionsSection {
+    folderTypes: string[];
+    objectTypes: string[];
+    secondaryObjectTypes: string[];
+}
+interface ObjectTypePermissions {
+    createableObjectTypes: string[];
+    searchableObjectTypes: string[];
+}
+
+type ObjectTypeFieldType = 'string' | 'integer' | 'decimal' | 'boolean' | 'table' | 'datetime';
+type ObjectTypeFieldInternalType = ObjectTypeFieldType | InternalFieldType.STRING_REFERENCE | InternalFieldType.STRING_ORGANIZATION | InternalFieldType.STRING_ORGANIZATION_SET | InternalFieldType.STRING_CATALOG | InternalFieldType.STRING_CATALOG_I18N | InternalFieldType.BOOLEAN_SWITCH | InternalFieldType.STRING_DYNAMIC_CATALOG;
+interface FormElementString extends ObjectTypeField {
+    propertyType: 'string';
+    defaultvalue?: string[] | string;
+    maxLength?: number;
+    minLength?: number;
+    rows?: number;
+    options?: string[] | string;
+    regex?: string;
+}
+interface FormElementInteger extends ObjectTypeField {
+    propertyType: 'integer';
+    defaultvalue?: number[] | number;
+    maxValue?: number;
+    minValue?: number;
+    precision?: number;
+    grouping?: boolean;
+    pattern?: string;
+}
+interface FormElementDecimal extends ObjectTypeField {
+    propertyType: 'decimal';
+    defaultvalue?: number[] | number;
+    maxValue?: number;
+    minValue?: number;
+    precision?: number;
+    scale?: number;
+    grouping?: boolean;
+    pattern?: string;
+}
+interface FormElementBoolean extends ObjectTypeField {
+    propertyType: 'boolean';
+    defaultvalue?: boolean;
+    tristate?: boolean;
+}
+interface FormElementDatetime extends ObjectTypeField {
+    propertyType: 'datetime';
+    defaultvalue?: string[] | string;
+    resolution?: 'date';
+}
+interface FormElementTable extends ObjectTypeField {
+    elements: ObjectTypeField[];
+    propertyType: 'table';
+}
+
+/**
+ * Config defining the most important/interessting fields for
+ * a certain object type. They'll be used to render result lists
+ * as well as headers for onbjects of that type.
+ */
+interface ObjectConfig {
+    objectTypeId: string;
+    icon?: ObjectConfigIcon;
+    title?: ObjectConfigProperty;
+    description?: ObjectConfigProperty;
+    meta?: ObjectConfigProperty;
+    aside?: ObjectConfigProperty;
+    actions?: ObjectConfigAction[];
+    badges?: ObjectConfigBadge[];
+}
+interface ObjectConfigIcon {
+    svg: string;
+}
+interface ObjectConfigAction {
+    id: string;
+}
+interface ObjectConfigBadge {
+    label: string;
+}
+interface ObjectConfigProperty {
+    label: string;
+    propertyName: string;
+}
+interface StoredObjectConfig {
+    main: ObjectConfigRecord;
+    buckets: ObjectConfigBucket[];
+}
+type ObjectConfigRecord = Record<string, ObjectConfig>;
+interface ObjectConfigBucket {
+    id: string;
+    configs: ObjectConfigRecord;
+}
+interface ResolvedObjectConfig {
+    id: string;
+    objectTypeId: string;
+    icon?: ResolvedObjectConfigItem;
+    title: ResolvedObjectConfigItem;
+    description?: ResolvedObjectConfigItem;
+    meta?: ResolvedObjectConfigItem;
+    aside?: ResolvedObjectConfigItem;
+    actions?: ObjectConfigAction[];
+    badges?: ObjectConfigBadge[];
+    instanceData?: Record<string, unknown>;
+}
+interface ResolvedObjectConfigItem {
+    propertyName: string;
+    rendererType?: RendererType;
+    value?: any;
+    meta?: Record<string, any>;
+}
+type RendererType = Partial<ObjectTypeFieldInternalType | string>;
+interface ConfigTypeOption {
+    bucket?: string;
+    type: VirtualObjectType;
+}
+
+/**
+ * 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.
+ */
+declare class ObjectConfigService {
+    #private;
+    OBJECT_CONFIG_STORAGE_KEY: string;
+    init(): Observable<any>;
+    getObjectConfigs$(bucket?: string, includeDefaults?: boolean): Observable<ObjectConfigRecord>;
+    /**
+     * 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: ObjectConfigRecord, bucket?: string): void;
+    unregisterDefaults(configs: ObjectConfigRecord, bucket?: string): void;
+    getRegisteredDefault(objectTypeId: string, bucket?: string): ObjectConfig | undefined;
+    /**
+     * 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: VirtualObjectType, bucket?: string): ObjectConfig;
+    saveObjectConfig(type: VirtualObjectType, config?: ObjectConfig, bucket?: string): Observable<any>;
+    saveObjectConfigs(configs: Record<string, ObjectConfig | undefined>, bucket?: string): Observable<any>;
+    getDefaultConfig(objectTypeID: string): ObjectConfig;
+    getResolvedObjectConfig(data: Record<string, any>, type: VirtualObjectType, bucket?: string, includeDefaults?: boolean): ResolvedObjectConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectConfigService>;
+}
+
+type ObjectFormModel = ObjectFormGroup | ObjectFormControlWrapper;
+declare class ObjectFormControlWrapper extends FormGroup {
+    _eoFormControlWrapper?: YuvFormGroupWrapper;
+}
+interface YuvFormGroupWrapper {
+    /**
+     * form control situation (CREATE, EDIT, SEARCH)
+     */
+    situation: string;
+    /**
+     * the name of the wrapped form control
+     */
+    controlName: string;
+}
+interface YuvFormGroup {
+    /**
+     * the label for the form group
+     */
+    label?: string;
+    /**
+     * object holding properties defining layout properties of the group
+     */
+    layout: any;
+    /**
+     * type of group indicating if the form is a stack, a fieldset or a simple group
+     */
+    type: string;
+}
+/**
+ * @ignore
+ * Extension of the default angular form group,
+ */
+declare class ObjectFormGroup extends FormGroup {
+    _eoFormGroup?: YuvFormGroup;
+}
+/**
+ * @ignore
+ * Extension of the default angular form control,
+ */
+declare class ObjectFormControl extends FormControl {
+    private __eoFormElement;
+    set _eoFormElement(v: any);
+    get _eoFormElement(): any;
+}
+
+/**
+ * Interface to be implemented by all components (state components) that are aware of pending changes
+ */
+interface PendingChangesComponent {
+    hasPendingChanges: () => boolean;
+}
+
+/**
+ * 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.
+ */
+declare class PendingChangesService {
+    #private;
+    tasks$: Observable<{
+        id: string;
+        message?: string;
+    }[]>;
+    /**
+     * Registers a task to be pending.
+     * @param message alert message
+     * @returns Unique id to be used for finishing this task
+     */
+    startTask(message: string): string;
+    /**
+     * Finishes a task
+     * @param id The id of the task to be finished. This is the one the component got from startTask()
+     */
+    finishTask(id: string): void;
+    /**
+     * 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?: string | string[]): boolean;
+    /**
+     * Returns whether or not the component|service has pending tasks.
+     * Checks via confirm dialog
+     * @param component
+     * @returns false if there are no pending changes or user confirmed
+     * to continue, true if there are pending changes and user canceled the action
+     */
+    check(component?: PendingChangesComponent): boolean;
+    checkForPendingTasks(taskIds: string | string[]): boolean;
+    /**
+     * Clear list of pending tasks
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PendingChangesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PendingChangesService>;
+}
+
+/**
+ * Providing a `PendingChangesComponent`.
+ */
+declare class PendingChangesGuard implements CanDeactivate<PendingChangesComponent> {
+    private pendingChanges;
+    constructor(pendingChanges: PendingChangesService);
+    canDeactivate(component: PendingChangesComponent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PendingChangesGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PendingChangesGuard>;
+}
+
+/**
+ * Service that provides guards for Material Dialog close operations.
+ *
+ * This service allows you to intercept and control dialog close events,
+ * enabling confirmation dialogs or preventing accidental closure when
+ * there are unsaved changes or pending operations.
+ *
+ * @example
+ * ```typescript
+ * readonly #dialogCloseGuard = inject(DialogCloseGuard);
+ *
+ * openDialog() {
+ *   const dialogRef = this.dialog.open(MyComponent);
+ *
+ *   // Prevent dialog from closing if there are unsaved changes
+ *   this.#dialogCloseGuard.dialogCanClose(dialogRef, () => {
+ *     return this.hasUnsavedChanges() ? this.confirmClose() : true;
+ *   }).subscribe();
+ * }
+ * ```
+ */
+declare class DialogCloseGuard {
+    #private;
+    /**
+     * Guards against dialog closure when the backdrop is clicked.
+     *
+     * This method disables the default close behavior and only allows the dialog
+     * to close when the provided check function returns true. The check is triggered
+     * specifically when the user clicks on the dialog backdrop.
+     *
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<boolean> - Emits true when the dialog can be closed via backdrop click
+     *
+     * @example
+     * ```typescript
+     * this.dialogCloseGuard.checkBackdropCanClose(dialogRef, () => {
+     *   return this.formIsDirty ? this.showConfirmDialog() : true;
+     * }).subscribe(canClose => {
+     *   if (canClose) {
+     *     dialogRef.close();
+     *   }
+     * });
+     * ```
+     */
+    checkBackdropCanClose(dialogRef: MatDialogRef<any>, checkFunction: () => boolean | Observable<boolean>): Observable<boolean>;
+    /**
+     * Guards against dialog closure when the Escape key is pressed.
+     *
+     * This method disables the default close behavior and only allows the dialog
+     * to close when the provided check function returns true. The check is triggered
+     * specifically when the user presses the Escape key.
+     *
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<boolean> - Emits true when the dialog can be closed via Escape key
+     *
+     * @example
+     * ```typescript
+     * this.dialogCloseGuard.checkKeydownEventsCanClose(dialogRef, () => {
+     *   return this.hasUnsavedChanges ? this.confirmDiscardChanges() : true;
+     * }).subscribe(canClose => {
+     *   if (canClose) {
+     *     dialogRef.close();
+     *   }
+     * });
+     * ```
+     */
+    checkKeydownEventsCanClose(dialogRef: MatDialogRef<any>, checkFunction: () => boolean | Observable<boolean>): Observable<boolean>;
+    /**
+     * Comprehensive dialog close guard that handles both backdrop clicks and Escape key presses.
+     *
+     * This method provides a unified approach to guard dialog closure by monitoring both
+     * backdrop clicks and Escape key events. When either event occurs, it runs the provided
+     * check function and automatically closes the dialog if the check passes.
+     *
+     * This is the most convenient method when you want to guard against all common
+     * dialog close scenarios with a single setup.
+     *
+     * @template T - The type of data that the dialog returns
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @param checkFunction - Function that determines if the dialog can be closed.
+     *                        Can return a boolean directly or an Observable<boolean>
+     * @returns Observable<false | void> - Emits false if the dialog cannot be closed,
+     *                                    or void when the dialog is successfully closed
+     *
+     * @example
+     * ```typescript
+     * // Simple boolean check
+     * this.dialogCloseGuard.dialogCanClose(dialogRef, () => !this.hasUnsavedChanges).subscribe();
+     *
+     * // Async check with confirmation dialog
+     * this.dialogCloseGuard.dialogCanClose(dialogRef, () => {
+     *   return this.hasUnsavedChanges
+     *     ? this.confirmationService.confirm('Discard changes?')
+     *     : of(true);
+     * }).subscribe();
+     * ```
+     */
+    preventCloseUntil<T>(dialogRef: MatDialogRef<T>, checkFunction: () => boolean | Observable<boolean>): Observable<false | void>;
+    /**
+     * Specialized dialog close guard that automatically checks for pending changes.
+     *
+     * This convenience method provides automatic pending changes detection without
+     * requiring a custom check function. It integrates with the PendingChangesService
+     * to determine if there are any unsaved changes, and handles both backdrop clicks
+     * and Escape key presses automatically.
+     *
+     * This method is ideal when you want to prevent dialog closure if there are
+     * pending changes anywhere in the application, without having to implement
+     * custom change detection logic.
+     *
+     * @template T - The type of data that the dialog returns
+     * @param dialogRef - Reference to the Material Dialog instance
+     * @returns Observable<false | void> - Emits false if there are pending changes
+     *                                    preventing closure, or void when the dialog
+     *                                    is successfully closed
+     *
+     */
+    pendingChangesDialogCanClose<T>(dialogRef: MatDialogRef<T>): Observable<false | void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogCloseGuard>;
+}
+
+declare class TabGuardDirective implements DoCheck {
+    #private;
+    constructor();
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabGuardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabGuardDirective, "mat-tab-group[yuvTabGuardDisable]", never, {}, {}, never, never, true, never>;
+}
+
+interface PredictionClassifyResult {
+    objectId: string;
+    properties: PredictionClassifyResultItem[];
+}
+interface PredictionClassifyResultItem {
+    type: string;
+    probability: number;
+}
+interface PredictionExtractResult {
+    objectId: string;
+    properties: Record<string, PredictionExtractResultItem[]>;
+}
+interface PredictionExtractResultItem {
+    value: string;
+    probability: number;
+    boundingBox?: number[];
+    page?: number;
+}
+
+declare class PredictionService {
+    #private;
+    classify(objectIDs: string[], schemaObjectTypeId?: string): Observable<Record<string, PredictionClassifyResult>>;
+    /**
+     * @param schemaObjectTypeId
+     * @param objectIDs
+     * @returns  Observable<Record<string, PredictionClassifyResult>> string is objectID
+     */
+    extract(schemaObjectTypeId: string, objectIDs: string[]): Observable<Record<string, PredictionExtractResult>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PredictionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PredictionService>;
+}
+
+interface RetentionState {
+    underRetention: boolean;
+    start?: Date;
+    end?: Date;
+}
+
+/**
+ * Service to manage retention for DMS objects. This service allows to set retention
+ * for objects and revert retention if necessary/possible.
+ */
+declare class RetentionService {
+    #private;
+    /**
+     * Set retention for given objects. This will add the retention SOT to the objects
+     * and set the retention start and end date. If the retetion start date is in the
+     * future, you can revert the retention until then by calling `revertRetention`.
+     * @param dmsObjects The objects to set retention for
+     * @param retentionStart Date when retention period should begin
+     * @param retentionEnd Date when retention period should end
+     * @param destructionDate Date when the object should be destroyed. This right now is just a
+     * marker and has no effect on the object lifecycle.
+     * @returns The updated objects
+     */
+    setRetention(dmsObjects: DmsObject[], retentionStart: Date, retentionEnd: Date, destructionDate?: Date): Observable<DmsObject[]>;
+    getRetentionState(dmsObject: DmsObject): RetentionState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RetentionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RetentionService>;
+}
+
+declare class SearchService {
+    #private;
+    static DEFAULT_QUERY_SIZE: number;
+    /**
+     * Execute a search query ans transform the result to a SearchResult object
+     * @param query The search query
+     * @returns Observable of a SearchResult
+     */
+    search(query: SearchQuery): Observable<SearchResult>;
+    /**
+     * 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: SearchQuery): Observable<any>;
+    /**
+     * 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: string, size?: number, includePermissions?: boolean): Observable<SearchResult>;
+    /**
+     * 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: SearchQuery, aggregations: string[]): Observable<AggregateResult>;
+    /**
+     * Go to a page of a search result.
+     * @param query SearchQuery or CMIS query statement
+     * @param page The number of the page to go to
+     */
+    getPage(query: SearchQuery | string, page: number, pageSize?: number, includePermissions?: boolean): Observable<SearchResult>;
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse: SearchResponse, pageSize?: number, skipCount?: number): SearchResult;
+    /**
+     * Maps data extracted from a search form to search filters. Every key of the form data object
+     * will be mapped to a search filter.
+     * @param formData form data
+     * @returns Array of search filters
+     */
+    formDataToSearchFilter(formData: Record<string, unknown>): SearchFilter[];
+    rangeValueToSearchFilter(value: RangeValue, property: string): SearchFilter | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}
+
+declare class SearchUtils {
+    static dateRanges: string[];
+    static filesizeRanges: string[];
+    static dateRangeStartEnd(dateRange: DateRange): {
+        start: Date;
+        end: Date;
+    };
+    /**
+     * Maps a date range filter to a date range value like 'thisWeek', 'lastMonth', etc.
+     * @param rangeValue the range value
+     * @returns the date range (eg. 'thisWeek', 'lastMonth', etc.)
+     */
+    static getMatchingDateRange(rangeValue: RangeValue): DateRange | undefined;
+    static getMatchingFilesizeRange(rangeValue: RangeValue): FilesizeRange | undefined;
+    static filesizeRangeToRangeValue(filesizeRange: FilesizeRange): RangeValue | undefined;
+}
+
+declare class SessionStorageService {
+    #private;
+    constructor();
+    /**
+     * 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: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
+}
+
+/**
+ * Providing system definitions.
+ */
+declare class SystemService {
+    #private;
+    system?: SystemDefinition;
+    system$: Observable<SystemDefinition>;
+    authData?: AuthData;
+    /**
+     * Get all object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): GenericObjectType[];
+    /**
+     * Get all secondary object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getSecondaryObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): SecondaryObjectType[];
+    /**
+     * 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: string, withLabel?: boolean): GenericObjectType | undefined;
+    /**
+     * 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: string, withLabel?: boolean): SecondaryObjectType | undefined;
+    getRelationship(id: string, withLabel?: boolean): Relationship | undefined;
+    /**
+     * Get supported relationships for a given dms object
+     * @param dmsObject DmsObject to get supported relationships for
+     */
+    getSupportedRelationships(dmsObject: DmsObject, withLabel?: boolean): Relationship[];
+    /**
+     * Get the base document type all documents belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseDocumentType(withLabel?: boolean): ObjectType;
+    /**
+     * Get the base folder type all folders belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseFolderType(withLabel?: boolean): ObjectType;
+    /**
+     * Get the base object type all dms objects belong to
+     */
+    getBaseType(): ObjectType;
+    /**
+     * Get the resolved object type with all fields ( including fields from related secondary types )
+     */
+    getResolvedType(objectTypeId?: string): {
+        id: string;
+        fields: ObjectTypeField[];
+    };
+    /**
+     * Get the resolved object tags
+     */
+    getResolvedTags(objectTypeId: string): {
+        id: string;
+        tagName: string;
+        tagValues: any;
+        fields: ObjectTypeField[];
+    }[];
+    /**
+     * 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: string): string[];
+    /**
+     * 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: string): {
+        [tagName: string]: any[];
+    };
+    private fetchVisibleTags;
+    filterVisibleTags(objectTypeId: string, tagsValue: Array<Array<any>>): Array<Array<any>>;
+    /**
+     * 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: string, fallback?: string): Observable<string>;
+    /**
+     * 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: string, fallback?: string): string;
+    private getFallbackIcon;
+    getLocalizedResource(key: string): string;
+    getLocalizedLabel(id: string): string;
+    getLocalizedDescription(id: string): string;
+    /**
+     * Determine whether or not the given object type field is a system field
+     * @param field Object type field to be checked
+     */
+    isSystemProperty(field: ObjectTypeField): boolean;
+    /**
+     * 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?: AuthData): Observable<boolean>;
+    setPermissions(p: ObjectTypePermissions): void;
+    /**
+     * Create the schema from the servers schema response
+     * @param schemaResponse Response from the backend
+     */
+    setSchema(schemaResponse: SchemaResponse, localizedResource?: Localization): void;
+    /**
+     * 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: string[], situation: string): Observable<Record<string, any>>;
+    /**
+     * 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: string, situation: string): Observable<any>;
+    /**
+     * 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: string, classifications?: string[]): ObjectTypeFieldInternalType;
+    getObjectTypeField(id: string): ObjectTypeField | 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: string[]): Map<string, ClassificationEntry>;
+    toFormElement(field: ObjectTypeField): any;
+    updateAuthData(data: Partial<AuthData>): Observable<boolean>;
+    updateLocalizations(iso: string): Observable<any>;
+    fetchResources(id: string): Observable<{
+        global: any;
+        tenant: any;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemService>;
+}
+
+interface ToastOptions {
+    duration?: number;
+    position?: ToastPosition;
+    level?: ToastLevel;
+    title?: string;
+}
+type ToastPosition = 'top-start' | 'top-end' | 'top-center' | 'bottom-start' | 'bottom-end' | 'bottom-center';
+type ToastLevel = 'success' | 'warning' | 'error' | 'info';
+
+declare class ToastService {
+    private document;
+    constructor(document: Document);
+    success(message: string, title?: string, options?: ToastOptions): Promise<void>;
+    warning(message: string, title?: string, options?: ToastOptions): Promise<void>;
+    info(message: string, title?: string, options?: ToastOptions): Promise<void>;
+    error(message: string, title?: string, options?: ToastOptions): Promise<void>;
+    toast(message: string, title?: string, options?: ToastOptions): Promise<void>;
+    private _createToast;
+    private _addToast;
+    private _getToastContainer;
+    private _init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+/**
+ * Interface for providing an uploading status of an object
+ */
+interface ProgressStatus {
+    items: ProgressStatusItem[];
+    err: number;
+}
+/**
+ * Is part of the `ProgressStatus` interface
+ */
+interface ProgressStatusItem {
+    id: string;
+    filename: string;
+    progress: Observable<number>;
+    subscription: Subscription;
+    result?: UploadResult[];
+    scope?: string;
+    err?: {
+        code: number;
+        message: string;
+    };
+}
+/**
+ * is a part of `CreatedObject` interface
+ */
+interface ContentStream {
+    contentStreamId: string;
+    repositoryId: string;
+    digest: string;
+    fileName: string;
+    archivePath: string;
+    length: number;
+    mimeType: string;
+}
+/**
+ * Interface providng properties of uploaded object type
+ */
+interface UploadResult {
+    objectId: string | string[];
+    contentStreamId: string;
+    filename: string;
+    label?: string;
+}
+/**
+ * Interface that was used by upload service
+ */
+interface CreatedObject {
+    body?: {
+        objects: {
+            properties: any;
+            contentStreams?: ContentStream[];
+        }[];
+    };
+}
+
+/**
+ * Service for providing upload of different object types into a client.
+ */
+declare class UploadService {
+    #private;
+    status$: Observable<ProgressStatus>;
+    uploadStatus$: Observable<boolean | null>;
+    /**
+     * 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
+     *
+     * @deprecated use uploadFile instead. `label`, `silent` as well as `scope` can be provided through `options`.
+     */
+    upload(url: string, file: File, label?: string, silent?: boolean): Observable<any>;
+    /**
+     * Uploads a single file to the specified URL using the structured `FileUploadOptions` object.
+     *
+     * This is the preferred alternative to the legacy `upload()` method. It accepts a typed
+     * options object instead of individual parameters, which makes it easier to pass optional
+     * settings such as `silent` mode and `scope` without relying on positional arguments.
+     *
+     * **Behavior:**
+     * - If `options.silent` is `false` (default), the upload appears in the upload overlay dialog
+     *   and progress is tracked via `status$`
+     * - If `options.silent` is `true`, the upload runs quietly in the background with no UI feedback
+     * - `options.label` is shown in the overlay dialog during upload; falls back to `file.name` if omitted
+     * - `options.scope` tags the upload with a named scope, enabling an `UploadProgressComponent`
+     *   configured with the same scope to display only the uploads relevant to its section of the UI
+     *
+     * @param url - The backend URL to POST the file to
+     * @param file - The `File` object to be uploaded
+     * @param options - Upload configuration: label, silent mode, and optional scope
+     * @returns An `Observable` that emits the server response on completion
+     *
+     * @example
+     * ```typescript
+     * // Standard upload with progress indicator
+     * this.uploadService.uploadFile(url, file, { label: 'Uploading contract.pdf' }).subscribe();
+     *
+     * // Silent upload (no UI, runs in background)
+     * this.uploadService.uploadFile(url, file, { label: 'document.pdf', silent: true }).subscribe();
+     *
+     * // Scoped upload — only the UploadProgressComponent with scope 'profile-editor' will show this
+     * this.uploadService.uploadFile(url, file, { label: 'photo.jpg', scope: 'profile-editor' }).subscribe();
+     * ```
+     */
+    uploadFile(url: string, file: File, options: FileUploadOptions): Observable<unknown>;
+    /**
+     * 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
+     *
+     * @deprecated Use multipartUpload(url, files, options, data) instead. Provide scope through options.
+     */
+    uploadMultipart(url: string, files: File[], data?: any, label?: string, silent?: boolean): Observable<any>;
+    /**
+     * Uploads multiple files to the specified URL using a multipart/form-data request.
+     *
+     * This is the preferred method for multi-file uploads. It accepts a typed `FileUploadOptions`
+     * object for configuration, making it easier to pass `scope` and other options compared
+     * to the legacy `uploadMultipart()` overload.
+     *
+     * **Behavior:**
+     * - All files are bundled into a single `FormData` payload under the `files` field
+     * - Optional `data` is appended as a JSON blob under the `data` field
+     * - If `options.silent` is `false` (default), upload progress is shown in the overlay dialog
+     * - If `options.silent` is `true`, the upload runs in the background with no UI feedback
+     * - `options.scope` tags the upload with a named scope, enabling an `UploadProgressComponent`
+     *   configured with the same scope to display only the uploads relevant to its section of the UI
+     *
+     * @param url - The backend URL to POST the multipart request to
+     * @param files - Array of `File` objects to upload
+     * @param options - Upload configuration: label (required), silent mode, and optional scope
+     * @param data - Optional metadata object to send alongside the files (serialized as JSON)
+     * @returns An `Observable` that emits the server response on completion
+     *
+     * @example
+     * ```typescript
+     * // Upload files with a visible progress indicator
+     * this.uploadService.multipartUpload(url, files, { label: 'Uploading 3 files' }).subscribe();
+     *
+     * // Upload files with additional metadata
+     * this.uploadService
+     *   .multipartUpload(url, files, { label: 'Batch upload' }, { folderId: 'abc123' })
+     *   .subscribe();
+     *
+     * // Scoped upload — only the UploadProgressComponent with scope 'mail-editor' will show this
+     * this.uploadService
+     *   .multipartUpload(url, files, { label: 'attachments', scope: 'mail-editor' })
+     *   .subscribe();
+     * ```
+     */
+    multipartUpload(url: string, files: File[], options: FileUploadOptions, data?: unknown): Observable<unknown>;
+    /**
+     * Creates a document on the server by sending structured metadata without a file attachment.
+     *
+     * Unlike `uploadFile()` and `multipartUpload()`, this method does not attach any file content.
+     * It is intended for creating document objects from metadata alone — for example, creating
+     * a folder, a placeholder record, or a document entry where the content stream will be
+     * provided separately.
+     *
+     * **Behavior:**
+     * - Sends the `data` object as a JSON blob inside a `FormData` payload
+     * - Progress is NOT tracked — this method does not appear in `status$`
+     * - Errors are re-thrown so the caller can handle them via the returned `Observable`
+     *
+     * @param url - The backend URL to POST the document creation request to
+     * @param data - Metadata object describing the document to be created
+     * @returns An `Observable` that emits the created object(s) on success
+     *
+     * @example
+     * ```typescript
+     * const metadata = {
+     *   objectTypeId: 'yuv:document',
+     *   properties: { 'yuv:title': 'My Document' }
+     * };
+     *
+     * this.uploadService.createDocument(url, metadata).subscribe((result) => {
+     *   console.log('Created:', result);
+     * });
+     * ```
+     */
+    createDocument(url: string, data: any): Observable<any>;
+    /**
+     * Cancels one or all active upload requests and removes them from the tracked upload list.
+     *
+     * This method unsubscribes from the underlying HTTP request, effectively aborting the upload,
+     * and removes the corresponding item(s) from the internal status list. The updated status
+     * is then emitted via `status$` so that any subscribed UI components (e.g. the upload overlay)
+     * can reflect the change immediately.
+     *
+     * **Behavior:**
+     * - If `id` is provided, only the matching upload item is cancelled
+     * - If `id` is omitted, **all** active uploads are cancelled at once
+     * - If the provided `id` does not match any active item, the call is a no-op
+     * - After cancellation, the error count on `status$` is recalculated
+     *
+     * @param id - Optional ID of the upload item to cancel. Omit to cancel all active uploads.
+     *
+     * @example
+     * ```typescript
+     * // Cancel a specific upload by ID
+     * this.uploadService.cancelItem(uploadId);
+     *
+     * // Cancel all ongoing uploads (e.g. on component destroy or user confirmation)
+     * this.uploadService.cancelItem();
+     * ```
+     */
+    cancelItem(id?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
+}
+
+/**
+ * Service providing user related remote storage. This service is used load and
+ * store user related data from any device.
+ */
+declare class UserStorageService {
+    #private;
+    /**
+     *
+     * @param section section key for
+     * @param value  value to be stored
+     */
+    getItem(section: string): Observable<Record<string, any> | undefined>;
+    setItem(section: string, data: Record<string, any>): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserStorageService>;
+}
+
+declare const YUV_USER: InjectionToken<YuvUser | undefined>;
+declare const provideUser: (user: YuvUser) => Provider;
+
+/**
+ * Service providing user account configurations.
+ */
+declare class UserService {
+    #private;
+    private backend;
+    private translate;
+    private logger;
+    private system;
+    private eventService;
+    private config;
+    user$: Observable<YuvUser | undefined>;
+    globalSettings: Map<any, any>;
+    userPermissions?: UserPermissions;
+    /**
+     * @ignore
+     */
+    constructor(backend: BackendService, translate: TranslateService, logger: Logger, system: SystemService, eventService: EventService, config: ConfigService);
+    private getUiDirection;
+    /**
+     * Set a new current user
+     * @param user The user to be set as current user
+     */
+    setCurrentUser(user: YuvUser): void;
+    getCurrentUser(): YuvUser;
+    get hasAdminRole(): boolean;
+    get hasSystemRole(): boolean;
+    get hasAdministrationRoles(): boolean;
+    get hasManageSettingsRole(): boolean;
+    get isAdvancedUser(): boolean;
+    get isRetentionManager(): boolean;
+    canCreateObjects: boolean;
+    /**
+     * Change the users client locale
+     * @param iso ISO locale string to be set as new client locale
+     */
+    changeClientLocale(iso: string, persist?: boolean): void;
+    saveUserSettings(settings: Partial<UserSettings>): Observable<any>;
+    fetchUserSettings(): Observable<UserSettings>;
+    private setUserPermissions;
+    private mapPermissions;
+    /**
+     * 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: string, excludeMe?: boolean, roles?: string[]): Observable<YuvUser[]>;
+    getUserById(id: string): Observable<YuvUser>;
+    logout(redirRoute?: string): void;
+    getSettings(section: string): Observable<any>;
+    saveObjectConfig(objectConfigs: StoredObjectConfig): Observable<any>;
+    loadObjectConfig(): Observable<StoredObjectConfig | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+
+declare enum Sort {
+    ASC = "asc",
+    DESC = "desc"
+}
+declare enum ClassificationPrefix {
+    EMAIL = "mailto:",
+    EMAIL_ICON = "envelope",
+    PHONE = "tel:",
+    PHONE_ICON = "phone",
+    URL = "",
+    URL_ICON = "globe"
+}
+type FormattedMailTo = string | string[];
+
+declare class Utils {
+    static readonly DEFAULT_TIME_OFFSET_V2: number;
+    static optionsToURLParams(options: Record<string, any>): string;
+    /**
+     * Get all focusable child elements of a host element.
+     * @param host The host/parent element
+     * @returns Array of focusable child elements
+     */
+    static getFocusableChildren(host: HTMLElement): Element[];
+    static hasProperty(o: unknown, property: string): boolean;
+    static patternToRegExp(pattern: string): RegExp;
+    /**
+     * 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: string, params: any): string;
+    static formatMailTo(value: FormattedMailTo, isEmail: boolean): FormattedMailTo;
+    /**
+     * Creates a unique identifier.
+     * @returns A Universally Unique Identifier
+     */
+    static uuid(): string;
+    /**
+     * 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: string): string;
+    /**
+     *
+     * @param boolean s
+     * @return string
+     */
+    private static _p8;
+    /**
+     * 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
+     */
+    private static encodeToUtf8;
+    /**
+     * See [quoted-printable]{@link https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js}
+     **/
+    private static quotedPrintable;
+    /**
+     * 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
+     */
+    private static encodeToQuotedPrintable;
+    /**
+     * 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?: string, order?: Sort, locales?: string | string[], options?: Intl.CollatorOptions): (a: any, b: any) => number;
+    /**
+     * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param object
+     * @param string key
+     * @returns any
+     */
+    static getProperty(object: any, key?: string): any;
+    /**
+     * @param object
+     * @param key
+     * @param value
+     */
+    static setProperty(object: any, key: string | undefined, value: any): any;
+    /**
+     * 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?: (error: any) => any): () => rxjs.Observable<never>;
+    static getBaseHref(removeTrailingSlash?: boolean): string;
+    /**
+     * 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: string, num: number, ending?: string): string;
+    /**
+     * Get the TimeZone Offsest as minutes
+     */
+    static getTimezoneOffset(): number;
+    /**
+     * Transform to date with yyyy-mm-dd format
+     */
+    static transformDate(v: Date | string): string;
+    static isEdge(): boolean;
+    static isFirefox(): boolean;
+    static isSafari(): boolean;
+    static isEmpty(obj: any): boolean;
+    static isEmptyOrFalse(val: any): boolean;
+    static escapeHtml(str: string): string;
+    static arrayToObject<T>(arr?: any[], keyProperty?: string | ((o: any) => string), valueProperty?: string | ((o: any) => any)): {
+        [key: string]: T;
+    };
+    static downloadBlob(content: any, mimeType: string, filename: string): void;
+    static isValidDate(value: any): value is Date;
+    static getDateFrom(value?: Date | string | null): Date | undefined;
+    static getDateRangeFrom(dateRange: RangeValue<Date | string>): RangeValue<Date> | undefined;
+}
+
+/**
+ * @ignore
+ */
+declare class LocaleDecimalPipe extends DecimalPipe implements PipeTransform {
+    translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: any, digits?: string, locale?: string): string | null | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleDecimalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleDecimalPipe, "localeDecimal", true>;
+}
+/**
+ * @ignore
+ */
+declare class LocalePercentPipe extends PercentPipe implements PipeTransform {
+    translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: any, digits?: string, locale?: string): string | null | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalePercentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalePercentPipe, "localePercent", true>;
+}
+/**
+ * @ignore
+ */
+declare class LocaleCurrencyPipe extends CurrencyPipe implements PipeTransform {
+    translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: any, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | boolean, digits?: string, locale?: string): string | null | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleCurrencyPipe, "localeCurrency", true>;
+}
+declare class LocaleNumberPipe implements PipeTransform {
+    translate: TranslateService;
+    decimalPipe: LocaleDecimalPipe;
+    decimalSeparator: string;
+    separator: string;
+    constructor(translate: TranslateService);
+    transform(value: any, grouping?: boolean, pattern?: string, scale?: number, digits?: string, locale?: string): string | null;
+    private updateSeparators;
+    stringToNumber(value: string): number;
+    numberToString(value: number, grouping?: boolean, pattern?: string, scale?: number): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleNumberPipe, "localeNumber", true>;
+}
+
+/**
+ * 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>
+ */
+declare class FileSizePipe extends LocaleNumberPipe implements PipeTransform {
+    private k;
+    private sizes;
+    transform(bytes?: number): string;
+    stringToNumber(value: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", true>;
+}
+
+type Formats = 'short' | 'medium' | 'shortDate';
+declare class LocaleDatePipe implements PipeTransform {
+    translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: string | number | Date | undefined, format?: Formats): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleDatePipe, "localeDate", true>;
+}
+
+/**
+ * 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>
+ */
+declare class SafeHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(style: any): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+/**
+ * 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>
+ */
+declare class SafeUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(url: any): SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", true>;
+}
+
+/**
+ * @ignore
+ */
+declare class KeysPipe implements PipeTransform {
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeysPipe, "keys", true>;
+}
+
+interface NativeNotificationOptions {
+    options: NotificationOptions;
+    preventOnTabActive?: boolean;
+    onClick?: () => void;
+}
+
+declare class NativeNotificationService {
+    requestPermission(): void;
+    showNotification(title: string, options?: NativeNotificationOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NativeNotificationService>;
+}
+
+type AvailabilityState = 'enabled' | 'disabled';
+type Requirements = Record<string, string[]>;
+interface YuvAvailableBackendApps {
+    name: string;
+    state: AvailabilityState;
+}
+
+declare const AVAILABLE_BACKEND_APPS: InjectionToken<YuvAvailableBackendApps[] | undefined>;
+declare const provideAvailabilityManagement: (user: YuvAvailableBackendApps[]) => Provider;
+declare const CLIENT_APP_REQUIREMENTS: InjectionToken<Requirements | null>;
+declare const provideRequirements: (requirements: Requirements) => Provider;
+
+/**
+ * Registers a global `beforeunload` event listener that prevents the browser
+ * from navigating away (tab close / reload) whenever there are pending tasks
+ * tracked by {@link PendingChangesService}.
+ *
+ * Usage in `app.config.ts`:
+ * ```ts
+ * provideBeforeUnloadProtection()
+ * ```
+ */
+declare function provideBeforeUnloadProtection(): EnvironmentProviders;
+
+declare function provideNavigationProtection(): EnvironmentProviders[];
+
+/**
+ * Provides environment-level protection against the browser back/forward buttons
+ * while a Material dialog is open.
+ *
+ * Behavior:
+ * 1. Listens for the browser `popstate` event (triggered by back/forward navigation).
+ * 2. If at least one `MatDialog` is open, the URL is immediately restored via
+ *    `history.pushState` so the Angular router does not pick up the navigation.
+ * 3. If `PendingChangesService` reports a pending task the user is prompted for
+ *    confirmation — the topmost dialog is closed only when the user agrees to discard.
+ * 4. If there are no pending changes the topmost dialog is closed directly.
+ */
+declare function providePopstateDialogProtection(): EnvironmentProviders;
+
+interface YuvClientCoreConfig {
+    translations: string[];
+}
+declare const provideYuvClientCore: (options?: YuvClientCoreConfig, customEvents?: string[], customEventsTrustedOrigin?: string[], disableBeforeUnloadProtection?: boolean, disablePopstateDialogProtection?: boolean) => EnvironmentProviders;
+
+export { AFO_STATE, AVAILABLE_BACKEND_APPS, AdministrationRoles, ApiBase, AppCacheService, AuditField, AuditService, AuthService, BackendService, BaseObjectTypeField, BpmService, CLIENT_APP_REQUIREMENTS, CORE_CONFIG, CUSTOM_CONFIG, CUSTOM_YUV_EVENT_PREFIX, CatalogService, Classification, ClassificationPrefix, ClientCacheService, ClientDefaultsObjectTypeField, ClipboardService, ColumnConfigSkipFields, ConfigService, ConnectionService, ContentStreamAllowed, ContentStreamField, CoreConfig, DeviceScreenOrientation, DeviceService, DialogCloseGuard, Direction, DmsObject, DmsService, EventService, FileSizePipe, IdmService, InternalFieldType, KeysPipe, LocaleCurrencyPipe, LocaleDatePipe, LocaleDecimalPipe, LocaleNumberPipe, LocalePercentPipe, Logger, LoginStateName, NativeNotificationService, NotificationService, ObjectConfigService, ObjectFormControl, ObjectFormControlWrapper, ObjectFormGroup, ObjectTag, ObjectTypeClassification, ObjectTypePropertyClassification, Operator, OperatorLabel, ParentField, PendingChangesGuard, PendingChangesService, PredictionService, ProcessAction, RelationshipTypeField, RetentionField, RetentionService, SafeHtmlPipe, SafeUrlPipe, SearchService, SearchUtils, SecondaryObjectTypeClassification, SessionStorageService, Situation, Sort, SystemResult, SystemSOT, SystemService, SystemType, TENANT_HEADER, TabGuardDirective, ToastService, UploadService, UserRoles, UserService, UserStorageService, Utils, YUV_USER, YuvError, YuvEventType, YuvUser, init_moduleFnc, provideAvailabilityManagement, provideBeforeUnloadProtection, provideNavigationProtection, providePopstateDialogProtection, provideRequirements, provideUser, provideYuvClientCore };
+export type { AggregateResult, Aggregation, AggregationEntry, ApplicableSecondaries, AuditEntry, AuditQueryOptions, AuditQueryResult, AuthData, AvailabilityState, BaseCatalog, CacheEntry, Catalog, CatalogEntry, ClassificationEntry, ClipboardData, ClipboardDataMode, ClipboardStore, ConfigTypeOption, ConnectionState, ContentStream$1 as ContentStream, CoreApiBatchResponse, CoreApiObject, CoreApiObjectProperty, CoreApiResponse, CreatedObject, DateRange, DeviceScreen, DeviceScreenBounds, DmsObjectAuditInfo, DmsObjectPermissions, DmsObjectTag, FetchTaskOptions, FilesizeRange, FlavoredDmsObject, FormElementBoolean, FormElementDatetime, FormElementDecimal, FormElementInteger, FormElementString, FormElementTable, FormattedMailTo, GenericObjectType, HttpDeleteOptions, HttpOptions, ILogger, IdmCachedUser, IdmUserCache, IdmUserResponse, InboxTask, IsAny, Localization, LoginDeviceResult, LoginState, ObjectConfig, ObjectConfigAction, ObjectConfigBadge, ObjectConfigBucket, ObjectConfigIcon, ObjectConfigProperty, ObjectConfigRecord, ObjectCopyOptions, ObjectCreateFlavor, ObjectDeleteError, ObjectDeleteOptions, ObjectDeleteResult, ObjectFormModel, ObjectMoveOptions, ObjectOptions, ObjectType, ObjectTypeField, ObjectTypeFieldInternalType, ObjectTypeFieldType, ObjectTypeFlavor, ObjectTypePermissions, OrganizationSetEntry, PredictionClassifyResult, PredictionClassifyResultItem, PredictionExtractResult, PredictionExtractResultItem, Process, ProcessCreatePayload, ProcessPostPayload, ProcessUser, ProcessVariable, ProgressStatus, ProgressStatusItem, RangeValue, Relationship, RendererType, Requirements, ResolvedObjectConfig, ResolvedObjectConfigItem, RetentionState, SchemaResponse, SchemaResponseDocumentTypeDefinition, SchemaResponseFieldDefinition, SchemaResponseFolderTypeDefinition, SchemaResponseRelationDefinition, SchemaResponseTypeDefinition, ScreenSize, SearchFilter, SearchQuery, SearchResponse, SearchResult, SearchResultContent, SearchResultItem, SearchResultPermissions, SecondaryObjectType, SortOption, StoredObjectConfig, StoredToken, SystemDefinition, TableFilter, ToastLevel, ToastOptions, ToastPosition, Trigger, UploadResult, UserPermissions, UserPermissionsSection, UserSettings, VirtualObjectType, VisibleObjectTag, YuvAvailableBackendApps, YuvClientCoreConfig, YuvConfig, YuvConfigLanguages, YuvEvent, YuvEventCreatedData, YuvEventDeletedData, YuvEventUpdatedData, YuvFormGroup, YuvFormGroupWrapper, YuvInitError, YuvMessage, _ObjectTypeBase, _ObjectTypeFieldBase };