@wolkabout/commons 0.0.4 → 0.0.6

package/index.d.ts

@@ -1,12 +1,1519 @@
-import { BehaviorSubject } from 'rxjs';
-import * as i0 from '@angular/core';
+import { RouterLink, RouterOutlet, RouterLinkActive, Routes, CanActivateFn, QueryParamsHandling, Router, ActivatedRoute } from '@angular/router';
+import { MatButtonModule } from '@angular/material/button';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ElementRef, OnDestroy, TemplateRef, ViewContainerRef, Renderer2, AfterViewInit, AfterViewChecked, OnChanges, PipeTransform, OnInit, DestroyRef, Signal, WritableSignal } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { TranslateService, MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';
+import { DateAdapter, ErrorStateMatcher } from '@angular/material/core';
+import * as ngx_echarts from 'ngx-echarts';
+import { ThemeOption } from 'ngx-echarts';
+import { ControlValueAccessor, AbstractControl, ValidationErrors, NgControl, FormControl, FormGroupDirective, NgForm, Validator, FormGroup, ValidatorFn } from '@angular/forms';
+import { Overlay } from '@angular/cdk/overlay';
+import { MatAutocompleteTrigger, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { EChartsOption } from 'echarts';
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import { MatDateRangePicker } from '@angular/material/datepicker';
+import { MatSelectChange } from '@angular/material/select';
+import { DateTime } from 'luxon';
+import { GoogleMap } from '@angular/google-maps';
+import { MarkerClusterer } from '@googlemaps/markerclusterer';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer, SafeUrl, SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
 
-declare class CommonsService {
-    serviceID: `${string}-${string}-${string}-${string}-${string}`;
-    secretMessage: BehaviorSubject<string>;
+declare const angularComponents: (typeof MatButtonModule)[];
+declare const shared: (typeof MatButtonModule | typeof RouterLink | typeof RouterOutlet | typeof RouterLinkActive)[];
+
+interface SvgIcon {
+    id: string;
+}
+interface LoadedIcon {
+    data: Observable<Blob | null>;
+    defaultIcon: SvgIcon | string;
+}
+
+interface Tab {
+    name: string;
+    route: string;
+    icon?: string;
+    condition?: Observable<boolean>;
+    tooltip?: string;
+}
+
+interface User {
+    id: number;
+    firstName: string | null;
+    lastName: string | null;
+    email: string;
+}
+interface Authority {
+    contextId: number;
+    contextName: string;
+    mainContext: boolean;
+    active: boolean;
+    accessToken: string;
+    roleNames: string[];
+    permissions: string[];
+}
+interface Authentication {
+    user: User;
+    authorities: Authority[];
+    refreshToken: string;
+}
+declare function isContextAccessible(authority: Authority, isMainContext: boolean): boolean;
+
+interface ImportError {
+    key: string;
+    value: string[];
+}
+
+declare enum DataType {
+    STRING = "STRING",
+    NUMERIC = "NUMERIC",
+    BOOLEAN = "BOOLEAN",
+    LOCATION = "LOCATION",
+    HEXADECIMAL = "HEXADECIMAL",
+    ENUM = "ENUM",
+    VECTOR = "VECTOR",
+    DATE = "DATE",
+    DURATION = "DURATION",
+    COLOR = "COLOR",
+    LINK = "LINK"
+}
+
+declare enum Permission {
+    ACCESS_MODULE_PLATFORM_MANAGEMENT_FEATURE_APPLICATION = "ACCESS.MODULE_PLATFORM_MANAGEMENT.FEATURE_APPLICATION",
+    ACCESS_MODULE_PLATFORM_MANAGEMENT_FEATURE_PLATFORM_CONFIGURATION = "ACCESS.MODULE_PLATFORM_MANAGEMENT.FEATURE_PLATFORM_CONFIGURATION",
+    ACCESS_MODULE_PLATFORM_MANAGEMENT_FEATURE_TENANT_MANAGEMENT = "ACCESS.MODULE_PLATFORM_MANAGEMENT.FEATURE_TENANT_MANAGEMENT",
+    ACCESS_MODULE_USER_MANAGEMENT_FEATURE_APPLICATION = "ACCESS.MODULE_USER_MANAGEMENT.FEATURE_APPLICATION",
+    ACCESS_MODULE_USER_MANAGEMENT_FEATURE_USER_MANAGEMENT = "ACCESS.MODULE_USER_MANAGEMENT.FEATURE_USER_MANAGEMENT",
+    ACCESS_MODULE_USER_MANAGEMENT_FEATURE_USER_GROUPS_MANAGEMENT = "ACCESS.MODULE_USER_MANAGEMENT.FEATURE_USER_GROUPS_MANAGEMENT",
+    ACCESS_MODULE_USER_MANAGEMENT_FEATURE_GLOBAL_ROLES_MANAGEMENT = "ACCESS.MODULE_USER_MANAGEMENT.FEATURE_GLOBAL_ROLES_MANAGEMENT",
+    ACCESS_MODULE_USER_MANAGEMENT_FEATURE_INVENTORY_ROLES_MANAGEMENT = "ACCESS.MODULE_USER_MANAGEMENT.FEATURE_INVENTORY_ROLES_MANAGEMENT",
+    ACCESS_MODULE_TENANT_MANAGEMENT_FEATURE_APPLICATION = "ACCESS.MODULE_TENANT_MANAGEMENT.FEATURE_APPLICATION",
+    ACCESS_MODULE_TENANT_MANAGEMENT_FEATURE_READING_TYPES_MANAGEMENT = "ACCESS.MODULE_TENANT_MANAGEMENT.FEATURE_READING_TYPES_MANAGEMENT",
+    ACCESS_MODULE_TENANT_MANAGEMENT_FEATURE_INTEGRATIONS = "ACCESS.MODULE_TENANT_MANAGEMENT.FEATURE_INTEGRATIONS",
+    ACCESS_MODULE_TENANT_MANAGEMENT_FEATURE_ACCESS_KEYS = "ACCESS.MODULE_TENANT_MANAGEMENT.FEATURE_ACCESS_KEYS",
+    ACCESS_MODULE_TENANT_MANAGEMENT_FEATURE_AUDIT_LOG = "ACCESS.MODULE_TENANT_MANAGEMENT.FEATURE_AUDIT_LOG",
+    ACCESS_MODULE_DEVICES_AND_EDGE_FEATURE_APPLICATION = "ACCESS.MODULE_DEVICES_AND_EDGE.FEATURE_APPLICATION",
+    ACCESS_MODULE_DEVICES_AND_EDGE_FEATURE_DEVICES = "ACCESS.MODULE_DEVICES_AND_EDGE.FEATURE_DEVICES",
+    ACCESS_MODULE_DEVICES_AND_EDGE_FEATURE_TYPES = "ACCESS.MODULE_DEVICES_AND_EDGE.FEATURE_TYPES",
+    ACCESS_MODULE_DEVICES_AND_EDGE_FEATURE_GROUPS = "ACCESS.MODULE_DEVICES_AND_EDGE.FEATURE_GROUPS",
+    ACCESS_MODULE_DATA_MANAGEMENT_FEATURE_APPLICATION = "ACCESS.MODULE_DATA_MANAGEMENT.FEATURE_APPLICATION",
+    ACCESS_MODULE_DATA_MANAGEMENT_FEATURE_DATA_MANAGEMENT = "ACCESS.MODULE_DATA_MANAGEMENT.FEATURE_DATA_MANAGEMENT",
+    ACCESS_MODULE_DATA_MANAGEMENT_FEATURE_TYPES = "ACCESS.MODULE_DATA_MANAGEMENT.FEATURE_TYPES",
+    ACCESS_MODULE_RULE_ENGINE_FEATURE_APPLICATION = "ACCESS.MODULE_RULE_ENGINE.FEATURE_APPLICATION",
+    ACCESS_MODULE_DASHBOARDS_FEATURE_APPLICATION = "ACCESS.MODULE_DASHBOARDS.FEATURE_APPLICATION",
+    ACCESS_MODULE_MESSAGES_FEATURE_APPLICATION = "ACCESS.MODULE_MESSAGES.FEATURE_APPLICATION",
+    ACCESS_MODULE_MESSAGES_FEATURE_MESSAGE_TEMPLATES = "ACCESS.MODULE_MESSAGES.FEATURE_MESSAGE_TEMPLATES",
+    ACCESS_MODULE_MESSAGES_FEATURE_MESSAGES = "ACCESS.MODULE_MESSAGES.FEATURE_MESSAGES",
+    PLATFORM_MANAGEMENT_SETTINGS_VIEW = "PLATFORM_MANAGEMENT.SETTINGS.VIEW",
+    PLATFORM_MANAGEMENT_SETTINGS_MANAGE = "PLATFORM_MANAGEMENT.SETTINGS.MANAGE",
+    PLATFORM_MANAGEMENT_TENANTS_VIEW = "PLATFORM_MANAGEMENT.TENANTS.VIEW",
+    PLATFORM_MANAGEMENT_TENANTS_MANAGE = "PLATFORM_MANAGEMENT.TENANTS.MANAGE",
+    USER_MANAGEMENT_USERS_VIEW = "USER_MANAGEMENT.USERS.VIEW",
+    USER_MANAGEMENT_USERS_MANAGE = "USER_MANAGEMENT.USERS.MANAGE",
+    USER_MANAGEMENT_USER_GROUPS_VIEW = "USER_MANAGEMENT.USER_GROUPS.VIEW",
+    USER_MANAGEMENT_USER_GROUPS_MANAGE = "USER_MANAGEMENT.USER_GROUPS.MANAGE",
+    USER_MANAGEMENT_GLOBAL_ROLES_MANAGE = "USER_MANAGEMENT.GLOBAL_ROLES.MANAGE",
+    USER_MANAGEMENT_INVENTORY_ROLES_MANAGE = "USER_MANAGEMENT.INVENTORY_ROLES.MANAGE",
+    TENANT_CONFIGURATION_READING_TYPE_MANAGEMENT_MANAGE = "TENANT_CONFIGURATION.READING_TYPE_MANAGEMENT.MANAGE",
+    TENANT_CONFIGURATION_INTEGRATIONS_VIEW = "TENANT_CONFIGURATION.INTEGRATIONS.VIEW",
+    TENANT_CONFIGURATION_INTEGRATIONS_MANAGE = "TENANT_CONFIGURATION.INTEGRATIONS.MANAGE",
+    TENANT_CONFIGURATION_ACCESS_KEYS_VIEW = "TENANT_CONFIGURATION.ACCESS_KEYS.VIEW",
+    TENANT_CONFIGURATION_ACCESS_KEYS_MANAGE = "TENANT_CONFIGURATION.ACCESS_KEYS.MANAGE",
+    TENANT_CONFIGURATION_SETTINGS_MANAGE = "TENANT_CONFIGURATION.SETTINGS.MANAGE",
+    DEVICE_MANAGEMENT_DEVICE_GROUPS_VIEW = "DEVICE_MANAGEMENT.DEVICE_GROUPS.VIEW",
+    DEVICE_MANAGEMENT_DEVICE_GROUPS_MANAGE = "DEVICE_MANAGEMENT.DEVICE_GROUPS.MANAGE",
+    DEVICE_MANAGEMENT_DEVICE_GROUPS_ACCESS_VIEW = "DEVICE_MANAGEMENT.DEVICE_GROUPS.ACCESS_VIEW",
+    DEVICE_MANAGEMENT_DEVICE_GROUPS_ACCESS_MANAGE = "DEVICE_MANAGEMENT.DEVICE_GROUPS.ACCESS_MANAGE",
+    DATA_MANAGEMENT_DATA_VIEW = "DATA_MANAGEMENT.DATA.VIEW",
+    DATA_MANAGEMENT_DATA_MANAGE = "DATA_MANAGEMENT.DATA.MANAGE",
+    DATA_MANAGEMENT_DATA_ACCESS_VIEW = "DATA_MANAGEMENT.DATA.ACCESS_VIEW",
+    DATA_MANAGEMENT_DATA_ACCESS_MANAGE = "DATA_MANAGEMENT.DATA.ACCESS_MANAGE",
+    DATA_MANAGEMENT_DATA_DASHBOARDS_VIEW = "DATA_MANAGEMENT.DATA.DASHBOARDS_VIEW",
+    DATA_MANAGEMENT_DATA_DASHBOARDS_MANAGE = "DATA_MANAGEMENT.DATA.DASHBOARDS_MANAGE",
+    DATA_MANAGEMENT_SEMANTIC_TYPES_VIEW = "DATA_MANAGEMENT.SEMANTIC_TYPES.VIEW",
+    DATA_MANAGEMENT_SEMANTIC_TYPES_MANAGE = "DATA_MANAGEMENT.SEMANTIC_TYPES.MANAGE",
+    DATA_MANAGEMENT_SEMANTIC_TYPES_ACCESS_VIEW = "DATA_MANAGEMENT.SEMANTIC_TYPES.ACCESS_VIEW",
+    DATA_MANAGEMENT_SEMANTIC_TYPES_ACCESS_MANAGE = "DATA_MANAGEMENT.SEMANTIC_TYPES.ACCESS_MANAGE",
+    RULE_ENGINE_RULE_VIEW = "RULE_ENGINE.RULE.VIEW",
+    RULE_ENGINE_RULE_MANAGE = "RULE_ENGINE.RULE.MANAGE",
+    MESSAGES_TEMPLATES_VIEW = "MESSAGES.TEMPLATES.VIEW",
+    MESSAGES_TEMPLATES_MANAGE = "MESSAGES.TEMPLATES.MANAGE"
+}
+
+declare const createGlobalPermissionsGuard: (availableRoutesGetter: () => Routes, fallbackRoute: string[], parentRoutes?: string[]) => (permissions: Permission | Permission[]) => CanActivateFn;
+
+declare const AUTHENTICATION_CLIENT: InjectionToken<AuthenticationClient>;
+interface AuthenticationClient {
+    refreshToken(token: string): Observable<Authentication>;
+}
+
+declare class AuthenticationService {
+    private readonly authenticationClient;
+    private readonly LSK_REFRESH_TOKEN;
+    private readonly LSK_ACTIVE_TENANT;
+    private _activeUser$;
+    private _authorities$;
+    private _selectedAuthority$;
+    private refreshToken;
+    private _authenticationTokens;
+    constructor();
+    setAuthentication(authentication: Authentication): void;
+    updateUserName(firstName: string, lastName: string): void;
+    private initiateAuthenticatedState;
+    selectAuthority(authority: Authority): void;
+    logout(): void;
+    get accessToken(): Observable<string>;
+    get activeUser$(): Observable<User>;
+    get activeUser(): User | null;
+    get authorities$(): Observable<Authority[]>;
+    get activeAuthority(): Authority | null;
+    get activeAuthority$(): Observable<Authority>;
+    get unfilteredActiveAuthority$(): Observable<Authority | null>;
+    isAuthenticated(): Observable<boolean>;
+    private isValid;
+    getClaim(token: string, claim: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthenticationService>;
+}
+
+interface Feature {
+    name: string;
+    icon: SvgIcon;
+    order: number;
+    route: string;
+    translationPrefix: string;
+    permission?: string | string[];
+    primaryColor?: string;
+    secondaryColor?: string;
+    tertiaryColor?: string;
+    init?: () => void;
+}
+interface ExternalFeature {
+    remote: string;
+    exposedModule: string;
+}
+declare class FeatureRegistry {
+    private readonly injector;
+    private readonly _features;
+    registerFeature(feature: Feature): void;
+    loadExternalFeatures(features: ExternalFeature[]): void;
+    get features(): Observable<Feature[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeatureRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FeatureRegistry>;
+}
+
+declare class MapsLoaderService {
+    private readonly scriptSrc;
+    private readonly elementId;
+    readonly apiKey$: BehaviorSubject<string | null>;
+    readonly mapsLoaded$: BehaviorSubject<boolean>;
+    readonly mapError$: BehaviorSubject<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapsLoaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MapsLoaderService>;
+}
+
+declare class NotificationService {
+    private snackBar;
+    private translationService;
+    constructor(snackBar: MatSnackBar, translationService: TranslateService);
+    showInfo(message: string, duration?: number): void;
+    showSuccess(message: string, duration?: number): void;
+    showWarning(message: string, duration?: number): void;
+    showError(message: string, messageParameters?: any, duration?: number): rxjs.Observable<null>;
+    showGenericError(error?: any, duration?: number): rxjs.Observable<null>;
+    private showNotification;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare class PermissionsService {
+    readonly auth: AuthenticationService;
+    private _assetPermissions$;
+    private _globalPermissions$;
+    private _permissions$;
+    setAssetPermissions(permissions: string[] | null): void;
+    hasAnyPermission(permissions: string[]): Observable<boolean>;
+    hasAllPermissions(permissions: string[]): Observable<boolean>;
+    hasAnyGlobalOrAssetPermission(permissions: string[]): Observable<boolean>;
+    hasAllGlobalOrAssetPermissions(permissions: string[]): Observable<boolean>;
+    hasAnyPermissionSync(allPermissions: string[], permissions: string[]): boolean;
+    hasPermission(allPermissions: string[], permission?: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PermissionsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PermissionsService>;
+}
+
+declare class Locale {
+    name: string;
+    language: string;
+    country: string;
+    code: string;
+    countryLocaleCode: string;
+    constructor(language: string, country: string, name: string);
+}
+declare const DEFAULT_LOCALE: Locale;
+declare const LOCALES: Locale[];
+
+declare class TenantPropertiesService {
+    readonly dateAdapter: DateAdapter<any, any>;
+    locale: Locale;
+    timezone: string | null;
+    setLocale(locale: Locale): void;
+    setTimeZone(timeZone: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TenantPropertiesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TenantPropertiesService>;
+}
+
+interface Color {
+    name: string;
+    value: string;
+}
+interface Theme {
+    primary: string;
+    secondary: string;
+    tertiary: string;
+    error: string;
+    neutral: string;
+    neutralVariant: string;
+    warning: string;
+    success: string;
+}
+declare class ThemeService {
+    private readonly document;
+    private readonly THEME_KEY;
+    private readonly DEFAULT_COLORS;
+    private readonly themeType$;
+    readonly isDarkTheme$: rxjs.Observable<boolean>;
+    readonly chartTheme$: rxjs.Observable<ngx_echarts.ThemeOption>;
+    private readonly themeColors$;
+    constructor(document: Document);
+    get defaultColors(): Theme;
+    setThemeType(theme: 'SYSTEM' | 'LIGHT' | 'DARK'): void;
+    setThemeColors(primaryColor?: string, secondaryColor?: string, tertiaryColor?: string): void;
+    get themeType(): "SYSTEM" | "LIGHT" | "DARK";
+    get themeColors(): Theme;
+    computeColorFromHex(hex: string, tone: number): string;
+    private updateThemeVariables;
+    private updateColorVariables;
+    private computeColorPalette;
+    private getColorObject;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class LoadingIndicatorDirective {
+    private element;
+    set appLoadingShimmer(isLoading: boolean | unknown);
+    constructor(element: ElementRef<HTMLElement>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LoadingIndicatorDirective, "[appLoadingIndicator]", never, { "appLoadingShimmer": { "alias": "appLoadingIndicator"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LocalizedNumericInputDirective implements ControlValueAccessor {
+    private element;
+    private tenantPropertiesService;
+    locale: string;
+    decimalMarker: string;
+    thousandSeparator: string;
+    onChange: (value: any) => void;
+    onTouched: (ev: any) => void;
+    constructor(element: ElementRef<HTMLInputElement>, tenantPropertiesService: TenantPropertiesService);
+    input(value: any): void;
+    onFocus(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private printValue;
+    private parseValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalizedNumericInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LocalizedNumericInputDirective, "input[wolkaboutLocalizedNumericInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MessageTooltipDirective implements OnDestroy {
+    private overlay;
+    private elementRef;
+    private viewContainerRef;
+    private renderer;
+    tooltipTemplate: TemplateRef<any>;
+    private overlayRef;
+    private showTimeout;
+    constructor(overlay: Overlay, elementRef: ElementRef, viewContainerRef: ViewContainerRef, renderer: Renderer2);
+    show(): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MessageTooltipDirective, "[appMessageTooltip]", never, { "tooltipTemplate": { "alias": "appMessageTooltip"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgTemplateContentDirective {
+    template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgTemplateContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgTemplateContentDirective, "[appNgTemplateContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class OverflowClassDirective implements AfterViewInit, AfterViewChecked {
+    private el;
+    overflowClass: string | null;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    private checkScroll;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverflowClassDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverflowClassDirective, "[overflowClass]", never, { "overflowClass": { "alias": "overflowClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RequiresAllGlobalOrAssetPermissionsDirective {
+    private templateRef;
+    private viewContainer;
+    private permissions;
+    set appRequiresAllGlobalOrAssetPermissions(permissions: string | string[]);
+    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef, permissions: PermissionsService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequiresAllGlobalOrAssetPermissionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RequiresAllGlobalOrAssetPermissionsDirective, "[appRequiresAllGlobalOrAssetPermissions]", never, { "appRequiresAllGlobalOrAssetPermissions": { "alias": "appRequiresAllGlobalOrAssetPermissions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RequiresAllPermissionDirective {
+    private templateRef;
+    private viewContainer;
+    private permissions;
+    set appRequiresAllPermissions(permissions: string | string[]);
+    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef, permissions: PermissionsService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequiresAllPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RequiresAllPermissionDirective, "[appRequiresAllPermissions]", never, { "appRequiresAllPermissions": { "alias": "appRequiresAllPermissions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RequiresGlobalOrAsserPermissionDirective {
+    private templateRef;
+    private viewContainer;
+    private permissions;
+    set appRequiresGlobalOrAssetPermission(permissions: string | string[]);
+    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef, permissions: PermissionsService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequiresGlobalOrAsserPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RequiresGlobalOrAsserPermissionDirective, "[appRequiresGlobalOrAssetPermission]", never, { "appRequiresGlobalOrAssetPermission": { "alias": "appRequiresGlobalOrAssetPermission"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RequiresPermissionDirective {
+    private templateRef;
+    private viewContainer;
+    private permissions;
+    set appRequiresPermission(permissions: string | string[]);
+    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef, permissions: PermissionsService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequiresPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RequiresPermissionDirective, "[appRequiresPermission]", never, { "appRequiresPermission": { "alias": "appRequiresPermission"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollIntoViewDirective implements OnChanges {
+    private platformId;
+    private elementRef;
+    appScrollIntoView: boolean | undefined;
+    constructor(platformId: any, elementRef: ElementRef);
+    ngOnChanges(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollIntoViewDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollIntoViewDirective, "[appScrollIntoView]", never, { "appScrollIntoView": { "alias": "appScrollIntoView"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const formatDuration: (totalSeconds: number | undefined) => string;
+declare class DurationPipe implements PipeTransform {
+    /**
+     * Transforms the given value to "X days, Y hours, Z minutes" format
+     */
+    transform(totalSeconds?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DurationPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DurationPipe, "duration", true>;
+}
+
+declare class LocalizedNumberPipe implements PipeTransform {
+    private tenantPropertiesService;
+    constructor(tenantPropertiesService: TenantPropertiesService);
+    transform(value: number | string | null | undefined, decimals?: number, locale?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalizedNumberPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LocalizedNumberPipe, "localizedNumber", true>;
+}
+
+declare class SimpleDateTimePipe implements PipeTransform {
+    private tenantPropertiesService;
+    constructor(tenantPropertiesService: TenantPropertiesService);
+    transform(timestamp?: number | null, timeZone?: string | null, showTimeZone?: boolean, locale?: string | null): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleDateTimePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SimpleDateTimePipe, "simpleDateTime", true>;
+}
+
+declare class SimpleDatePipe implements PipeTransform {
+    private tenantPropertiesService;
+    constructor(tenantPropertiesService: TenantPropertiesService);
+    transform(timestamp?: number | null, timeZone?: string | null, showTimeZone?: boolean, locale?: string | null): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleDatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SimpleDatePipe, "simpleDate", true>;
+}
+
+declare class SimpleTimePipe implements PipeTransform {
+    private tenantPropertiesService;
+    constructor(tenantPropertiesService: TenantPropertiesService);
+    transform(timestamp?: number | null, timeZone?: string | null, showTimeZone?: boolean, locale?: string | null): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleTimePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SimpleTimePipe, "simpleTime", true>;
+}
+
+type SortDirection$1 = 'asc' | 'desc';
+declare class SortPipe implements PipeTransform {
+    transform(array: any, field?: string, direction?: SortDirection$1): any[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SortPipe, "sort", true>;
+}
+
+declare const chartThemeDark: ThemeOption;
+
+declare const COLORS: string[];
+declare const chartThemeLight: ThemeOption;
+
+declare const MILLISECONDS_IN_DAY = 86400000;
+declare const USERS_TIME_ZONE: string;
+declare const DEFAULT_TIME_ZONE: string;
+declare const startOfTheDay: (dayOffSet?: number, timeZone?: string | null) => number;
+declare const daysAway: (dayOffSet?: number, timeZone?: string | null) => number;
+declare const hoursAway: (hourOffset?: number, timeZone?: string | null) => number;
+declare const toStartOfTheDay: (millis: number, timeZone?: string | null) => number;
+declare function startOfWeek(weekOffset?: number, timeZone?: string | null): number;
+declare function toStartOfWeek(millis: number, timeZone?: string | null): number;
+declare function startOfMonth(monthOffset?: number, timeZone?: string | null): number;
+declare function toStartOfMonth(millis: number, timeZone?: string | null): number;
+declare function toEndOfMonth(millis: number, timeZone?: string | null): number;
+declare function startOfYear(yearOffset?: number, timeZone?: string | null): number;
+declare function toStartOfYear(millis: number, timeZone?: string | null): number;
+declare function toEndOfYear(millis: number, timeZone?: string | null): number;
+declare const toJsDate: (millis: number, timeZone?: string | null) => Date;
+declare const toTime: (millis: number, timeZone?: string | null) => {
+    hour: number;
+    minute: number;
+    offset: string;
+};
+declare const toOffset: (timeZone?: string | null) => string;
+declare const toDate: (millis: number, timeZone?: string | null) => {
+    day: number;
+    month: number;
+    year: number;
+    offset: string;
+};
+declare function parseTimeInput(date: Date, timeInput: string, timezone?: string): number;
+declare function format(millis: number, locale: string, format?: string): string;
+declare enum RelativeTimePeriod {
+    TODAY = "TODAY",
+    YESTERDAY = "YESTERDAY",
+    TOMORROW = "TOMORROW",
+    LAST_1_HOURS = "LAST_1_HOURS",
+    LAST_24_HOURS = "LAST_24_HOURS",
+    LAST_7_DAYS = "LAST_7_DAYS",
+    NEXT_7_DAYS = "NEXT_7_DAYS",
+    THIS_WEEK = "THIS_WEEK",
+    LAST_30_DAYS = "LAST_30_DAYS",
+    NEXT_30_DAYS = "NEXT_30_DAYS",
+    THIS_MONTH = "THIS_MONTH",
+    LAST_6_MONTHS = "LAST_6_MONTHS",
+    LAST_12_MONTHS = "LAST_12_MONTHS",
+    NEXT_12_MONTHS = "NEXT_12_MONTHS",
+    THIS_YEAR = "THIS_YEAR"
+}
+declare const RELATIVE_TIME_PERIODS: RelativeTimePeriod[];
+declare const startOfPeriod: (timezone?: string | null) => {
+    [key in RelativeTimePeriod]: number;
+};
+declare const endOfPeriod: (timezone?: string | null) => {
+    [key in RelativeTimePeriod]: number;
+};
+
+declare function saveFile(blob: Blob, fileName: string): void;
+
+declare function validateAssetName(control: AbstractControl): ValidationErrors | null;
+declare function fileSizeValidator(control: AbstractControl, maxSizeInBytes: number): ValidationErrors | null;
+declare function validateTypeAssetName(control: AbstractControl): ValidationErrors | null;
+
+declare class MissingTranslationHelper implements MissingTranslationHandler {
+    handle(params: MissingTranslationHandlerParams): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MissingTranslationHelper, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MissingTranslationHelper>;
+}
+
+declare function determineMinMaxValues(values: number[], paddingPercentage?: number): {
+    min: number;
+    max: number;
+};
+/**
+ * Determines the magnitude of the number.
+ *
+ * ...
+ * 100 - 999 -> 2
+ * 10 - 99 -> 1
+ * 0 - 9 -> 0
+ * 0.1 - 0.9999999999... -> -1
+ * 0.01 - 0.0999999... -> -2
+ * ...
+ */
+declare const determineMagnitude: (value: number) => number;
+declare const scale: (value: number, precision: number) => number;
+
+declare const equalsByValue: <T>(value1: T, value2: T) => boolean;
+declare const groupBy: <T>(array: T[], groupingFunction: (value: T) => string) => Record<string, T[]>;
+declare const uniqueFrom: <R, T>(array: T[], valueFunction: (value: T) => R) => R[];
+declare const uniqueBy: <R, T>(array: T[], valueFunction: (value: T) => R) => T[];
+declare const flatten: <T>(data: T[], getChildren: (node: T) => T[]) => T[];
+declare const flatMap: <T>(array: T[][]) => T[];
+declare const arrayToObject: <T, R>(array: T[] | null | undefined, propertyFunction: (entry: T) => string, mappingFunction: (entry: T) => R) => Record<string, R>;
+
+declare const generateRandomString: (length: number) => string;
+
+declare const DEFAULT_TIMEZONES = "Europe/Prague";
+declare const TIMEZONES: string[];
+
+/**
+ * Looks for the value of the specified queryParameter.
+ * Useful for many initialSelection implementations.
+ */
+declare const lookUpQueryParam: (queryParamName: string) => string | null;
+declare const lookUpPathPart: (index: number) => string | null;
+
+declare class AutocompleteComponent<ItemType> implements ControlValueAccessor, OnInit, OnDestroy {
+    controlDir: NgControl;
+    name: string;
+    dataFunction: (query: string) => Observable<ItemType[] | null>;
+    displayFunction: (item: ItemType) => string;
+    outlineBackground: boolean;
+    dropdownTemplate?: TemplateRef<unknown>;
+    autocompleteTrigger?: MatAutocompleteTrigger;
+    protected readonly Object: ObjectConstructor;
+    disabled: boolean;
+    formControl: FormControl<string | ItemType>;
+    data$: Observable<ItemType[] | null>;
+    loading$: Observable<boolean>;
+    componentIsDestroyed$: Subject<void>;
+    constructor(controlDir: NgControl);
+    onTouched: (ev: Event) => void;
+    ngOnInit(): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: (ev: Event) => void): void;
+    writeValue(value: ItemType): void;
+    setDisabledState(isDisabled: boolean): void;
+    clear(): void;
+    getErrors(): string[];
+    private setControlValidators;
+    private scrollEvent;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent<any>, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent<any>, "app-autocomplete", never, { "name": { "alias": "name"; "required": false; }; "dataFunction": { "alias": "dataFunction"; "required": false; }; "displayFunction": { "alias": "displayFunction"; "required": false; }; "outlineBackground": { "alias": "outlineBackground"; "required": false; }; }, {}, ["dropdownTemplate"], never, true, never>;
+}
+
+declare class AutocompleteChipsComponent<ItemType> implements OnInit, ControlValueAccessor, OnDestroy {
+    controlDir: NgControl;
+    name: string;
+    dataFunction: (query: string) => Observable<ItemType[] | null>;
+    displayFunction: (item: ItemType | any) => string;
+    outlineBackground: boolean;
+    dropdownTemplate?: TemplateRef<unknown>;
+    autocompleteTrigger?: MatAutocompleteTrigger;
+    inputRef: ElementRef<HTMLInputElement>;
+    protected readonly Object: ObjectConstructor;
+    disabled: boolean;
+    formControl: FormControl<string | null>;
+    items$: BehaviorSubject<ItemType[]>;
+    data$: Observable<ItemType[] | null>;
+    loading$: Observable<boolean>;
+    componentIsDestroyed$: Subject<void>;
+    onTouched: (ev: Event) => void;
+    constructor(controlDir: NgControl);
+    ngOnInit(): void;
+    removeItem(index: number, items: ItemType[]): void;
+    addItem(event: MatAutocompleteSelectedEvent): void;
+    registerOnChange(fn: (value: ItemType[]) => void): void;
+    registerOnTouched(fn: (ev: Event) => void): void;
+    writeValue(value: ItemType[] | null): void;
+    setDisabledState(isDisabled: boolean): void;
+    getErrors(): string[];
+    shouldShowOption(item: ItemType, items: ItemType[]): boolean;
+    private scrollEvent;
+    private setControlValidators;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteChipsComponent<any>, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteChipsComponent<any>, "app-autocomplete-chips", never, { "name": { "alias": "name"; "required": false; }; "dataFunction": { "alias": "dataFunction"; "required": false; }; "displayFunction": { "alias": "displayFunction"; "required": false; }; "outlineBackground": { "alias": "outlineBackground"; "required": false; }; }, {}, ["dropdownTemplate"], never, true, never>;
+}
+
+interface TimeSeries {
+    name: string;
+    unitGuid: string;
+    unitSymbol: string;
+    data: TimeSeriesData[];
+}
+interface TimeSeriesData {
+    timestamp: number;
+    value: number;
+}
+
+declare class BasicTimeSeriesGraphComponent {
+    private timeFormatter;
+    private themeService;
+    protected readonly chartTheme: _angular_core.Signal<ngx_echarts.ThemeOption | undefined>;
+    timeSeries: _angular_core.InputSignal<TimeSeries>;
+    desiredTimeFrame: _angular_core.InputSignal<{
+        from: number;
+        to: number;
+    } | undefined>;
+    primaryColor: _angular_core.InputSignal<string | undefined>;
+    graphOptions: _angular_core.Signal<EChartsOption>;
+    dataZoom: _angular_core.WritableSignal<{
+        start: number;
+        end: number;
+    } | null>;
+    constructor(timeFormatter: SimpleDateTimePipe);
+    chartZoom(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BasicTimeSeriesGraphComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BasicTimeSeriesGraphComponent, "app-basic-time-series-graph", never, { "timeSeries": { "alias": "timeSeries"; "required": true; "isSignal": true; }; "desiredTimeFrame": { "alias": "desiredTimeFrame"; "required": false; "isSignal": true; }; "primaryColor": { "alias": "primaryColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CardLabeledValueComponent {
+    permission: PermissionsService;
+    set permissions(permissions: string[] | undefined);
+    set useAssetPermissions(useAssetPermissions: boolean | undefined);
+    label: string;
+    editFunction: (() => void) | undefined;
+    icon: string;
+    tooltip: string;
+    private permissions$;
+    private useAssetPermissions$;
+    private hasPermission$;
+    hasPermission: _angular_core.Signal<boolean | undefined>;
+    constructor(permission: PermissionsService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardLabeledValueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardLabeledValueComponent, "app-card-labeled-value", never, { "permissions": { "alias": "permissions"; "required": false; }; "useAssetPermissions": { "alias": "useAssetPermissions"; "required": false; }; "label": { "alias": "label"; "required": true; }; "editFunction": { "alias": "editFunction"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ConfirmationData {
+    message: string;
+    parameters: any;
+    deleteDialog?: boolean;
+    actionButtonLabel?: string;
+}
+declare class ConfirmationDialogComponent {
+    data: ConfirmationData;
+    private dialog;
+    constructor(data: ConfirmationData, dialog: MatDialogRef<ConfirmationDialogComponent>);
+    confirm(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmationDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmationDialogComponent, "app-confirmation-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare function parseDateRangeInputPeriod(value: DateRangeValues | null, timezone: string | null): {
+    periodOption: "CUSTOM_PERIOD";
+    from: number;
+    to: number;
+} | {
+    periodOption: RelativeTimePeriod;
+    from: number;
+    to: number;
+} | null;
+declare const CUSTOM_PERIOD = "CUSTOM_PERIOD";
+type RelativeTimePeriodWithCustom = typeof CUSTOM_PERIOD | RelativeTimePeriod;
+interface DateRangeValues {
+    periodOption: RelativeTimePeriodWithCustom;
+    from?: number;
+    to?: number;
+}
+declare class PeriodErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+declare class DateRangeInputComponent implements ControlValueAccessor, Validator {
+    private destroyRef;
+    private tenantPropertiesService;
+    availableDateOptions: _angular_core.InputSignal<RelativeTimePeriod[]>;
+    translationPrefix: _angular_core.InputSignal<string | undefined>;
+    allowCustomTimespan: _angular_core.InputSignal<boolean>;
+    isInForm: _angular_core.InputSignal<boolean>;
+    datePicker: _angular_core.Signal<MatDateRangePicker<Date> | undefined>;
+    validators: _angular_core.InputSignal<(() => ValidationErrors)[]>;
+    private validateForm;
+    onTouched: (ev: any) => void;
+    private onChange;
+    onValidatorChange: () => void;
+    dateRangeForm: FormGroup<{
+        periodOption: FormControl<any>;
+        from: FormControl<any>;
+        to: FormControl<any>;
+    }>;
+    CUSTOM_PERIOD: string;
+    periodErrorStateMatcher: PeriodErrorStateMatcher;
+    constructor(destroyRef: DestroyRef, tenantPropertiesService: TenantPropertiesService);
+    writeValue(value: DateRangeValues | null | undefined): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    onTimeRangeChanged(selection: MatSelectChange): void;
+    emitValueChange(): void;
+    private onChangeForm;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangeInputComponent, "app-date-range-input", never, { "availableDateOptions": { "alias": "availableDateOptions"; "required": false; "isSignal": true; }; "translationPrefix": { "alias": "translationPrefix"; "required": false; "isSignal": true; }; "allowCustomTimespan": { "alias": "allowCustomTimespan"; "required": false; "isSignal": true; }; "isInForm": { "alias": "isInForm"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DateTimeFormFieldComponent implements OnDestroy, ControlValueAccessor, Validator {
+    private translate;
+    dateLabel?: string;
+    timeLabel?: string;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    formGroup: FormGroup<{
+        date: FormControl<DateTime<boolean> | null>;
+        time: FormControl<string | null>;
+    }>;
+    onTouched: (ev: any) => void;
+    onValidatorChange: () => void;
+    private destroy$;
+    private readonly timeRegex;
+    onTimeInputChange: BehaviorSubject<string | null>;
+    timeChange: rxjs.Observable<string | null>;
+    constructor(translate: TranslateService);
+    writeValue(obj: Date | number | string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    ngOnDestroy(): void;
+    getDateErrors(): string[];
+    getTimeErrors(): string[];
+    getDateErrorTooltip(): string;
+    getTimeErrorTooltip(): string;
+    onInputChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimeFormFieldComponent, "app-date-time-form-field", never, { "dateLabel": { "alias": "dateLabel"; "required": false; }; "timeLabel": { "alias": "timeLabel"; "required": false; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DragDropFileUploadComponent implements ControlValueAccessor, Validator, AfterViewInit, OnDestroy {
+    controlDir: NgControl;
+    private notificationService;
+    dragDropZone: ElementRef<HTMLDivElement>;
+    fileInput: ElementRef<HTMLInputElement>;
+    accept: string;
+    multiple?: boolean;
+    prompt: string;
+    highlight: boolean;
+    disabled: boolean;
+    files$: BehaviorSubject<File[] | null>;
+    TRUNCATE_NAME_LIMIT: number;
+    private destroy$;
+    constructor(controlDir: NgControl, notificationService: NotificationService);
+    onTouched: (ev?: any) => void;
+    onValidatorChange: () => void;
+    onChange: (value: any) => void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    writeValue(val: any): void;
+    ngAfterViewInit(): void;
+    getFileName(name: string): string;
+    getErrorForTranslation(errors?: ValidationErrors | null): {
+        key: string;
+        params?: any;
+    };
+    onFileAdded({ target }: {
+        target: any;
+    }): void;
+    deleteFile(event: MouseEvent, index: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropFileUploadComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DragDropFileUploadComponent, "application-drag-drop-file-upload", never, { "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface MapItem {
+    name: string;
+    lat: number;
+    lng: number;
+    trueLat?: number;
+    trueLng?: number;
+    path: string;
+    time: number;
+    color: string;
+}
+declare class GoogleMapComponent {
+    private translateService;
+    private simpleDateTimePipe;
+    map: _angular_core.Signal<GoogleMap>;
+    googleMapId: _angular_core.InputSignal<string>;
+    darkTheme: _angular_core.InputSignal<boolean>;
+    items: _angular_core.InputSignal<MapItem[]>;
+    pinColor: _angular_core.InputSignal<string>;
+    markerClicked: _angular_core.OutputEmitterRef<MapItem>;
+    zoom: _angular_core.WritableSignal<number>;
+    mapOptions: _angular_core.Signal<google.maps.MapOptions>;
+    clusterer: _angular_core.Signal<MarkerClusterer>;
+    markers: _angular_core.Signal<google.maps.marker.AdvancedMarkerElement[]>;
+    mapBounds: google.maps.LatLngBounds;
+    constructor(translateService: TranslateService, simpleDateTimePipe: SimpleDateTimePipe);
+    changeZoom(number: number): void;
+    fitBounds(): void;
+    private openDetails;
+    private createMarker;
+    addJitter(mapItems: MapItem[]): MapItem[];
+    private spreadMarkersInCircle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GoogleMapComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GoogleMapComponent, "app-google-map", never, { "googleMapId": { "alias": "googleMapId"; "required": true; "isSignal": true; }; "darkTheme": { "alias": "darkTheme"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "pinColor": { "alias": "pinColor"; "required": true; "isSignal": true; }; }, { "markerClicked": "markerClicked"; }, never, never, true, never>;
+}
+
+declare class ImageDisplayComponent {
+    readonly sanitizer: DomSanitizer;
+    readonly dialog: MatDialog;
+    value: _angular_core.InputSignal<string | null | undefined>;
+    imageUrl: Signal<SafeUrl>;
+    isHtml(image: SafeUrl | SafeHtml | null): boolean;
+    openImage(image: SafeUrl): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageDisplayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageDisplayComponent, "app-image-display", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ImagePreviewComponent {
+    data: {
+        image: SafeUrl | SafeHtml;
+    };
+    image: ElementRef<HTMLImageElement>;
+    svgElement: ElementRef<HTMLDivElement>;
+    dimensionStyles: WritableSignal<{
+        [key: string]: any;
+    }>;
+    constructor(data: {
+        image: SafeUrl | SafeHtml;
+    });
+    isHtml(image: SafeUrl | SafeHtml | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImagePreviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImagePreviewComponent, "app-image-preview", never, {}, {}, never, never, true, never>;
+}
+
+declare class LabeledValueComponent {
+    name: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabeledValueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabeledValueComponent, "app-labeled-value", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class LoadedIconComponent {
+    private sanitizer;
+    iconRequest: _angular_core.InputSignal<Observable<Blob | null>>;
+    defaultIcon: _angular_core.InputSignal<string | SvgIcon>;
+    size: _angular_core.InputSignal<number>;
+    icon: _angular_core.Signal<Observable<_angular_platform_browser.SafeHtml | null>>;
+    isSvgIcon(): SvgIcon | null;
+    constructor(sanitizer: DomSanitizer);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadedIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadedIconComponent, "app-loaded-icon", never, { "iconRequest": { "alias": "iconRequest"; "required": true; "isSignal": true; }; "defaultIcon": { "alias": "defaultIcon"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TableColumn {
+    name: string;
+    shouldSort: boolean;
+    shouldTranslateValue?: boolean;
+}
+type SortDirection = 'asc' | 'desc';
+declare class LocalSortTableComponent {
+    columns: _angular_core.InputSignal<TableColumn[]>;
+    data: _angular_core.InputSignal<Record<string, any>[]>;
+    translationPrefix: _angular_core.InputSignal<string>;
+    loading: _angular_core.InputSignal<boolean>;
+    itemSelected: _angular_core.OutputEmitterRef<Record<string, any>>;
+    sortDirection: SortDirection;
+    sortField: string;
+    displayData: _angular_core.WritableSignal<Record<string, any>[] | null>;
+    sorting: _angular_core.WritableSignal<boolean>;
+    constructor();
+    sort(field: string, shouldUpdateDirectionAndField?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalSortTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LocalSortTableComponent, "app-local-sort-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "translationPrefix": { "alias": "translationPrefix"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Determines the width ratio between master and detail parts.
+ * The idea is to use appropriate ratios to maintain the equal width between all master parts
+ * in the case where a master-detail component is embedded as a detail of another.
+ *
+ * 'full' width will use 25% of the available width for the master part.
+ * 'medium' will use 33% of the available width, which corresponds to 25% of total width when embedded once.
+ * 'narrow' will use 50% of the available width, which corresponds to 25% of total width when embedded twice.
+ */
+type MasterDetailDisplayRatio = 'full' | 'wide' | 'medium' | 'narrow' | 'reverse';
+declare class MasterDetailsViewComponent {
+    displayRatio: MasterDetailDisplayRatio;
+    calculateWidth(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MasterDetailsViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MasterDetailsViewComponent, "app-master-details-view", never, { "displayRatio": { "alias": "displayRatio"; "required": false; }; }, {}, never, ["[app-master]", "[app-details]"], true, never>;
+}
+
+interface NestedListItem<ItemType> {
+    id: string;
+    name: string;
+    idPath: string;
+    type?: string;
+    icon: string | LoadedIcon | SvgIcon;
+    isRoot: boolean;
+    data: ItemType;
+}
+declare abstract class NestedListDataSource<ItemType> {
+    /**
+     * Loads roots (needed for multiple roots).
+     */
+    abstract loadRoots(): Observable<ItemType[]>;
+    /**
+     * Loads the breadcrumb data (top half).
+     */
+    abstract loadBreadcrumbs(id: string): Observable<ItemType[]>;
+    /**
+     * Loads children for the currently selected item.
+     */
+    abstract loadChildren(item: NestedListItem<ItemType>): Observable<ItemType[]>;
+    /**
+     * Sets the id of the item that should be loaded first.
+     */
+    abstract initialSelection(): string | null;
+    /**
+     * Generalized the item and prepares it for display.
+     */
+    abstract prepareItem(item: ItemType, isRoot?: boolean): NestedListItem<ItemType>;
+    sortingFunction(item1: NestedListItem<ItemType>, item2: NestedListItem<ItemType>): number;
+}
+
+declare class NestedListDataControl<ItemType> {
+    private _changeSelection$;
+    private _itemUpdated$;
+    private _childAdded;
+    private _itemRemoved$;
+    readonly selectItem: (id: string) => void;
+    readonly updateItem: (item: ItemType) => void;
+    readonly addItem: (item: ItemType) => void;
+    readonly removeItem: (id: string) => void;
+    /**
+     * Internal event hook. Do not use outside the Nested List Component
+     */
+    get changeSelection$(): Observable<string>;
+    /**
+     * Internal event hook. Do not use outside of the Nested List Component
+     */
+    get itemUpdated$(): Observable<ItemType>;
+    /**
+     * Internal event hook. Do not use outside the Nested List Component
+     */
+    get childAdded(): Observable<ItemType>;
+    /**
+     * Internal event hook. Do not use outside the Nested List Component
+     */
+    get itemRemoved$(): Observable<string>;
+}
+
+interface SearchAction {
+    name: string;
+    icon: SvgIcon;
+    defaultAction?: boolean;
+    action: (params?: any) => void;
+    disableCondition?: (params?: any) => boolean;
+    disabledTooltip?: string;
+    condition: (params?: any) => Observable<boolean>;
+}
+declare class NestedListViewComponent<ItemType> {
+    private destroyRef;
+    private dialog;
+    dataSource: _angular_core.InputSignal<NestedListDataSource<ItemType>>;
+    dataControl: _angular_core.InputSignal<NestedListDataControl<ItemType>>;
+    position: _angular_core.InputSignal<"inner" | "outer">;
+    disableThresholdId: _angular_core.InputSignal<string | null | undefined>;
+    hideDetails: _angular_core.InputSignal<boolean>;
+    isColoredInput: _angular_core.InputSignal<boolean>;
+    searchActions: _angular_core.InputSignal<SearchAction[]>;
+    defaultSearchAction: _angular_core.Signal<SearchAction | undefined>;
+    otherSearchActions: _angular_core.Signal<SearchAction[]>;
+    width: _angular_core.Signal<"w-full" | "basis-1/4" | "basis-1/2">;
+    loadingBreadcrumbs: _angular_core.WritableSignal<boolean>;
+    loadingChildren: _angular_core.WritableSignal<boolean>;
+    selectedItem: _angular_core.WritableSignal<NestedListItem<ItemType> | null>;
+    hideSearch: _angular_core.InputSignal<boolean>;
+    nameSearchControl: FormControl<string | null>;
+    searchTerm: _angular_core.Signal<string | null | undefined>;
+    breadcrumbs: _angular_core.WritableSignal<NestedListItem<ItemType>[]>;
+    roots: _angular_core.WritableSignal<NestedListItem<ItemType>[]>;
+    hasMultipleRoots: _angular_core.WritableSignal<boolean>;
+    rootButtonText: _angular_core.InputSignal<string>;
+    enableDrag: _angular_core.InputSignal<boolean>;
+    isDragging: _angular_core.WritableSignal<boolean>;
+    dragging: _angular_core.OutputEmitterRef<boolean>;
+    children: _angular_core.WritableSignal<NestedListItem<ItemType>[]>;
+    filteredChildren: _angular_core.Signal<NestedListItem<ItemType>[]>;
+    itemSelected: _angular_core.OutputEmitterRef<ItemType | null>;
+    constructor(destroyRef: DestroyRef, dialog: MatDialog);
+    private initiateState;
+    selectBreadcrumb(item: NestedListItem<ItemType>): void;
+    selectChild(item: NestedListItem<ItemType>): void;
+    dragStart(event: DragEvent, item: ItemType): void;
+    resetNavigation(): void;
+    shouldDisableBreadcrumbClick(item: NestedListItem<ItemType>): boolean | "" | null | undefined;
+    isAsyncIcon(item: NestedListItem<ItemType>): LoadedIcon | null;
+    isSvgIcon(item: NestedListItem<ItemType>): SvgIcon | null;
+    formControlAction(params?: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NestedListViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NestedListViewComponent<any>, "app-nested-list-view", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "dataControl": { "alias": "dataControl"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "disableThresholdId": { "alias": "disableThresholdId"; "required": false; "isSignal": true; }; "hideDetails": { "alias": "hideDetails"; "required": false; "isSignal": true; }; "isColoredInput": { "alias": "isColoredInput"; "required": false; "isSignal": true; }; "searchActions": { "alias": "searchActions"; "required": false; "isSignal": true; }; "hideSearch": { "alias": "hideSearch"; "required": false; "isSignal": true; }; "rootButtonText": { "alias": "rootButtonText"; "required": false; "isSignal": true; }; "enableDrag": { "alias": "enableDrag"; "required": false; "isSignal": true; }; }, { "dragging": "dragging"; "itemSelected": "itemSelected"; }, never, ["[app-no-items-message]", "[app-actions]", "[app-details]"], true, never>;
+}
+
+declare class PdfViewerComponent {
+    private sanitizer;
+    value: _angular_core.InputSignal<string>;
+    safeSrc: _angular_core.Signal<SafeResourceUrl | null>;
+    constructor(sanitizer: DomSanitizer);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdfViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdfViewerComponent, "app-pdf-viewer", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StandardListItem<ItemType> {
+    id: string;
+    name: string;
+    icon: string | LoadedIcon | SvgIcon;
+    data: ItemType;
+}
+declare abstract class StandardListDataSource<ItemType> {
+    page: number;
+    isPaged: boolean;
+    isLastPage: boolean;
+    /**
+     * Loads the initial data from the backend.
+     */
+    abstract loadData(): Observable<ItemType[]>;
+    /**
+     * Sets the id of the item that should be selected as soon as the data loads.
+     */
+    abstract initialSelection(): string[] | string | null;
+    /**
+     * Generalized the item and prepares it for display.
+     */
+    abstract prepareItem(item: ItemType): StandardListItem<ItemType>;
+    sortingFunction(item1: StandardListItem<ItemType>, item2: StandardListItem<ItemType>): number;
+    /**
+     * If isPaged is set to true, implement this method, gets next page from the backend.
+     */
+    nextPage(): Observable<ItemType[]>;
+}
+
+declare class StandardListDataControl<ItemType> {
+    private _changeSelection$;
+    private _itemUpdated$;
+    private _itemAdded$;
+    private _itemRemoved$;
+    readonly selectItem: (id: string) => void;
+    readonly updateItem: (item: ItemType) => void;
+    readonly addItem: (item: ItemType) => void;
+    readonly removeItem: (id: string) => void;
+    /**
+     * Internal event hook. Do not use outside the Standard List Component
+     */
+    get changeSelection$(): Observable<string>;
+    /**
+     * Internal event hook. Do not use outside of the Standard List Component
+     */
+    get itemUpdated$(): Observable<ItemType>;
+    /**
+     * Internal event hook. Do not use outside the Standard List Component
+     */
+    get itemAdded$(): Observable<ItemType>;
+    /**
+     * Internal event hook. Do not use outside the Standard List Component
+     */
+    get itemRemoved$(): Observable<string>;
+}
+
+declare class StandardListViewComponent<ItemType> {
+    dataSource: _angular_core.InputSignal<StandardListDataSource<ItemType>>;
+    dataControl: _angular_core.InputSignal<StandardListDataControl<ItemType>>;
+    position: _angular_core.InputSignal<"inner" | "outer">;
+    isColoredInput: _angular_core.InputSignal<boolean>;
+    loadingData: _angular_core.WritableSignal<boolean>;
+    loadingPage: _angular_core.WritableSignal<boolean>;
+    selectedItem: _angular_core.WritableSignal<StandardListItem<ItemType> | null>;
+    hideSearch: _angular_core.InputSignal<boolean>;
+    hideDetails: _angular_core.InputSignal<boolean>;
+    hidePadding: _angular_core.InputSignal<boolean>;
+    width: _angular_core.Signal<"w-full" | "basis-1/4" | "basis-1/3">;
+    nameSearchControl: FormControl<string | null>;
+    searchTerm: _angular_core.Signal<string | null | undefined>;
+    items: _angular_core.WritableSignal<StandardListItem<ItemType>[]>;
+    filteredItems: _angular_core.Signal<StandardListItem<ItemType>[]>;
+    itemSelected: _angular_core.OutputEmitterRef<ItemType | null>;
+    content: _angular_core.Signal<NgTemplateContentDirective | undefined>;
+    constructor(destroyRef: DestroyRef);
+    selectItem(item: StandardListItem<ItemType>): void;
+    selectEmpty(): void;
+    isAsyncIcon(item: StandardListItem<ItemType>): LoadedIcon | null;
+    isSvgIcon(item: StandardListItem<ItemType>): SvgIcon | null;
+    loadMore(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StandardListViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StandardListViewComponent<any>, "app-standard-list-view", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "dataControl": { "alias": "dataControl"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "isColoredInput": { "alias": "isColoredInput"; "required": false; "isSignal": true; }; "hideSearch": { "alias": "hideSearch"; "required": false; "isSignal": true; }; "hideDetails": { "alias": "hideDetails"; "required": false; "isSignal": true; }; "hidePadding": { "alias": "hidePadding"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, ["content"], ["[app-no-items-message]", "[app-actions]", "[app-details]"], true, never>;
+}
+
+declare const LAST_ACTIVE_TAB_KEY = "WOLK_LAST_ACTIVE_TAB";
+declare class TabulatedChipViewComponent {
+    private router;
+    private route;
+    tabs: _angular_core.InputSignal<Tab[]>;
+    queryParamHandling: _angular_core.InputSignal<QueryParamsHandling>;
+    saveLastActiveTab: _angular_core.InputSignal<boolean>;
+    navBarLayoutClasses: _angular_core.InputSignal<string>;
+    constructor(router: Router, route: ActivatedRoute);
+    isActive(route: string): boolean;
+    navigate(route: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabulatedChipViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabulatedChipViewComponent, "app-tabulated-chip-view", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "queryParamHandling": { "alias": "queryParamHandling"; "required": false; "isSignal": true; }; "saveLastActiveTab": { "alias": "saveLastActiveTab"; "required": false; "isSignal": true; }; "navBarLayoutClasses": { "alias": "navBarLayoutClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabulatedViewComponent {
+    private router;
+    private route;
+    tabs: Tab[];
+    constructor(router: Router, route: ActivatedRoute);
+    isActive(route: string): boolean;
+    navigate(route: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabulatedViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabulatedViewComponent, "app-tabulated-view", never, { "tabs": { "alias": "tabs"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+interface TreeNode<Type> {
+    guid: string;
+    name: string;
+    icon: string;
+    canHaveChildren: boolean;
+    hasChildren: boolean;
+    children: Observable<TreeNode<Type>[]>;
+    data: Type;
+    open: boolean;
+    selected: boolean;
+}
+
+declare class TreeComponent {
+    roots: _angular_core.InputSignal<TreeNode<any>[]>;
+    guidPath: _angular_core.InputSignal<string[]>;
+    nodeSelected: _angular_core.OutputEmitterRef<TreeNode<any>>;
+    selectedNode: TreeNode<any> | null;
+    constructor();
+    private discoverNode;
+    selectNode(node: TreeNode<any>): void;
+    private markSelected;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeComponent, "app-tree", never, { "roots": { "alias": "roots"; "required": true; "isSignal": true; }; "guidPath": { "alias": "guidPath"; "required": true; "isSignal": true; }; }, { "nodeSelected": "nodeSelected"; }, never, never, true, never>;
+}
+
+declare class TreeNodeComponent {
+    node: _angular_core.InputSignal<TreeNode<any>>;
+    nodeSelected: _angular_core.OutputEmitterRef<TreeNode<any>>;
+    toggle(node: TreeNode<any>): void;
+    selectNode(node: TreeNode<any>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeComponent, "app-tree-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, { "nodeSelected": "nodeSelected"; }, never, never, true, never>;
+}
+
+declare class ValueDisplayComponent {
+    protected readonly DataType: typeof DataType;
+    value: _angular_core.InputSignal<string | null | undefined>;
+    type: _angular_core.InputSignal<DataType>;
+    unit: _angular_core.InputSignal<string | undefined>;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<CommonsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CommonsService>;
+    getNumber(epochTime: string): number;
+    getVectorValue(vector: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueDisplayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueDisplayComponent, "app-value-display", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ValueInputValidationConditions {
+    regex?: string | RegExp | null;
+    required?: boolean | null;
+    minSize?: number | null;
+    maxSize?: number | null;
+}
+declare class ValueInputComponent implements ControlValueAccessor, Validator {
+    name: _angular_core.InputSignal<string>;
+    dataType: _angular_core.InputSignal<DataType>;
+    options: _angular_core.InputSignal<string[] | undefined>;
+    validationConditions: _angular_core.InputSignal<ValueInputValidationConditions | null | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    validators: _angular_core.WritableSignal<ValidatorFn[]>;
+    formControl: FormControl<string | null>;
+    onValidatorChange: () => void;
+    constructor();
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    onTouched: (event: Event) => void;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: (event: Event) => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private setValidators;
+    protected readonly DataType: typeof DataType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputComponent, "app-value-input", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "validationConditions": { "alias": "validationConditions"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputBooleanComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    name: _angular_core.InputSignal<string>;
+    formControl: FormControl<boolean | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    constructor(translate: TranslateService);
+    onTouched: () => void;
+    onValidatorChange: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputBooleanComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputBooleanComponent, "app-value-input-boolean", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputColorComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    name: _angular_core.InputSignal<string>;
+    colorPicker: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    showPicker: boolean;
+    formControl: FormControl<string | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    openColorPicker(): void;
+    onColorPickerChange(event: Event): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    private hexadecimalColorValidator;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputColorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputColorComponent, "app-value-input-color", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputDateComponent implements ControlValueAccessor, Validator, OnDestroy {
+    formControl: FormControl<Date | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor();
+    writeValue(value: Date): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputDateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputDateComponent, "app-value-input-date", never, { "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputDurationComponent implements ControlValueAccessor, Validator {
+    private destroyRef;
+    private translate;
+    name: _angular_core.InputSignal<string>;
+    formControl: FormControl<string | null>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    durationValidator: ValidatorFn;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(destroyRef: DestroyRef, translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    parseDurationToSeconds(duration: string | null): number | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputDurationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputDurationComponent, "app-value-input-duration", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputEnumComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    formControl: FormControl<string | null>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    destroy$: Subject<void>;
+    options: _angular_core.InputSignal<string[] | undefined>;
+    name: _angular_core.InputSignal<string>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputEnumComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputEnumComponent, "app-value-input-enum", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputHexadecimalComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    formControl: FormControl<string | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    constructor(translate: TranslateService);
+    onTouched: any;
+    onValidatorChange: () => void;
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    private hexadecimalValidator;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputHexadecimalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputHexadecimalComponent, "app-value-input-hexadecimal", never, { "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputLinkComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    formControl: FormControl<string | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private linkValidator;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputLinkComponent, "app-value-input-link", never, { "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputLocationComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    destroy$: Subject<void>;
+    formGroup: FormGroup<{
+        latitude: FormControl<string | null>;
+        longitude: FormControl<string | null>;
+    }>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    handleLocationPaste(event: ClipboardEvent, formControlName: 'latitude' | 'longitude'): void;
+    getErrors(controlName: string): string[];
+    getErrorTooltip(controlName: string): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputLocationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputLocationComponent, "app-value-input-location", never, { "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputNumericComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    formControl: FormControl<number | null>;
+    destroy$: Subject<void>;
+    name: _angular_core.InputSignal<string>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    writeValue(value: number): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    private numberValidator;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputNumericComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputNumericComponent, "app-value-input-numeric", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputStringComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    name: _angular_core.InputSignal<string>;
+    formControl: FormControl<string | null>;
+    destroy$: Subject<void>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputStringComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputStringComponent, "app-value-input-string", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ValueInputVectorComponent implements ControlValueAccessor, Validator, OnDestroy {
+    private translate;
+    formControl: FormControl<string | null>;
+    destroy$: Subject<void>;
+    options: _angular_core.InputSignal<string[] | undefined>;
+    name: _angular_core.InputSignal<string>;
+    showErrorInTooltip: _angular_core.InputSignal<boolean>;
+    validators: _angular_core.InputSignal<ValidatorFn[] | undefined>;
+    onTouched: any;
+    onValidatorChange: () => void;
+    constructor(translate: TranslateService);
+    writeValue(value: string): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: any): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getErrors(): string[];
+    getErrorTooltip(): string;
+    validateOptions: (control: AbstractControl) => ValidationErrors | null;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueInputVectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueInputVectorComponent, "app-value-input-vector", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "showErrorInTooltip": { "alias": "showErrorInTooltip"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { CommonsService };
+export { AUTHENTICATION_CLIENT, AuthenticationService, AutocompleteChipsComponent, AutocompleteComponent, BasicTimeSeriesGraphComponent, COLORS, CUSTOM_PERIOD, CardLabeledValueComponent, ConfirmationDialogComponent, DEFAULT_LOCALE, DEFAULT_TIMEZONES, DEFAULT_TIME_ZONE, DataType, DateRangeInputComponent, DateTimeFormFieldComponent, DragDropFileUploadComponent, DurationPipe, FeatureRegistry, GoogleMapComponent, ImageDisplayComponent, ImagePreviewComponent, LAST_ACTIVE_TAB_KEY, LOCALES, LabeledValueComponent, LoadedIconComponent, LoadingIndicatorDirective, LocalSortTableComponent, Locale, LocalizedNumberPipe, LocalizedNumericInputDirective, MILLISECONDS_IN_DAY, MapsLoaderService, MasterDetailsViewComponent, MessageTooltipDirective, MissingTranslationHelper, NestedListDataControl, NestedListDataSource, NestedListViewComponent, NgTemplateContentDirective, NotificationService, OverflowClassDirective, PdfViewerComponent, PeriodErrorStateMatcher, Permission, PermissionsService, RELATIVE_TIME_PERIODS, RelativeTimePeriod, RequiresAllGlobalOrAssetPermissionsDirective, RequiresAllPermissionDirective, RequiresGlobalOrAsserPermissionDirective, RequiresPermissionDirective, ScrollIntoViewDirective, SimpleDatePipe, SimpleDateTimePipe, SimpleTimePipe, SortPipe, StandardListDataControl, StandardListDataSource, StandardListViewComponent, TIMEZONES, TabulatedChipViewComponent, TabulatedViewComponent, TenantPropertiesService, ThemeService, TreeComponent, TreeNodeComponent, USERS_TIME_ZONE, ValueDisplayComponent, ValueInputBooleanComponent, ValueInputColorComponent, ValueInputComponent, ValueInputDateComponent, ValueInputDurationComponent, ValueInputEnumComponent, ValueInputHexadecimalComponent, ValueInputLinkComponent, ValueInputLocationComponent, ValueInputNumericComponent, ValueInputStringComponent, ValueInputVectorComponent, angularComponents, arrayToObject, chartThemeDark, chartThemeLight, createGlobalPermissionsGuard, daysAway, determineMagnitude, determineMinMaxValues, endOfPeriod, equalsByValue, fileSizeValidator, flatMap, flatten, format, formatDuration, generateRandomString, groupBy, hoursAway, isContextAccessible, lookUpPathPart, lookUpQueryParam, parseDateRangeInputPeriod, parseTimeInput, saveFile, scale, shared, startOfMonth, startOfPeriod, startOfTheDay, startOfWeek, startOfYear, toDate, toEndOfMonth, toEndOfYear, toJsDate, toOffset, toStartOfMonth, toStartOfTheDay, toStartOfWeek, toStartOfYear, toTime, uniqueBy, uniqueFrom, validateAssetName, validateTypeAssetName };
+export type { Authentication, AuthenticationClient, Authority, Color, ConfirmationData, DateRangeValues, ExternalFeature, Feature, ImportError, LoadedIcon, MapItem, MasterDetailDisplayRatio, NestedListItem, RelativeTimePeriodWithCustom, SearchAction, SortDirection$1 as SortDirection, StandardListItem, SvgIcon, Tab, Theme, TimeSeries, TimeSeriesData, TreeNode, User, ValueInputValidationConditions };