@openmfp/portal-ui-lib 0.0.0 → 0.182.3

package/index.d.ts

@@ -0,0 +1,1071 @@
+import * as i0 from '@angular/core';
+import { Type, EnvironmentProviders } from '@angular/core';
+import { Context } from '@luigi-project/client';
+import { HttpHeaders, HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ActivatedRoute, RouteReuseStrategy, ActivatedRouteSnapshot, DetachedRouteHandle } from '@angular/router';
+
+declare enum AuthEvent {
+    AUTH_SUCCESSFUL = "AuthSuccessful",
+    AUTH_ERROR = "AuthError",
+    AUTH_EXPIRED = "AuthExpired",
+    AUTH_REFRESHED = "AuthRefreshed",
+    AUTH_EXPIRE_SOON = "AuthExpireSoon",
+    AUTH_CONFIG_ERROR = "AuthConfigError",
+    LOGOUT = "Logout"
+}
+
+interface PortalContext extends Record<string, any> {
+}
+interface EntityContext extends Record<string, any> {
+}
+interface LuigiGlobalContext extends Record<string, any> {
+    portalContext: PortalContext;
+    userId: string;
+    userEmail: string;
+    token: string;
+    portalBaseUrl: string;
+}
+interface NodeContext extends LuigiGlobalContext {
+    entityContext?: EntityContext;
+    parentNavigationContexts?: string[];
+    error?: {
+        code: number;
+        errorComponentConfig?: Record<string, any>;
+        entityDefinition?: EntityDefinition;
+        additionalContext?: Record<string, any>;
+    };
+    translationTable?: Record<string, any>;
+    serviceProviderConfig?: Record<string, any>;
+}
+
+interface LuigiNavigationConfig {
+    nodes?: LuigiNode[];
+    viewGroupSettings?: any;
+    appSwitcher?: any;
+    globalContext?: any;
+    profile?: any;
+    addNavHrefs?: boolean;
+    contextSwitcher?: any;
+    nodeAccessibilityResolver?: any;
+    validWebcomponentUrls?: string;
+    intentMapping?: any;
+    nodeChangeHook?: any;
+    breadcrumbs?: any;
+}
+interface LuigiStaticSettings extends Record<string, any> {
+    header: {
+        title: string;
+        logo: string;
+        favicon?: string;
+    };
+    btpToolLayout?: boolean;
+    experimental?: {
+        webcomponents?: boolean;
+        globalNav?: boolean;
+        profileMenuFiori3?: boolean;
+        navHeader?: boolean;
+        breadcrumbs?: boolean;
+        globalSearchCentered?: boolean;
+        btpToolLayout?: boolean;
+    };
+    links?: {
+        title: string;
+        link: string;
+    }[];
+}
+interface LuigiConfig {
+    auth?: any;
+    routing?: any;
+    settings?: LuigiStaticSettings;
+    lifecycleHooks?: any;
+    navigation?: LuigiNavigationConfig;
+    userSettings?: any;
+    communication?: any;
+    globalSearch?: any;
+}
+interface LuigiCustomMessage extends Record<string, any> {
+    id: string;
+}
+interface EntityDefinition {
+    id: string;
+    dynamicFetchId?: string;
+    contextKey?: string;
+    useBack?: boolean;
+    label?: string;
+    pluralLabel?: string;
+    notFoundConfig?: {
+        entityListNavigationContext: string;
+        sapIllusSVG: string;
+    };
+    graphqlEntity?: {
+        group: 'string';
+        kind: 'string';
+        query: 'string';
+    };
+}
+interface LuigiStatusBadge {
+    label: string;
+    type: string;
+}
+interface LuigiUserSetting {
+    type: string;
+    label?: string;
+    style?: string;
+    description?: string;
+    options?: string[];
+    isEditable?: boolean;
+}
+interface LuigiUserSettingsGroup {
+    label?: string;
+    sublabel?: string;
+    title?: string;
+    icon?: string;
+    viewUrl?: string;
+    settings?: Record<string, LuigiUserSetting>;
+}
+interface LuigiUserSettings {
+    groups: Record<string, LuigiUserSettingsGroup>;
+}
+interface LuigiNodeIFramePermissions {
+    allow?: string[];
+    sandbox?: string[];
+}
+interface PortalLuigiNodeExtensions {
+    _userSettingsConfig?: LuigiUserSettings;
+    _preloadUrl?: string;
+    _requiredIFramePermissionsForViewGroup?: LuigiNodeIFramePermissions;
+    _portalDirectChildren?: LuigiNode[];
+    _intentMappings?: LuigiIntent[];
+    _entityRelativePaths?: Record<string, any>;
+    _entityRootChild?: boolean;
+    hideFromBreadcrumb?: boolean;
+    breadcrumbBadge?: BreadcrumbBadge;
+    entityType?: string;
+    requiredPolicies?: string[];
+    visibleForEntityContext?: Record<string, any>;
+    visibleForContext?: string;
+    visibleForPlugin?: boolean;
+    configurationMissing?: string;
+    networkVisibility?: NetworkVisibility;
+    isMissingMandatoryData?: boolean;
+    extensionClassName?: string;
+    defineEntity?: EntityDefinition;
+    order?: string;
+    dxpOrder?: string;
+    navSlot?: string;
+    defineSlot?: string;
+    configurationHint?: string;
+    configurationLink?: string;
+    requiredIFramePermissions?: LuigiNodeIFramePermissions;
+}
+interface LuigiNodeCategory {
+    label: string;
+    collapsible?: boolean;
+    order?: number;
+    id?: string;
+    icon?: string;
+}
+interface HelpContext {
+    displayName?: string;
+    issueTracker?: {
+        url: string;
+    };
+    feedbackTracker?: {
+        url: string;
+    };
+    stackSearch?: {
+        tags: string[];
+    };
+    documentation?: {
+        url: string;
+    };
+}
+interface LuigiIntent {
+    baseEntityId?: string;
+    relativePath?: string;
+    semanticObject: string;
+    action: string;
+    pathSegment?: string;
+}
+interface LuigiBadgeCounter {
+    label: string;
+    count: () => Promise<number | string> | number | string;
+}
+interface LuigiNode extends PortalLuigiNodeExtensions {
+    testId?: string;
+    pathSegment?: string;
+    viewUrl?: string;
+    viewGroup?: string;
+    label?: string;
+    icon?: string;
+    link?: string;
+    urlSuffix?: string;
+    navHeader?: any;
+    hideFromNav?: boolean;
+    hideSideNav?: boolean;
+    virtualTree?: boolean;
+    initialRoute?: any;
+    openNodeInModal?: any;
+    navigationContext?: string;
+    showBreadcrumbs?: boolean;
+    loadingIndicator?: {
+        enabled: boolean;
+    };
+    target?: IntentSpecification;
+    compound?: any;
+    badgeCounter?: LuigiBadgeCounter;
+    category?: LuigiNodeCategory | string;
+    context?: NodeContext;
+    visibleForFeatureToggles?: string[];
+    statusBadge?: LuigiStatusBadge;
+    onNodeActivation?: (node: LuigiNode) => boolean;
+    isolateView?: boolean;
+    webcomponent?: {
+        selfRegistered: boolean;
+    };
+    children?: LuigiNode[] | {
+        (context?: any): Promise<LuigiNode[]>;
+    } | {
+        (context?: any): LuigiNode[];
+    };
+    titleResolver?: any;
+    globalNav?: boolean;
+    parent?: LuigiNode;
+}
+interface IntentSpecification {
+    type: string;
+    inboundId: string;
+    resolvedIntent?: LuigiIntent;
+}
+declare enum NetworkVisibility {
+    INTERNAL = "internal",
+    INTERNET = "internet"
+}
+interface BreadcrumbBadge {
+    text: string;
+    colorSchema?: BreadcrumbBadgeColorSchema;
+    hint?: string;
+}
+type BreadcrumbBadgeColorSchema = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10';
+
+interface LuigiNodeDefaults {
+    entityType?: string;
+    isolateView?: boolean;
+}
+interface Dictionary {
+    locale: string;
+    textDictionary: Record<string, string>;
+}
+interface LuigiAppConfig {
+    urlTemplateParams: Record<string, any>;
+    navMode?: string;
+    urlTemplateId?: string;
+}
+interface ViewGroup {
+    preloadSuffix?: string;
+    requiredIFramePermissions?: LuigiNodeIFramePermissions;
+}
+interface LuigiConfigData {
+    viewGroup?: ViewGroup;
+    nodeDefaults?: LuigiNodeDefaults;
+    nodes: LuigiNode[];
+    texts?: Dictionary[];
+    targetAppConfig?: Record<string, any>;
+    userSettings?: LuigiUserSettings;
+}
+interface LuigiConfigFragment {
+    data: LuigiConfigData;
+}
+interface ContentConfiguration {
+    name: string;
+    creationTimestamp?: string;
+    url?: string;
+    luigiConfigFragment: LuigiConfigFragment;
+}
+
+declare enum EntityType {
+    GLOBAL = "global",
+    GLOBAL_TOPNAV = "global.topnav",
+    ENTITY_ERROR = "entity.error"
+}
+
+interface AuthTokenData {
+    expires_in: string;
+    access_token: string;
+    id_token: string;
+}
+interface AuthData {
+    accessTokenExpirationDate: number;
+    idToken: string;
+}
+interface ClientEnvironment extends Record<string, any> {
+    idpName: string;
+    baseDomain: string;
+    oauthServerUrl: string;
+    clientId: string;
+    isLocal: boolean;
+    developmentInstance: boolean;
+    validWebcomponentUrls?: string;
+    authData: AuthTokenData;
+    uiOptions?: string[];
+}
+
+interface SceneConfig {
+    scene: SceneConfigData;
+}
+interface SceneConfigData {
+    url: string;
+    id: string;
+}
+interface ButtonConfig {
+    url?: string;
+    label?: string;
+    route?: {
+        context: string;
+    };
+}
+
+interface ErrorComponentConfig {
+    sceneConfig?: SceneConfig;
+    illustratedMessageTitle?: string;
+    illustratedMessageText?: string;
+    buttons?: ButtonConfig[];
+}
+
+interface Config {
+    url?: string;
+    data?: ContentConfiguration;
+}
+interface LocalDevelopmentSettings {
+    isActive: boolean;
+    configs: Config[];
+    serviceProviderConfig: Record<string, string>;
+}
+
+interface ServiceProvider {
+    name: string;
+    displayName: string;
+    creationTimestamp: string;
+    nodes: LuigiNode[];
+}
+interface EntityConfig {
+    providers: ServiceProvider[];
+    entityContext: Record<string, any>;
+}
+interface PortalConfig {
+    providers: ServiceProvider[];
+    portalContext: PortalContext;
+    featureToggles: Record<string, boolean>;
+}
+
+interface UserData {
+    name: string;
+    email: string;
+    description: string;
+    picture: string;
+    icon: boolean;
+    initials: string;
+    userId: string;
+}
+interface UserTokenData {
+    first_name: string;
+    last_name: string;
+    given_name: string;
+    family_name: string;
+    mail: string;
+    email: string;
+    sub: string;
+}
+
+declare class LuigiCoreService {
+    setConfig(config: LuigiConfig): any;
+    get config(): LuigiConfig;
+    getConfigValue(key: string): any;
+    unloadConfig(): any;
+    sendCustomMessage(customMessage: LuigiCustomMessage): any;
+    configChanged(scope?: string): void;
+    customMessages(): any;
+    navigation(): any;
+    resetLuigi(): void;
+    clearNavigationCache(): void;
+    showAlert(alert: any): any;
+    ux(): any;
+    theming(): any;
+    i18n(): any;
+    globalSearch(): any;
+    getGlobalContext(): LuigiGlobalContext;
+    getWcExtendedContext(): Record<string, any>;
+    getWcModalExtendedContext(): Record<string, any>;
+    setGlobalContext(globalContext: Record<string, any>, preventUpdate?: boolean): void;
+    setInGlobalContext(context: Record<string, any>, preventUpdate?: boolean): void;
+    routing(): any;
+    setFeatureToggle(featureToggleName: string): void;
+    unsetFeatureToggle(featureToggleName: string): void;
+    unsetAllFeatureToggles(): void;
+    setFeatureToggles(featureToggles: Record<string, boolean>): void;
+    isFeatureToggleActive(ft: string): boolean;
+    getActiveFeatureToggleList(): string[];
+    setAuthData(authData: AuthData): void;
+    removeAuthData(): void;
+    getAuthData(): AuthData | undefined;
+    setCurrentLocale(language: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuigiCoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuigiCoreService>;
+}
+
+declare class GlobalContextConfigService {
+    private authService;
+    private configService;
+    private luigiExtendedGlobalContextConfigService;
+    getGlobalContext(): Promise<LuigiGlobalContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalContextConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalContextConfigService>;
+}
+
+declare class RequestHeadersService {
+    private luigiCoreService;
+    private route;
+    constructor(luigiCoreService: LuigiCoreService, route: ActivatedRoute);
+    createOptionsWithAuthHeader(): {
+        headers: HttpHeaders;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestHeadersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestHeadersService>;
+}
+
+declare class ConfigService {
+    private http;
+    private requestHeadersService;
+    private portalConfigCachePromise;
+    private entityConfigCache;
+    constructor(http: HttpClient, requestHeadersService: RequestHeadersService);
+    getPortalConfig(): Promise<PortalConfig>;
+    reloadConfig(entity: string, context?: Record<string, string>): Promise<void>;
+    getEntityConfig(entity: string, context?: Record<string, string>): Promise<EntityConfig>;
+    clearEntityConfigCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+
+declare class AuthService {
+    private http;
+    private authEventSubject;
+    private authData;
+    constructor(http: HttpClient);
+    get authEvents(): Observable<AuthEvent>;
+    authEvent(event: AuthEvent): void;
+    refresh(): Promise<AuthTokenData | undefined>;
+    private setAuthData;
+    getAuthData(): AuthData;
+    private parseJwt;
+    getToken: () => any;
+    private getUser;
+    getUserInfo(): UserData;
+    private processExpDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+declare class EnvConfigService {
+    private http;
+    private envConfigCache;
+    getEnvConfig(): Promise<ClientEnvironment>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnvConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnvConfigService>;
+}
+
+interface ValidationError {
+    message: string;
+}
+interface ValidationResult {
+    parsedConfiguration?: string;
+    validationErrors?: ValidationError[];
+    url: string;
+}
+interface TransformResult {
+    nodes?: LuigiNode[];
+    errors?: ValidationResult[];
+}
+
+declare class LocalNodesService {
+    private http;
+    private luigiCoreService;
+    getLuigiNodesFromConfigurations(contentConfigurations: ContentConfiguration[]): Promise<TransformResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalNodesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalNodesService>;
+}
+
+declare class SessionRefreshService {
+    private authService;
+    private luigiCoreService;
+    private navigationGlobalContextConfigService;
+    constructor(authService: AuthService, luigiCoreService: LuigiCoreService, navigationGlobalContextConfigService: GlobalContextConfigService);
+    refresh(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionRefreshService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionRefreshService>;
+}
+
+declare class I18nService {
+    private envConfigService;
+    private luigiCoreService;
+    fallbackLanguage: string;
+    translationTable: any;
+    currentLanguage: string;
+    afterInit(): void;
+    /**
+     * get translation synchronously. If nothing is found for current locale try to get tranlsation for fallback language
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns returns translated search key or search key, if nothing matched
+     */
+    getTranslation(key: string, interpolations?: Record<string, string>, locale?: string): string;
+    /**
+     * Get translation asynchronously (especially for logout and theming translation in user settings dialog).
+     * If nothing is found for current locale try to get translation for fallback language
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns returns translated search key or search key, if nothing matched
+     */
+    getTranslationAsync(key: string, interpolations?: Record<string, string>, locale?: string): Promise<string>;
+    /**
+     * Finds the translated value based on given key.
+     *
+     * @param key key to be translated
+     * @param translationTable translation table
+     * @param locale current language
+     * @param interpolations in translation table
+     * @returns translation value
+     */
+    findTranslation(key: string, translationTable: any, locale: string, interpolations?: Record<string, string>): any;
+    /**
+     * Replaces values that are defined in translation strings
+     *
+     * @param value to be translated
+     * @param interpolations in translation table
+     * @returns interpolation
+     * @example
+     * findInterpolations('Environment {num}', {num: 1})
+     */
+    findInterpolations(value: string, interpolations: Record<string, string>): string;
+    /**
+     * wraps fetched translation table to a specific locale
+     *
+     * @param locale current language
+     * @param data translation json object for specific locale
+     */
+    addTranslationFile(locale: string, data: Record<string, string>): void;
+    /**
+     * fetch generated translation json files
+     *
+     * @param locale current language
+     * @returns translationTable for a specific language
+     */
+    fetchTranslationFile(locale: string): Promise<unknown>;
+    /**
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns tranlsated search key or search key, if nothing matched
+     */
+    private getInternalTranslation;
+    getValidLanguages(): Promise<{
+        value: string;
+        label: string;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<I18nService>;
+}
+
+declare enum LoginEventType {
+    LOGIN_TRIGGERED = "LoginTriggered",
+    LOGOUT_TRIGGERED = "LogoutTriggered"
+}
+interface LoginEvent {
+    type: LoginEventType;
+    queryParams?: Record<string, any>;
+}
+declare class LoginEventService {
+    private events;
+    get loginEvents(): Observable<LoginEvent>;
+    loginEvent(event: LoginEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginEventService>;
+}
+
+interface UserSettings {
+    frame_userAccount?: any;
+    frame_appearance?: any;
+    frame_development?: any;
+    frame_versions?: any;
+    frame_featureToggle?: any;
+}
+interface UserSettingsValues {
+    frame_userAccount?: {
+        name: string;
+        email: string;
+        language: string;
+    };
+    frame_appearance?: {
+        selectedTheme: string;
+    };
+    frame_development?: {
+        localDevelopmentSettings: LocalDevelopmentSettings;
+    };
+    frame_versions?: any;
+    frame_featureToggle?: {
+        featureToggleSettings: Record<string, boolean>;
+    };
+}
+declare class UserSettingsConfigService {
+    private luigiThemingService;
+    private authService;
+    private i18nService;
+    private luigiCoreService;
+    private dependenciesVersionsService;
+    private envConfigService;
+    private versionsConfig;
+    getUserSettings(childrenByEntity: Record<string, LuigiNode[]>): Promise<{
+        userSettingsProfileMenuEntry: {
+            label: string;
+        };
+        userSettingsDialog: {
+            dismissBtn: string;
+            saveBtn: string;
+            dialogHeader: string;
+        };
+        userSettingGroups: {
+            frame_userAccount?: any;
+            frame_appearance?: any;
+            frame_development?: any;
+            frame_versions?: any;
+            frame_featureToggle?: any;
+        };
+        readUserSettings: () => Promise<any>;
+        storeUserSettings: (settings: UserSettingsValues, previous: UserSettingsValues) => Promise<void>;
+    }>;
+    private getCoreUserSettingsGroups;
+    private saveFeatureToggleSettings;
+    private saveLocalDevelopmentSettings;
+    private extractUserSettings;
+    private changeToSelectedLanguage;
+    private applyNewTheme;
+    private getGroupsFromUserSettings;
+    private getSelectedThemeDisplayName;
+    private addThemingSettings;
+    private addLocalDevelopmentSettings;
+    private addUserSettings;
+    private addInfoSettings;
+    private addFeatureToggleSettings;
+    private readDependenciesVersions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingsConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingsConfigService>;
+}
+
+declare enum LocalStorageKeys {
+    LAST_NAVIGATION_URL = "openmfp.navigation.lastUrl",
+    USER_SETTINGS = "openmfp.settings.userSettings",
+    LOCAL_DEVELOPMENT_SETTINGS = "openmfp.settings.localDevelopmentSettings",
+    FEATURE_TOGGLE_SETTINGS = "openmfp.settings.featureToggleSettings",
+    DEVELOPMENT_MODE_CONFIG = "dev-mode-settings"
+}
+declare const localDevelopmentSettingsLocalStorage: {
+    read: (localStorageKey?: string) => LocalDevelopmentSettings;
+    store: (localDevelopmentSetting: LocalDevelopmentSettings) => void;
+};
+declare const userSettingsLocalStorage: {
+    read: (userInfo: UserData) => Promise<UserSettingsValues>;
+    store: (settings: UserSettingsValues) => Promise<UserSettingsValues>;
+};
+declare const featureToggleLocalStorage: {
+    read: () => Record<string, boolean>;
+    store: (featureToggleSettings: Record<string, boolean>) => void;
+};
+
+interface Theme {
+    id: string;
+    name: string;
+    description: string;
+}
+interface ThemingService {
+    applyTheme(id: string, reset?: boolean): void;
+    getDefaultThemeId(): string;
+    getAvailableThemes(): Theme[];
+}
+
+interface StaticSettingsConfigService {
+    getStaticSettingsConfig(): Promise<LuigiStaticSettings>;
+}
+declare class StaticSettingsConfigServiceImpl implements StaticSettingsConfigService {
+    private customStaticSettingsConfigService;
+    private i18nService;
+    private iframeService;
+    getStaticSettingsConfig(): Promise<LuigiStaticSettings>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StaticSettingsConfigServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StaticSettingsConfigServiceImpl>;
+}
+
+/**
+ * A representation of a custom message listener and the custom message the listener listens on.
+ * See also {@link https://docs.luigi-project.io/docs/communication/?section=luigi-client-to-luigi-core}
+ */
+interface CustomMessageListener {
+    /**
+     * The custom message id the listener is registered for.
+     */
+    messageId(): string;
+    /**
+     * The callback to be executed when the custom message is send by Luigi.
+     *
+     * @param customMessage The message object, see also {@link https://docs.luigi-project.io/docs/luigi-client-api?section=sendcustommessage}
+     * @param mfObject The micro frontend object, see also {@link https://docs.luigi-project.io/docs/luigi-core-api?section=getmicrofrontends}
+     * @param mfNodesObject The nodes object of the micro frontend, see also {@link https://docs.luigi-project.io/docs/navigation-parameters-reference?section=node-parameters}
+     */
+    onCustomMessageReceived(customMessage: any, mfObject: any, mfNodesObject: any): void;
+}
+
+interface ReloadLuigiConfigMessage {
+    origin: string;
+    action: string;
+    id: string;
+    entity: string;
+    context: Record<string, any>;
+}
+declare class ReloadLuigiConfigListener implements CustomMessageListener {
+    private configService;
+    private luigiCoreService;
+    messageId(): string;
+    onCustomMessageReceived(customMessage: ReloadLuigiConfigMessage, mfObject: any, mfNodesObject: any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReloadLuigiConfigListener, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReloadLuigiConfigListener>;
+}
+
+interface MessageListener {
+    (msg: any, mf: any, mfNodes: any): void;
+}
+interface MessageListeners {
+    customMessagesListeners: Record<string, MessageListener>;
+}
+/**
+ * This class holds the customMessageListeners for custom messages used by the application portal.
+ * See also {@link https://docs.luigi-project.io/docs/communication/?section=luigi-core-to-luigi-client}
+ * See also {@link https://docs.luigi-project.io/docs/luigi-core-api/?section=custommessages}
+ */
+declare class CustomMessageListenersService {
+    private messageListeners;
+    private customMessageListeners;
+    private readonly listeners;
+    constructor(messageListeners: ReloadLuigiConfigListener, customMessageListeners: CustomMessageListener[]);
+    /**
+     * An object containing the property 'listeners' in which the message-id and listener assignments are made.
+     * See also {@link https://docs.luigi-project.io/docs/communication/?section=luigi-core-to-luigi-client}
+     */
+    getMessageListeners(): MessageListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomMessageListenersService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomMessageListenersService>;
+}
+
+interface GlobalSearchConfigService {
+    getGlobalSearchConfig(): any;
+}
+
+interface AppSwitcherConfigService {
+    getAppSwitcher(luigiNodes: LuigiNode[]): any;
+}
+interface NodeConfig {
+    title: string;
+    icon: string;
+    link: string;
+    selectionConditions?: {
+        route: string;
+        contextCriteria: {
+            key: string;
+            value: string;
+        }[];
+    };
+}
+declare class AppSwitcherConfigServiceImpl implements AppSwitcherConfigService {
+    private luigiCoreService;
+    private nodeUtilsService;
+    getAppSwitcher(luigiNodes: LuigiNode[]): {
+        keepMainTitle: boolean;
+        showSubTitle: boolean;
+        itemRenderer: (item: any, slot: HTMLElement, appSwitcherApiObj: any) => void;
+        items: NodeConfig[];
+    };
+    private getNodeItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSwitcherConfigServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppSwitcherConfigServiceImpl>;
+}
+
+interface ExternalLink {
+    sameWindow: boolean;
+    URL: string;
+}
+interface OpenNodeInModal {
+    title?: string;
+    size?: 's' | 'm' | 'l';
+    width?: string;
+    height?: string;
+}
+interface UserProfileItem {
+    label?: string;
+    icon?: string;
+    link?: string;
+    openNodeInModal?: boolean | OpenNodeInModal;
+    externalLink?: ExternalLink;
+}
+interface UserProfile {
+    logout?: UserProfileItem;
+    items: UserProfileItem[];
+}
+interface UserProfileConfigService {
+    getProfile(): Promise<UserProfile>;
+}
+
+declare class IframeService {
+    private luigiCoreService;
+    private isIFrameFeaturePolicyAllowed;
+    private isIFrameSandboxPermissionAllowed;
+    iFrameCreationInterceptor(): (iframe: any, viewGroup: string, navigationNode: any, microFrontendType: any) => void;
+    private applyIframePermissions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IframeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IframeService>;
+}
+
+interface NodeItem extends LuigiNode {
+    node?: LuigiNode;
+    route?: string;
+}
+interface LuigiBreadcrumb {
+    pendingItemLabel: string;
+    omitRoot: boolean;
+    autoHide: boolean;
+    clearBeforeRender?: boolean;
+    renderer: (containerElement: HTMLElement, nodeItems: NodeItem[], clickHandler: (item: NodeItem) => void) => HTMLElement;
+}
+type RendererFn = LuigiBreadcrumb['renderer'];
+interface HeaderBarConfig extends Omit<LuigiBreadcrumb, 'renderer'> {
+    rightRenderers: RendererFn[];
+    leftRenderers: RendererFn[];
+}
+interface HeaderBarConfigService {
+    getConfig(): Promise<HeaderBarConfig>;
+}
+declare class HeaderBarService {
+    private headerBarConfig;
+    constructor(headerBarConfig: HeaderBarConfigService);
+    getConfig(): Promise<LuigiBreadcrumb | undefined>;
+    private setParrentStyles;
+    private executeRenderes;
+    private createRendererContainers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderBarService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeaderBarService>;
+}
+
+interface NodeChangeHookConfigService {
+    nodeChangeHook(prevNode: LuigiNode, nextNode: LuigiNode): void;
+}
+
+interface LuigiAuthEventsCallbacksService {
+    onAuthSuccessful: (settings: any, authData: any) => void;
+    onAuthError: (settings: any, err: any) => void;
+    onAuthExpired: (settings: any) => void;
+    onLogout: (settings: any) => void;
+    onAuthExpireSoon: (settings: any) => void;
+    onAuthConfigError: (settings: any, err: any) => void;
+}
+
+declare class AuthConfigService {
+    private authService;
+    private envConfigService;
+    private luigiAuthEventsCallbacksService;
+    getAuthConfig(): Promise<{
+        use: string;
+        storage: string;
+        oAuth2AuthCode: {
+            idpProvider: any;
+            authorizeUrl: string;
+            logoutUrl: string;
+            post_logout_redirect_uri: string;
+            oAuthData: {
+                client_id: string;
+                scope: string;
+                redirect_uri: string;
+                response_type: string;
+            };
+            accessTokenExpiringNotificationTime: number;
+            expirationCheckInterval: number;
+            userInfoFn: () => Promise<unknown>;
+        };
+        disableAutoLogin: boolean;
+        events: {
+            onAuthSuccessful: (settings: any, authData: any) => void;
+            onAuthError: (settings: any, err: any) => void;
+            onAuthExpired: (settings: any) => void;
+            onLogout: (settings: any) => void;
+            onAuthExpireSoon: (settings: any) => void;
+            onAuthConfigError: (settings: any, err: any) => void;
+        };
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthConfigService>;
+}
+
+interface LocalConfigurationService {
+    getLocalNodes(): Promise<LuigiNode[]>;
+}
+declare class LocalConfigurationServiceImpl {
+    private http;
+    private luigiConfigService;
+    private i18nService;
+    private luigiCoreService;
+    private customLocalConfigurationService;
+    private cachedLocalNodes;
+    getLocalNodes(): Promise<LuigiNode[]>;
+    addLocalDevelopmentModeOnIndicator(): void;
+    private alertErrors;
+    replaceServerNodesWithLocalOnes(serverLuigiNodes: LuigiNode[], currentEntities: string[]): Promise<LuigiNode[]>;
+    private logNodesState;
+    private localNodeMatchesServerNode;
+    private getLocalConfigurations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalConfigurationServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalConfigurationServiceImpl>;
+}
+
+declare class LuigiNodesService {
+    private i18nService;
+    private configService;
+    private localConfigurationService;
+    private errorComponentConfig;
+    private getChildrenByEntity;
+    retrieveChildrenByEntity(): Promise<Record<string, LuigiNode[]>>;
+    retrieveEntityChildren(entityDefinition: EntityDefinition, additionalContext?: Record<string, string>): Promise<LuigiNode[]>;
+    private createErrorNodes;
+    nodePolicyResolver(nodeToCheckPermissionFor: any): boolean;
+    clearNodeCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuigiNodesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuigiNodesService>;
+}
+
+interface LuigiExtendedGlobalContextConfigService {
+    createLuigiExtendedGlobalContext(): Promise<Record<string, any>>;
+}
+
+interface CustomGlobalNodesService {
+    getCustomGlobalNodes(): Promise<LuigiNode[]>;
+}
+
+interface CustomNodeProcessingService {
+    processNode(ctx: Context, node: LuigiNode): Promise<LuigiNode>;
+}
+
+declare class NodeUtilsService {
+    private luigiCoreService;
+    constructor(luigiCoreService: LuigiCoreService);
+    retrieveGlobalHelpContext(): (node: LuigiNode) => boolean;
+    isVisible(node: LuigiNode): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeUtilsService>;
+}
+
+interface NodeContextProcessingService {
+    processNodeContext(entityId: string, entityNode: LuigiNode, ctx: NodeContext): Promise<void>;
+}
+
+interface RoutingConfigService {
+    getInitialRoutingConfig?(): object;
+    getRoutingConfig?(): object;
+}
+declare class RoutingConfigServiceImpl implements RoutingConfigService {
+    private customRoutingConfigService;
+    getInitialRoutingConfig(): any;
+    getRoutingConfig(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingConfigServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoutingConfigServiceImpl>;
+}
+
+interface PortalOptions {
+    /** Service containing and providing the luigi settings configuration **/
+    staticSettingsConfigService?: Type<StaticSettingsConfigService>;
+    /** A set of class representing custom listeners **/
+    customMessageListeners?: Type<CustomMessageListener>[];
+    /** Service providing local configuration services **/
+    localConfigurationService?: Type<LocalConfigurationService>;
+    /** Service providing user setting specific configuration **/
+    userSettingsConfigService?: Type<UserSettingsConfigService>;
+    /** Service providing global search configuration **/
+    globalSearchConfigService?: Type<GlobalSearchConfigService>;
+    /** Service providing luigi app switcher configuration **/
+    appSwitcherConfigService?: Type<AppSwitcherConfigService>;
+    /** Service providing luigi node extended context configuration **/
+    luigiExtendedGlobalContextConfigService?: Type<LuigiExtendedGlobalContextConfigService>;
+    /** Service providing custom global level nodes **/
+    customGlobalNodesService?: Type<CustomGlobalNodesService>;
+    /** Service providing custom global level nodes **/
+    nodeContextProcessingService?: Type<NodeContextProcessingService>;
+    /** Service providing luigi user profile configuration **/
+    userProfileConfigService?: Type<UserProfileConfigService>;
+    /** Provide a config that contains renderers for Nav Bar */
+    headerBarConfigService?: Type<HeaderBarConfigService>;
+    /** Service providing custom global level nodes **/
+    nodeChangeHookConfigService?: Type<NodeChangeHookConfigService>;
+    /** Service handling every node access policies **/
+    customNodeProcessingService?: Type<CustomNodeProcessingService>;
+    /** Service handling luigi authentication events **/
+    luigiAuthEventsCallbacksService?: Type<LuigiAuthEventsCallbacksService>;
+    /** Provide a error configuration for error component to override the default values **/
+    errorComponentConfig?: Record<string, ErrorComponentConfig>;
+    /** Provide a error configuration for error component to override the default values **/
+    themingService?: Type<ThemingService>;
+    /** Service providing luigi routing configuration **/
+    routingConfigService?: Type<RoutingConfigService>;
+}
+declare function providePortal(options?: PortalOptions): EnvironmentProviders;
+
+declare const ERROR_COMPONENT_CONFIG = "OPENMFP_ERROR_COMPONENT_CONFIG";
+declare const THEMING_SERVICE = "OPENMFP_THEMING_SERVICE";
+declare const LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_STATIC_SETTINGS_CONFIG_SERVICE";
+declare const LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN = "OPENMFP_LUIGI_CUSTOM_MESSAGE_LISTENERS";
+declare const LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE";
+declare const LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_APP_SWITCHER_CONFIG_SERVICE";
+declare const LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_USER_PROFILE_CONFIG_SERVICE";
+declare const LUIGI_BREADCRUMB_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_BREADCRUMB_CONFIG_SERVICE";
+declare const LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_NODE_CHANGE_HOOK_CONFIG_SERVICE";
+declare const LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_NODES_EXTENDED_CONTEXT_SERVICE";
+declare const LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN = "OPENMFP_LOCAL_CONFIGURATION_SERVICE";
+declare const LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_NODES_CUSTOM_GLOBAL_SERVICE";
+declare const LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_CUSTOM_NODE_PROCESSING_SERVICE";
+declare const LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE";
+declare const LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE";
+declare const HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_HEADER_BAR_CONFIG_SERVICE";
+declare const LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN = "OPENMFP_LUIGI_ROUTING_CONFIG_SERVICE";
+
+declare class PortalComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PortalComponent, "app-portal", never, {}, {}, never, never, true, never>;
+}
+
+declare class CustomReuseStrategy implements RouteReuseStrategy {
+    shouldDetach(route: ActivatedRouteSnapshot): boolean;
+    store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle | null): void;
+    shouldAttach(route: ActivatedRouteSnapshot): boolean;
+    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+}
+
+/**
+ * Evaluates the JMESPath expression on the context and returns true if the result is true, otherwise false
+ * @param context The context to evaluate
+ * @param jmesPathExpression The JMESPath expression to evaluate
+ * @returns true if the result of the JMESPath expression is true, otherwise (or if there was an exception while matching with JMESPath) false
+ * */
+declare function matchesJMESPath(context: object, jmesPathExpression: string): boolean;
+
+export { AppSwitcherConfigServiceImpl, AuthConfigService, AuthEvent, AuthService, ConfigService, CustomMessageListenersService, CustomReuseStrategy, ERROR_COMPONENT_CONFIG, EntityType, EnvConfigService, GlobalContextConfigService, HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN, HeaderBarService, I18nService, IframeService, LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN, LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN, LUIGI_BREADCRUMB_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN, LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN, LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN, LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN, LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN, LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN, LocalConfigurationServiceImpl, LocalNodesService, LocalStorageKeys, LoginEventService, LoginEventType, LuigiCoreService, LuigiNodesService, NetworkVisibility, NodeUtilsService, PortalComponent, RequestHeadersService, RoutingConfigServiceImpl, SessionRefreshService, StaticSettingsConfigServiceImpl, THEMING_SERVICE, UserSettingsConfigService, featureToggleLocalStorage, localDevelopmentSettingsLocalStorage, matchesJMESPath, providePortal, userSettingsLocalStorage };
+export type { AppSwitcherConfigService, AuthData, AuthTokenData, BreadcrumbBadge, BreadcrumbBadgeColorSchema, ButtonConfig, ClientEnvironment, Config, ContentConfiguration, CustomGlobalNodesService, CustomMessageListener, CustomNodeProcessingService, Dictionary, EntityConfig, EntityContext, EntityDefinition, ErrorComponentConfig, ExternalLink, GlobalSearchConfigService, HeaderBarConfig, HeaderBarConfigService, HelpContext, IntentSpecification, LocalConfigurationService, LocalDevelopmentSettings, LoginEvent, LuigiAppConfig, LuigiAuthEventsCallbacksService, LuigiBadgeCounter, LuigiBreadcrumb, LuigiConfig, LuigiConfigData, LuigiConfigFragment, LuigiCustomMessage, LuigiExtendedGlobalContextConfigService, LuigiGlobalContext, LuigiIntent, LuigiNavigationConfig, LuigiNode, LuigiNodeCategory, LuigiNodeDefaults, LuigiNodeIFramePermissions, LuigiStaticSettings, LuigiStatusBadge, LuigiUserSetting, LuigiUserSettings, LuigiUserSettingsGroup, MessageListener, MessageListeners, NodeChangeHookConfigService, NodeContext, NodeContextProcessingService, NodeItem, OpenNodeInModal, PortalConfig, PortalContext, PortalLuigiNodeExtensions, PortalOptions, RendererFn, RoutingConfigService, SceneConfig, SceneConfigData, ServiceProvider, StaticSettingsConfigService, Theme, ThemingService, UserData, UserProfile, UserProfileConfigService, UserProfileItem, UserSettings, UserSettingsValues, UserTokenData, ViewGroup };