oip-common 0.0.4 → 0.0.5

package/index.d.ts

@@ -0,0 +1,1028 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, WritableSignal, EventEmitter, Renderer2, PipeTransform } from '@angular/core';
+import { MessageService, ToastMessageOptions, MenuItem, SelectItem, ConfirmationService } from 'primeng/api';
+import { ActivatedRoute, QueryParamsHandling, IsActiveMatchOptions, Params, Router, UrlTree } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import * as rxjs from 'rxjs';
+import { Subject, BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { OidcSecurityService, LoginResponse, LogoutAuthOptions, AbstractSecurityStorage, StsConfigHttpLoader } from 'angular-auth-oidc-client';
+import { ContextMenu } from 'primeng/contextmenu';
+import { HttpInterceptorFn, HttpClient as HttpClient$1 } from '@angular/common/http';
+import { SafeUrl } from '@angular/platform-browser';
+
+interface TopBarDto {
+    id: 'content' | 'settings' | 'security';
+    icon: string;
+    caption: string;
+    claims?: string[];
+    click?(): void;
+}
+
+declare class TopBarService {
+    topBarItems: TopBarDto[];
+    private _activeId;
+    get availableTopBarItems(): TopBarDto[];
+    get activeTopBarItem(): TopBarDto | undefined;
+    get activeId(): string | undefined;
+    set activeId(value: string | undefined);
+    constructor();
+    setTopBarItems(items: TopBarDto[]): void;
+    checkId(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TopBarService>;
+}
+
+declare class MsgService {
+    protected readonly messageService: MessageService;
+    private readonly translate;
+    private readonly lifetime;
+    add(msg: ToastMessageOptions): void;
+    success(detail: any, summary?: any, life?: number): void;
+    info(detail: any, summary?: any, life?: number): void;
+    warn(detail: any, summary?: any, life?: number): void;
+    error(detail: any, summary?: any, life?: number): void;
+    contrast(detail: any, summary?: any, life?: number): void;
+    secondary(detail: any, summary?: any, life?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MsgService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MsgService>;
+}
+
+/**
+ * BaseDataService provides a unified interface for sending HTTP requests
+ * using Angular's HttpClient. It supports standard HTTP methods and automatic
+ * credential handling.
+ */
+declare class BaseDataService {
+    private readonly http;
+    /**
+     * Gets the base URL of the application from the HTML <base> tag.
+     */
+    get baseUrl(): string;
+    /**
+     * Sends an HTTP request with the specified method and data.
+     *
+     * @template TResponse - Expected response type.
+     * @param url - The target URL for the HTTP request.
+     * @param method - The HTTP method to use (GET, PUT, POST, DELETE). Default is 'GET'.
+     * @param data - An object containing request parameters or payload.
+     * @returns A promise that resolves to the response of type TResponse.
+     */
+    sendRequest<TResponse>(url: string, method?: 'GET' | 'PUT' | 'POST' | 'DELETE', data?: any): Promise<TResponse>;
+    /**
+     * Sends a GET request and retrieves a response as a Blob.
+     *
+     * @param url - The target URL for the GET request.
+     * @returns A promise that resolves to a Object response.
+     */
+    getBlob(url: string): Promise<object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseDataService>;
+}
+
+/**
+ * Service to manage the application title.
+ */
+declare class AppTitleService {
+    private readonly title;
+    private titleSubject;
+    title$: rxjs.Observable<string>;
+    /**
+     * Set the title of the current HTML document.
+     * @param newTitle
+     */
+    setTitle(newTitle: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppTitleService>;
+}
+
+declare abstract class BaseModuleComponent<TBackendStoreSettings, TLocalStoreSettings> implements OnInit, OnDestroy {
+    /**
+     * Provides access to topbar related functionality, such as managing visibility and content.
+     * @type {TopBarService}
+     */
+    readonly topBarService: TopBarService;
+    /**
+     * Provides access to information about the current route.
+     * This includes route parameters, data, and the route's path.
+     */
+    readonly route: ActivatedRoute;
+    /**
+     * Provides access to messaging services.
+     */
+    readonly msgService: MsgService;
+    /**
+     * Provides access to base data service functionality.
+     * @deprecated The method should not be used
+     */
+    readonly baseDataService: BaseDataService;
+    /**
+     * Provides access to translation functionality.
+     */
+    readonly translateService: TranslateService;
+    /**
+     * Provides access to the application's title service.
+     */
+    readonly appTitleService: AppTitleService;
+    /**
+     * Reference to the ChangeDetector. Used to trigger change detection manually.
+     */
+    private changeDetectorRef;
+    /**
+     * Represents a subscription to an observable.
+     * Manages the lifecycle of receiving data from the observable and allows unsubscribing to stop receiving data.
+     * @type {Subscription}
+     */
+    private subscriptions;
+    /**
+     * Configuration object for backend storage
+     * @type {TBackendStoreSettings}
+     */
+    settings: TBackendStoreSettings;
+    /**
+     * Configuration object for local storage.
+     * @type {TLocalStoreSettings}
+     */
+    _localSettings: TLocalStoreSettings;
+    /**
+     * A signal representing the local application settings.  Changes to this signal
+     * propagate updates to the underlying local store settings.
+     * @type {WritableSignal<TLocalStoreSettings>}
+     */
+    localSettings: WritableSignal<TLocalStoreSettings>;
+    /**
+     * A Subject emitting updates to local store settings. Observables can subscribe to this Subject to react to changes in local settings.
+     * @type {Subject<TLocalStoreSettings>}
+     */
+    localSettingsUpdate: Subject<TLocalStoreSettings>;
+    /**
+     * The title of the component. Get from Title in ngOnInit
+     * @type {string}
+     */
+    title: string;
+    /**
+     * Updates local settings and persists them to local storage.
+     * @return {void}
+     */
+    private onConfigUpdate;
+    private getLocalStorageSettings;
+    /**
+     * A unique numerical identifier for the module.
+     * @type {number}
+     */
+    id: number | undefined;
+    /**
+     * The name of the controller currently handling the request.
+     * @type {string}
+     */
+    controller: string;
+    /**
+     * Checks if the content ID is present.
+     * @returns {boolean} True if the content ID is present, false otherwise.
+     */
+    get isContent(): boolean;
+    /**
+     * Checks if the settings ID is present.
+     * @returns {boolean} True if the settings ID is present, false otherwise.
+     */
+    get isSettings(): boolean;
+    /**
+     * Checks if the security ID is present.
+     * @returns {boolean} True if the security ID is present, false otherwise.
+     */
+    get isSecurity(): boolean;
+    /**
+     * Defines the top bar items.
+     */
+    topBarItems: TopBarDto[];
+    /**
+     * Initializes the component and subscribes to local settings updates.
+     */
+    constructor();
+    /**
+     * Lifecycle hook that is called when a component is destroyed.
+     * Unsubscribes from all subscriptions to prevent memory leaks,
+     * resets the top bar items to an empty array, and sets the active ID
+     * to the ID of the first top bar item (if available).
+     */
+    ngOnDestroy(): void;
+    /**
+     * Initializes the component. Subscribes to translation service to set captions for top bar items,
+     * sets the top bar items via the top bar service, sets the active ID,
+     * subscribes to route parameters to get the ID, and retrieves settings.
+     * @return {Promise<void>} A promise that resolves when the initialization is complete.
+     */
+    ngOnInit(): Promise<void>;
+    /**
+     * Retrieves module instance settings.
+     * @return {Promise<void>} A promise that resolves when settings are retrieved.
+     */
+    getSettings(): Promise<void>;
+    /**
+     * Saves the provided settings to the backend.
+     * @param {TLocalStoreSettings} settings - The settings object to save.
+     * @return {Promise<void>} A promise that resolves when the settings are saved. Reject if an error occurs.
+     */
+    saveSettings(settings: TBackendStoreSettings): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseModuleComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseModuleComponent<any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class SecurityComponent implements OnInit, OnDestroy {
+    private readonly msgService;
+    private readonly dataService;
+    private readonly translateService;
+    securityData: any[];
+    id: number;
+    controller: string;
+    roles: string[];
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    saveClick(): void;
+    saveKeyDown($event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SecurityComponent, "security", never, { "id": { "alias": "id"; "required": false; }; "controller": { "alias": "controller"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface AppConfig {
+    preset?: string;
+    primary?: string;
+    surface?: string | null;
+    darkTheme?: boolean;
+    menuMode?: string;
+    language?: string;
+    dateFormat: string;
+    timeFormat: string;
+    dateTimeFormat: string;
+    timeZone: string;
+}
+interface LayoutState {
+    staticMenuDesktopInactive?: boolean;
+    overlayMenuActive?: boolean;
+    configSidebarVisible?: boolean;
+    staticMenuMobileActive?: boolean;
+    menuHoverActive?: boolean;
+}
+interface MenuChangeEvent$1 {
+    key: string;
+    routeEvent?: boolean;
+}
+declare class LayoutService {
+    _config: AppConfig;
+    _state: LayoutState;
+    layoutConfig: i0.WritableSignal<AppConfig>;
+    layoutState: i0.WritableSignal<LayoutState>;
+    private readonly configUpdate;
+    private readonly overlayOpen;
+    private readonly menuSource;
+    private readonly resetSource;
+    menuSource$: rxjs.Observable<MenuChangeEvent$1>;
+    resetSource$: rxjs.Observable<unknown>;
+    configUpdate$: rxjs.Observable<AppConfig>;
+    overlayOpen$: rxjs.Observable<any>;
+    theme: i0.Signal<"light" | "dark">;
+    isSidebarActive: i0.Signal<boolean>;
+    isDarkTheme: i0.Signal<boolean>;
+    getPrimary: i0.Signal<string>;
+    getSurface: i0.Signal<string>;
+    isOverlay: i0.Signal<boolean>;
+    language: i0.Signal<string>;
+    dateFormat: i0.Signal<string>;
+    primeNgDateFormat: i0.Signal<string>;
+    timeFormat: i0.Signal<string>;
+    dateTimeFormat: i0.Signal<string>;
+    monthFormat: i0.Signal<string>;
+    timeZone: i0.Signal<string>;
+    transitionComplete: i0.WritableSignal<boolean>;
+    private initialized;
+    constructor();
+    /**
+     * Get application settings from browser storage
+     * @returns AppConfig
+     */
+    private getAppConfigFromStorage;
+    private handleDarkModeTransition;
+    private startViewTransition;
+    toggleDarkMode(config?: AppConfig): void;
+    private onTransitionEnd;
+    onMenuToggle(): void;
+    isDesktop(): boolean;
+    isMobile(): boolean;
+    onConfigUpdate(): void;
+    onMenuStateChange(event: MenuChangeEvent$1): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+/**
+ * SecurityService extends OidcSecurityService to manage authentication,
+ * token handling, and user role access in an Angular application.
+ *
+ * It provides helper methods for checking authentication, managing tokens,
+ * determining user roles, and performing logout and refresh operations.
+ */
+declare class SecurityService extends OidcSecurityService implements OnDestroy {
+    /**
+     * Handles angular OIDC events.
+     */
+    private readonly publicEventsService;
+    /**
+     * Stores the latest login response from checkAuth().
+     */
+    loginResponse: BehaviorSubject<LoginResponse>;
+    /**
+     * Stores the decoded access token payload.
+     */
+    payload: BehaviorSubject<any>;
+    /**
+     * Stores user-specific data from the login response.
+     */
+    userData: any;
+    /**
+     * Initializes service and subscribes to authentication events.
+     * When a 'NewAuthenticationResult' event is received, the `auth` method is called.
+     */
+    constructor();
+    /**
+     * Returns the ID token for the sign-in.
+     * @returns A string with the id token.
+     */
+    getAccessToken(): Observable<string>;
+    /**
+     * Indicates whether the current user has the 'admin' role.
+     *
+     * @returns {boolean} True if the user is an admin, false otherwise.
+     */
+    get isAdmin(): boolean;
+    /**
+     * Initiates authentication check and updates login response, user data,
+     * and decoded token payload if authenticated.
+     */
+    auth(): void;
+    /**
+     * Performs logout and clears the local token payload.
+     *
+     * @param {string} [configId] Optional configuration ID for logout.
+     * @param {LogoutAuthOptions} [logoutAuthOptions] Optional logout options.
+     */
+    logout(configId?: string, logoutAuthOptions?: LogoutAuthOptions): void;
+    /**
+     * Completes the BehaviorSubjects when the service is destroyed to avoid memory leaks.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Checks whether the current access token is expired based on the 'exp' claim.
+     *
+     * @returns {Observable<boolean>} Observable that emits true if the token is expired.
+     */
+    isTokenExpired(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityService>;
+}
+
+/**
+ * UserService is responsible for retrieving and handling user-related data,
+ * including the user's photo and short label for avatar display.
+ */
+declare class UserService {
+    private readonly securityService;
+    private readonly baseDataService;
+    constructor();
+    /**
+     * Stores the user's photo as a data URL or binary blob, depending on how it's processed.
+     */
+    photo: any;
+    /**
+     * Indicates whether the user photo has finished loading.
+     */
+    photoLoaded: boolean;
+    /**
+     * Returns a short label composed of the user's initials.
+     * Typically used for avatar display when a photo is unavailable.
+     */
+    get shortLabel(): string;
+    get userName(): string;
+    /**
+     * Initiates an HTTP request to fetch the user's photo based on their email,
+     * and updates the `photo` and `photoLoaded` properties accordingly.
+     */
+    getUserPhoto(): void;
+    /**
+     * Converts a Blob image into a Base64 data URL and stores it in the `photo` property.
+     *
+     * @param image - The image Blob to be converted.
+     */
+    private createImageFromBlob;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+
+declare class AppTopbar {
+    layoutService: LayoutService;
+    items: MenuItem[];
+    securityService: SecurityService;
+    topBarService: TopBarService;
+    userService: UserService;
+    constructor(layoutService: LayoutService);
+    toggleDarkMode(): void;
+    logoutKeyDown($event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTopbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppTopbar, "app-topbar", never, {}, {}, never, never, true, never>;
+}
+
+declare class FooterComponent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "app-footer", never, {}, {}, never, never, true, never>;
+}
+
+/** Data Transfer Object for creating a new module instance */
+interface AddModuleInstanceDto {
+    /** The identifier of the module to create an instance of */
+    moduleId?: number;
+    /** The display label for the module instance */
+    label?: string | null;
+    /** The icon identifier for the module instance (optional) */
+    icon?: string | null;
+    /** The parent module instance identifier (optional) */
+    parentId?: number | null;
+    /** Array of role identifiers that can view this module instance (optional) */
+    viewRoles?: string[] | null;
+}
+/** Data Transfer Object for editing an existing module instance */
+interface EditModuleInstanceDto$1 {
+    /** The identifier of the module instance to edit */
+    moduleInstanceId?: number;
+    /** The updated display label for the module instance */
+    label?: string | null;
+    /** The updated icon identifier for the module instance (optional) */
+    icon?: string | null;
+    /** The updated parent module instance identifier (optional) */
+    parentId?: number | null;
+    /** Updated array of role identifiers that can view this module instance (optional) */
+    viewRoles?: string[] | null;
+}
+/** Represents a key-value pair where the key is an integer and the value is a string. */
+interface IntKeyValueDto {
+    key?: number;
+    value?: string | null;
+}
+/** It module in app */
+interface ModuleDto {
+    /** Id */
+    moduleId?: number;
+    /** Name */
+    name?: string | null;
+    /** Settings */
+    settings?: string | null;
+    /** Securities */
+    moduleSecurities?: ModuleSecurityDto[] | null;
+}
+/** Module Instance Dto */
+interface ModuleInstanceDto {
+    /** Unique identifier for the module instance. */
+    moduleInstanceId?: number;
+    /** Identifier for the module. */
+    moduleId?: number;
+    /** The label for the module instance. */
+    label?: string | null;
+    /** Icon associated with the module instance. see https://primeng.org/icons */
+    icon?: string | null;
+    /** Route link. */
+    routerLink?: string[] | null;
+    /** URL for the module instance. */
+    url?: string | null;
+    /** The target. */
+    target?: string | null;
+    /** Configuration settings for the module instance. */
+    settings?: string | null;
+    /** Child module instances. */
+    items?: ModuleInstanceDto[] | null;
+    /** Securities */
+    securities?: string[] | null;
+}
+/** Module security DTO */
+interface ModuleSecurityDto {
+    /** Right */
+    right?: string | null;
+    /** Role */
+    role?: string | null;
+}
+interface MenuDeleteModuleInstanceParams {
+    /** The unique identifier of the module instance to delete. */
+    id?: number;
+}
+
+interface ContextMenuItemDto {
+    url: any;
+    class: string | string[] | Set<string> | {
+        [p: string]: any;
+    } | null | undefined;
+    command: any;
+    disabled: boolean;
+    fragment: string | undefined;
+    icon: string | string[] | Set<string> | {
+        [p: string]: any;
+    } | null | undefined;
+    items: ContextMenuItemDto[];
+    label: string;
+    preserveFragment: unknown;
+    queryParamsHandling: QueryParamsHandling | null | undefined;
+    routerLink: string;
+    routerLinkActiveOptions: {
+        exact: boolean;
+    } | IsActiveMatchOptions;
+    visible: boolean;
+    skipLocationChange: unknown;
+    queryParams: Params | null | undefined;
+    target: string;
+    state: {
+        [p: string]: any;
+    } | undefined;
+    replaceUrl: unknown;
+    badgeClass: string;
+}
+
+/**
+ * Represents an event triggered when a menu item is clicked.
+ * @interface MenuChangeEvent
+ * @class
+ */
+interface MenuChangeEvent {
+    /**
+     * A string representing a key, used for identification or access.
+     */
+    key: string;
+    /**
+     * Indicates whether a route event has occurred.
+     * @type {boolean}
+     */
+    routeEvent?: boolean;
+    /**
+     * Represents a single item within a context menu.  Contains data necessary to display the item
+     * and execute its associated action.
+     */
+    item: ContextMenuItemDto;
+}
+
+interface EditModuleInstanceDto {
+    moduleInstanceId: number;
+    moduleId: number;
+    parentId: number;
+    label: string;
+    icon: string;
+    viewRoles: string[];
+}
+
+declare class MenuService extends BaseDataService {
+    private readonly menuSource;
+    private readonly resetSource;
+    private readonly titleService;
+    private readonly menuDataService;
+    menuSource$: rxjs.Observable<MenuChangeEvent>;
+    resetSource$: rxjs.Observable<unknown>;
+    contextMenuItem: any;
+    menu: ModuleInstanceDto[];
+    adminMode: boolean;
+    loadMenu(): Promise<void>;
+    /**
+     * Handles changes in the menu state.
+     * @param {MenuChangeEvent} event - The event containing information about the menu state change.
+     * @return {void}
+     */
+    onMenuStateChange(event: MenuChangeEvent): void;
+    reset(): void;
+    getMenu(): Promise<ModuleInstanceDto[]>;
+    getAdminMenu(): Promise<ModuleInstanceDto[]>;
+    getModules(): Promise<IntKeyValueDto[]>;
+    addModuleInstance(addModuleInstance: AddModuleInstanceDto): Promise<void>;
+    deleteItem(moduleInstanceId: number): Promise<unknown>;
+    editModuleInstance(item: EditModuleInstanceDto): Promise<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
+}
+
+type QueryParamsType = Record<string | number, any>;
+type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;
+interface FullRequestParams extends Omit<RequestInit, "body"> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** request cancellation token */
+    cancelToken?: CancelToken;
+}
+type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+type CancelToken = Symbol | string | number;
+declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+declare class HttpClient<SecurityDataType = unknown> {
+    protected securityService: SecurityService;
+    protected layoutService: LayoutService;
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor();
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpClient<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpClient<any>>;
+}
+
+declare class Menu<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
+    /**
+     * @description Retrieves the menu available to the current authenticated user.
+     *
+     * @tags Menu
+     * @name menuGet
+     * @request GET:/api/menu/get
+     * @secure
+     */
+    menuGet: (params?: RequestParams) => Promise<ModuleInstanceDto[]>;
+    /**
+     * @description Retrieves the admin-specific menu.
+     *
+     * @tags Menu
+     * @name menuGetAdminMenu
+     * @request GET:/api/menu/get-admin-menu
+     * @secure
+     */
+    menuGetAdminMenu: (params?: RequestParams) => Promise<ModuleInstanceDto[]>;
+    /**
+     * @description Retrieves all available modules in the system.
+     *
+     * @tags Menu
+     * @name menuGetModules
+     * @request GET:/api/menu/get-modules
+     * @secure
+     */
+    menuGetModules: (params?: RequestParams) => Promise<IntKeyValueDto[]>;
+    /**
+     * @description Adds a new module instance to the system.
+     *
+     * @tags Menu
+     * @name menuAddModuleInstance
+     * @request POST:/api/menu/add-module-instance
+     * @secure
+     */
+    menuAddModuleInstance: (data: AddModuleInstanceDto, params?: RequestParams) => Promise<void>;
+    /**
+     * @description Edits an existing module instance.
+     *
+     * @tags Menu
+     * @name menuEditModuleInstance
+     * @request POST:/api/menu/edit-module-instance
+     * @secure
+     */
+    menuEditModuleInstance: (data: EditModuleInstanceDto$1, params?: RequestParams) => Promise<void>;
+    /**
+     * @description Deletes a module instance by its identifier.
+     *
+     * @tags Menu
+     * @name menuDeleteModuleInstance
+     * @request DELETE:/api/menu/delete-module-instance
+     * @secure
+     */
+    menuDeleteModuleInstance: (query: MenuDeleteModuleInstanceParams, params?: RequestParams) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Menu<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Menu<any>>;
+}
+
+declare class MenuItemCreateDialogComponent implements OnInit {
+    menuService: MenuService;
+    protected readonly menu: Menu<any>;
+    visible: boolean;
+    visibleChange: EventEmitter<boolean>;
+    modules: IntKeyValueDto[];
+    selectModule: any;
+    label: string;
+    selectIcon: string;
+    ngOnInit(): Promise<void>;
+    changeVisible(): void;
+    save(): Promise<void>;
+    hide(): void;
+    showDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemCreateDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemCreateDialogComponent, "menu-item-create-dialog", never, { "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}
+
+declare class MenuItemEditDialogComponent {
+    private readonly menuService;
+    private readonly securityDataService;
+    visible: boolean;
+    visibleChange: EventEmitter<boolean>;
+    modules: any[];
+    roles: string[];
+    item: EditModuleInstanceDto;
+    changeVisible(): void;
+    save(): Promise<void>;
+    hide(): void;
+    showDialog(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemEditDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemEditDialogComponent, "menu-item-edit-dialog", never, { "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}
+
+declare class MenuComponent implements OnInit {
+    readonly menuService: MenuService;
+    readonly securityService: SecurityService;
+    readonly translateService: TranslateService;
+    menuItemCreateDialogComponent: MenuItemCreateDialogComponent;
+    menuItemEditDialogComponent: MenuItemEditDialogComponent;
+    contextMenu: ContextMenu;
+    ngOnInit(): void;
+    private newClick;
+    onContextMenu($event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "app-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarComponent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "app-sidebar", never, {}, {}, never, never, true, never>;
+}
+
+declare class AppLayoutComponent implements OnDestroy {
+    protected layoutService: LayoutService;
+    protected router: Router;
+    protected renderer: Renderer2;
+    overlayMenuOpenSubscription: Subscription;
+    menuOutsideClickListener: () => void;
+    appSidebar: SidebarComponent;
+    appTopBar: AppTopbar;
+    constructor();
+    isOutsideClicked(event: MouseEvent): boolean;
+    hideMenu(): void;
+    blockBodyScroll(): void;
+    unblockBodyScroll(): void;
+    get containerClass(): {
+        'layout-overlay': boolean;
+        'layout-static': boolean;
+        'layout-static-inactive': boolean;
+        'layout-overlay-active': boolean;
+        'layout-mobile-active': boolean;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppLayoutComponent, "app-layout", never, {}, {}, never, never, true, never>;
+}
+
+declare class LogoComponent {
+    width: number;
+    height: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoComponent, "logo", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NotfoundComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotfoundComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotfoundComponent, "app-notfound", never, {}, {}, never, never, true, never>;
+}
+
+declare class UnauthorizedComponent {
+    protected readonly securityService: SecurityService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnauthorizedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UnauthorizedComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class ErrorComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorComponent, "app-error", never, {}, {}, never, never, true, never>;
+}
+
+declare class ProfileComponent {
+    readonly userService: UserService;
+    readonly msgService: MsgService;
+    readonly translateService: TranslateService;
+    onBasicUploadAuto($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileComponent, "user-profile", never, {}, {}, never, never, true, never>;
+}
+
+interface L10n$1 {
+    menu: string;
+    all: string;
+    profile: string;
+    photo: string;
+    usePhoto256x256Pixel: string;
+    selectLanguage: string;
+    moduleManagement: string;
+    localization: string;
+    goTo: string;
+}
+declare class ConfigComponent implements OnInit {
+    private readonly layoutService;
+    private readonly l10nService;
+    protected readonly userService: UserService;
+    protected readonly securityService: SecurityService;
+    protected readonly menuService: MenuService;
+    protected l10n: L10n$1;
+    selectedLanguage: string;
+    languages: SelectItem<string>[];
+    constructor();
+    ngOnInit(): Promise<void>;
+    /**
+     * Changes the application's language.
+     * @return {void}
+     */
+    changeLanguage(): void;
+    onSwitchChange(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigComponent, "app-config", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A data transfer object indicating the absence of settings.
+ */
+interface NoSettingsDto {
+}
+
+interface MigrationDto {
+    name: string;
+    applied: boolean;
+    pending: boolean;
+    exist: boolean;
+}
+interface ApplyMigrationRequest {
+    name: string;
+}
+declare class DbMigrationComponent extends BaseModuleComponent<NoSettingsDto, NoSettingsDto> implements OnInit, OnDestroy {
+    data: MigrationDto[];
+    ngOnInit(): Promise<void>;
+    refreshAction(): Promise<void>;
+    getData(): Promise<MigrationDto[]>;
+    applyMigration(rowData: MigrationDto): Promise<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbMigrationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbMigrationComponent, "db-migration", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Service for managing translation loading in the application
+ */
+declare class L10nService {
+    private loadedTranslations;
+    private httpClient;
+    private translateService;
+    /**
+     * Loads translations for a specific component
+     * @param component - Name of the component to load translations for
+     */
+    loadComponentTranslations(component: string): Promise<void>;
+    /**
+     * Gets the translated value of a key (or an array of keys)
+     * @returns the translated key, or an object of translated keys
+     */
+    get(key: string): Promise<rxjs.Observable<any>>;
+    /**
+     * Internal method to load translations from JSON files
+     * @param component - Component or translation namespace
+     * @param lang - Language code to load translations for
+     */
+    private loadTranslations;
+    /**
+     * Changes the lang currently used
+     */
+    use(selectedLanguage: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<L10nService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<L10nService>;
+}
+
+interface L10n {
+    confirm: {
+        header: string;
+        message: string;
+        cancel: string;
+        delete: string;
+    };
+    title: string;
+    messages: {
+        deleteSuccess: string;
+    };
+    table: {
+        deleteTooltip: string;
+        currentlyLoaded: string;
+        yes: string;
+        no: string;
+        name: string;
+        moduleId: string;
+    };
+    refreshTooltip: string;
+}
+declare class AppModulesComponent implements OnInit {
+    protected dataService: BaseDataService;
+    protected modules: ModuleDto[];
+    protected msgService: MsgService;
+    protected confirmationService: ConfirmationService;
+    protected l10nService: L10nService;
+    protected l10n: L10n;
+    protected titleService: AppTitleService;
+    private moduleService;
+    ngOnInit(): Promise<void>;
+    refreshAction(): Promise<void>;
+    deleteModule(module: ModuleDto): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppModulesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppModulesComponent, "app-modules", never, {}, {}, never, never, true, never>;
+}
+
+interface SecurityDto {
+    code: string;
+    name: string;
+    description: string;
+    roles: string[];
+}
+
+interface PutSecurityDto {
+    id: number;
+    securities: SecurityDto[];
+}
+
+declare class SecurityDataService extends BaseDataService {
+    getSecurity(controller: string, id: number): Promise<SecurityDto[]>;
+    saveSecurity(controller: string, request: PutSecurityDto): Promise<any>;
+    getRealmRoles(): Promise<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityDataService>;
+}
+
+/**
+ * A route guard that ensures the user is authenticated and has a valid access token.
+ * If the access token is expired, it attempts to refresh the session.
+ * If authentication fails or refresh is unsuccessful, redirects to the unauthorized page.
+ */
+declare class AuthGuardService {
+    private readonly oidcSecurityService;
+    private readonly router;
+    /**
+     * Checks whether the route can be activated.
+     * - Returns `true` if the user is authenticated and the token is valid.
+     * - Attempts to refresh the token if expired.
+     * - Redirects to `/unauthorized` if not authenticated or refresh fails.
+     *
+     * @returns {Observable<boolean | UrlTree>} A stream resolving to true (allow), or UrlTree (redirect).
+     */
+    canActivate(): Observable<boolean | UrlTree>;
+    /**
+     * Attempts to refresh the session using the refresh token.
+     * If successful, allows route activation; otherwise, redirects to `/unauthorized`.
+     *
+     * @returns {boolean | UrlTree} A stream resolving to true or redirect UrlTree.
+     */
+    tryRefreshToken(): Observable<boolean | UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuardService>;
+}
+
+declare class SecurityStorageService implements AbstractSecurityStorage {
+    read(key: string): string;
+    write(key: string, value: any): void;
+    remove(key: string): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityStorageService>;
+}
+
+declare const langIntercept: HttpInterceptorFn;
+
+declare class SecurePipe implements PipeTransform {
+    private readonly http;
+    private readonly sanitizer;
+    transform(url: any): Observable<SafeUrl>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecurePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SecurePipe, "secure", true>;
+}
+
+/**
+ * Load keycloak settings from backend and save to sessionStorage
+ * @param httpClient
+ * @returns StsConfigHttpLoader
+ */
+declare const httpLoaderAuthFactory: (httpClient: HttpClient$1) => StsConfigHttpLoader;
+
+export { AppLayoutComponent, AppModulesComponent, AppTopbar, AuthGuardService, BaseDataService, BaseModuleComponent, ConfigComponent, DbMigrationComponent, ErrorComponent, FooterComponent, LayoutService, LogoComponent, MenuComponent, MenuService, MsgService, NotfoundComponent, ProfileComponent, SecurePipe, SecurityComponent, SecurityDataService, SecurityService, SecurityStorageService, SidebarComponent, TopBarService, UnauthorizedComponent, UserService, httpLoaderAuthFactory, langIntercept };
+export type { AppConfig, ApplyMigrationRequest, MenuChangeEvent, MigrationDto, NoSettingsDto, PutSecurityDto, SecurityDto, TopBarDto };