import * as i0 from '@angular/core';
import { Provider, EnvironmentProviders, InjectionToken, TransferState, Type, OnInit, PipeTransform, OnDestroy } from '@angular/core';
import { OpenIdConfiguration, OidcSecurityService, LoginResponse } from 'angular-auth-oidc-client';
import * as i5 from '@angular/router';
import { Routes, CanActivateFn, Router, CanDeactivateFn } from '@angular/router';
import * as _ngrx_signals from '@ngrx/signals';
import * as rxjs from 'rxjs';
import { Observable, OperatorFunction } from 'rxjs';
import * as _open_rlb_ng_app from '@open-rlb/ng-app';
import * as _open_rlb_ng_bootstrap from '@open-rlb/ng-bootstrap';
import { BreadcrumbItem, SidebarNavigableItem, ModalService, ToastService, ModalType, IModal, ModalData, OffcanvasComponent, VisibilityEvent, IToast, ToastData } from '@open-rlb/ng-bootstrap';
import * as _ngrx_store from '@ngrx/store';
import { Store } from '@ngrx/store';
import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import * as i3 from '@ngx-translate/core';
import { TranslateLoader } from '@ngx-translate/core';
import * as i1 from '@angular/common';
import * as i2 from '@angular/forms';
import { FormGroup, FormControl } from '@angular/forms';

declare abstract class AbstractSupportService {
    abstract sendSupport(data: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSupportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractSupportService>;
}

type AppViewMode = 'app' | 'settings';
interface AppInfoData {
    appName?: string;
}
interface AppInfo<T extends AppInfoData = any> {
    id?: string;
    type: string;
    enabled: boolean;
    core?: AppDetails;
    settings?: AppDetails;
    viewMode?: AppViewMode;
    routes?: string[];
    domains?: string[];
    actions?: string[];
    navigationUrl?: string;
    data?: T;
    autoRedirectOnRootEnabled?: boolean;
}
interface AppDetails {
    title: string;
    description: string;
    url: string;
    icon: string;
    auth: boolean;
}

interface AppDescriber<T = any> {
    info: AppInfo;
    routes?: Routes;
    providers?: (Provider | EnvironmentProviders)[];
}

declare class AppsService {
    private readonly store;
    private readonly activatedRoute;
    private readonly router;
    private readonly loggerService;
    private readonly confAuth;
    private readonly confAcl;
    private readonly aclStore;
    private readonly injector;
    private logger;
    constructor();
    readonly currentDomain: string;
    readonly apps: i0.Signal<any>;
    readonly currentApp: i0.Signal<AppInfo<any> | null>;
    readonly currentAppId: i0.Signal<string | undefined>;
    readonly currentAppAclInfo: i0.Signal<{
        busId: any;
        resId: any;
    } | null>;
    isAppSelected(appId: string): boolean;
    checkPermissionInCurrentApp(action?: string): boolean;
    /**
     * Finds the app that owns a given route path string (e.g. 'some-page/sub-page').
     * Used by permissionGuard on initial deep-link navigation, before NavigationEnd has
     * fired and currentApp has been selected by the router listener.
     */
    findAppForPath(path: string): AppInfo | undefined;
    checkPermissionForApp(app: AppInfo, action?: string): boolean;
    selectApp(app?: AppInfo, viewMode?: 'app' | 'settings', url?: string): void;
    private initAuthProviders;
    private initRouterListener;
    private resolveRouteAndApps;
    private handleResolvedApps;
    private findDeepestChild;
    private getStoredAppId;
    private getAppViewMode;
    private isDefaultRoute;
    private getConfigPath;
    private getActualPath;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppsService>;
}

declare class AppBreadcrumbService {
    private readonly router;
    private readonly route;
    private readonly loggerService;
    private readonly languageService;
    private readonly idService;
    private readonly _breadcrumbs;
    readonly breadcrumbs: i0.Signal<BreadcrumbItem[]>;
    /**
     * @deprecated Use `breadcrumbs` (signal-based) instead.
     */
    readonly breadcrumbs$: rxjs.Observable<BreadcrumbItem[]>;
    private logger;
    constructor();
    private updateBreadcrumbs;
    private buildBreadcrumbFromRoot;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppBreadcrumbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppBreadcrumbService>;
}

type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug' | 'log';
type LoggerContext = {
    error: (...args: any[]) => void;
    warn: (...args: any[]) => void;
    info: (...args: any[]) => void;
    debug: (...args: any[]) => void;
    log: (...args: any[]) => void;
};
declare class AppLoggerService {
    private currentLevel;
    private timestamps;
    constructor(environment?: EnvironmentConfiguration);
    setLogLevel(level: LogLevel): void;
    getLogLevel(): LogLevel;
    enableTimestamps(enabled: boolean): void;
    /**
     * returns logger with context / class name
     */
    for(context: string): LoggerContext;
    logError(contextOrMessage: any, ...args: any[]): void;
    logWarning(contextOrMessage: any, ...args: any[]): void;
    logDebug(contextOrMessage: any, ...args: any[]): void;
    logInfo(contextOrMessage: any, ...args: any[]): void;
    log(contextOrMessage: any, ...args: any[]): void;
    private print;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppLoggerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppLoggerService>;
}

declare const appContextFeatureKey = "app";
type AppTheme = 'light' | 'dark';
type PageTemplate = 'app' | 'basic' | 'cms' | 'content';
declare const RLB_APPS: InjectionToken<AppDescriber<any>>;
interface AppContext {
    apps: AppInfo[];
    currentApp: AppInfo | null;
    language: string | null;
    theme: AppTheme;
    supportedLanguages: string[];
}
declare const initialAppContextState: AppContext;
interface AppState {
    [appContextFeatureKey]: AppContext;
}

declare const authsFeatureKey = "auth";
interface Auth {
    currentProvider: string | null;
    loading: boolean;
}
declare const initialAuthState: Auth;
interface AuthState {
    [authsFeatureKey]: Auth;
}

declare const navbarsFeatureKey = "navbar";
type NavbarHeader = {
    type: 'text';
    text: string;
} | {
    type: 'image';
    src: string;
    alt?: string;
    height?: number;
};
type NavbarActionsLayout = 'default' | 'dropdown';
interface Navbar {
    visible: boolean;
    header: NavbarHeader | null;
    searchVisible: boolean;
    searchText: string | null;
    leftItems: string[];
    rightItems: string[];
    loginVisible: boolean;
    settingsVisible: boolean;
    appsVisible: boolean;
    separatorVisible: boolean;
    actionsLayout: NavbarActionsLayout;
}
declare const initialNavbarState: Navbar;
interface NavbarState {
    [navbarsFeatureKey]: Navbar;
}

declare const sidebarsFeatureKey = "sidebar";
interface Sidebar {
    items: SidebarNavigableItem[];
    visible: boolean;
    loginVisible: boolean;
    searchVisible: boolean;
    appsVisible: boolean;
    settingsVisible: boolean;
    searchText: string | null;
    footerComponent: string | null;
}
declare const initialSidebarState: Sidebar;
interface SidebarState {
    [sidebarsFeatureKey]: Sidebar;
}

declare const aclFeatureKey = "acl";
interface UserResource {
    companyId: string;
    resources: Resource[];
}
interface Resource {
    resourceId: string;
    actions: string[];
    friendlyName?: string;
}
interface Acl {
    resources: UserResource[] | null;
    loading: boolean;
    loaded: boolean;
    error: any;
}
declare const initialAclState: Acl;
interface AclState {
    [aclFeatureKey]: Acl;
}

declare const AppContextActionsInternal: {
    setLanguage: _ngrx_store.ActionCreator<"[AppContext/Internal] setLanguage", (props: {
        language: string;
    }) => {
        language: string;
    } & _ngrx_store.Action<"[AppContext/Internal] setLanguage">>;
    setCurrentApp: _ngrx_store.ActionCreator<"[AppContext/Internal] setCurrentApp", (props: {
        app: AppInfo | null;
        mode?: AppViewMode;
        url?: string;
    }) => {
        app: AppInfo | null;
        mode?: AppViewMode;
        url?: string;
    } & _ngrx_store.Action<"[AppContext/Internal] setCurrentApp">>;
    setSupportedLanguages: _ngrx_store.ActionCreator<"[AppContext/Internal] setSupportedLanguages", (props: {
        supportedLanguages: string[];
    }) => {
        supportedLanguages: string[];
    } & _ngrx_store.Action<"[AppContext/Internal] setSupportedLanguages">>;
    setTheme: _ngrx_store.ActionCreator<"[AppContext/Internal] setTheme", (props: {
        theme: AppTheme;
    }) => {
        theme: AppTheme;
    } & _ngrx_store.Action<"[AppContext/Internal] setTheme">>;
    addApp: _ngrx_store.ActionCreator<"[AppContext/Internal] addApp", (props: {
        app: AppInfo;
    }) => {
        app: AppInfo;
    } & _ngrx_store.Action<"[AppContext/Internal] addApp">>;
    setViewMode: _ngrx_store.ActionCreator<"[AppContext/Internal] setViewMode", (props: {
        viewMode?: AppViewMode;
    }) => {
        viewMode?: AppViewMode;
    } & _ngrx_store.Action<"[AppContext/Internal] setViewMode">>;
};
declare const AppContextActions: {
    setLanguage: _ngrx_store.ActionCreator<"[AppContext/API] setLanguage", (props: {
        language: string;
    }) => {
        language: string;
    } & _ngrx_store.Action<"[AppContext/API] setLanguage">>;
    setSupportedLanguages: _ngrx_store.ActionCreator<"[AppContext/API] setSupportedLanguages", (props: {
        supportedLanguages: string[];
    }) => {
        supportedLanguages: string[];
    } & _ngrx_store.Action<"[AppContext/API] setSupportedLanguages">>;
    setCurrentApp: _ngrx_store.ActionCreator<"[AppContext/API] setCurrentApp", (props: {
        app: AppInfo | null;
        mode?: AppViewMode;
        url?: string;
    }) => {
        app: AppInfo | null;
        mode?: AppViewMode;
        url?: string;
    } & _ngrx_store.Action<"[AppContext/API] setCurrentApp">>;
    removeApp: _ngrx_store.ActionCreator<"[AppContext/API] removeApp", (props: {
        appType: string;
    }) => {
        appType: string;
    } & _ngrx_store.Action<"[AppContext/API] removeApp">>;
    setTheme: _ngrx_store.ActionCreator<"[AppContext/API] setTheme", (props: {
        theme: AppTheme;
    }) => {
        theme: AppTheme;
    } & _ngrx_store.Action<"[AppContext/API] setTheme">>;
    finalizeApp: _ngrx_store.ActionCreator<"[AppContext/API] finalizeApp", (props: {
        appType: string;
        appId: string;
        data?: any;
    }) => {
        appType: string;
        appId: string;
        data?: any;
    } & _ngrx_store.Action<"[AppContext/API] finalizeApp">>;
};

declare class AuthFeatureService {
    private store;
    constructor(store: Store);
    login(): void;
    logout(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthFeatureService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthFeatureService>;
}

declare const AuthActionsInternal: {
    setCurrentProvider: _ngrx_store.ActionCreator<"[Auth/Internal] SetCurrentProvider", (props: {
        currentProvider: string;
    }) => {
        currentProvider: string;
    } & _ngrx_store.Action<"[Auth/Internal] SetCurrentProvider">>;
    setLoading: _ngrx_store.ActionCreator<"[Auth/Internal] SetLoading", (props: {
        loading: boolean;
    }) => {
        loading: boolean;
    } & _ngrx_store.Action<"[Auth/Internal] SetLoading">>;
    reset: _ngrx_store.ActionCreator<"[Auth/Internal] Reset", () => _ngrx_store.Action<"[Auth/Internal] Reset">>;
};
declare const AuthActions: {
    login: _ngrx_store.ActionCreator<"[Auth/API] Login", () => _ngrx_store.Action<"[Auth/API] Login">>;
    logout: _ngrx_store.ActionCreator<"[Auth/API] Logout", () => _ngrx_store.Action<"[Auth/API] Logout">>;
    setCurrentProvider: _ngrx_store.ActionCreator<"[Auth/API] SetCurrentProvider", (props: {
        currentProvider: string;
    }) => {
        currentProvider: string;
    } & _ngrx_store.Action<"[Auth/API] SetCurrentProvider">>;
};

declare const NavbarActionsInternal: {};
declare const NavbarActions: {
    setVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetVisible">>;
    setSearchVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetSearchVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetSearchVisible">>;
    setHeader: _ngrx_store.ActionCreator<"[Navbar/API] SetHeader", (props: {
        header: NavbarHeader | null;
    }) => {
        header: NavbarHeader | null;
    } & _ngrx_store.Action<"[Navbar/API] SetHeader">>;
    setSearchText: _ngrx_store.ActionCreator<"[Navbar/API] SetSearchText", (props: {
        text: string | null;
    }) => {
        text: string | null;
    } & _ngrx_store.Action<"[Navbar/API] SetSearchText">>;
    setLeftItems: _ngrx_store.ActionCreator<"[Navbar/API] SetLeftItems", (props: {
        items: string[];
    }) => {
        items: string[];
    } & _ngrx_store.Action<"[Navbar/API] SetLeftItems">>;
    setRightItems: _ngrx_store.ActionCreator<"[Navbar/API] SetRightItems", (props: {
        items: string[];
    }) => {
        items: string[];
    } & _ngrx_store.Action<"[Navbar/API] SetRightItems">>;
    setLoginVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetLoginVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetLoginVisible">>;
    setSettingsVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetSettingsVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetSettingsVisible">>;
    setAppsVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetAppsVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetAppsVisible">>;
    setSeparatorVisible: _ngrx_store.ActionCreator<"[Navbar/API] SetSeparatorVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Navbar/API] SetSeparatorVisible">>;
    setActionsLayout: _ngrx_store.ActionCreator<"[Navbar/API] SetActionsLayout", (props: {
        layout: NavbarActionsLayout;
    }) => {
        layout: NavbarActionsLayout;
    } & _ngrx_store.Action<"[Navbar/API] SetActionsLayout">>;
};

declare const SidebarActionsInternal: {};
declare const SidebarActions: {
    setItems: _ngrx_store.ActionCreator<"[Sidebar/API] SetItems", (props: {
        items: SidebarNavigableItem[];
    }) => {
        items: SidebarNavigableItem[];
    } & _ngrx_store.Action<"[Sidebar/API] SetItems">>;
    setVisible: _ngrx_store.ActionCreator<"[Sidebar/API] SetVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Sidebar/API] SetVisible">>;
    setLoginVisible: _ngrx_store.ActionCreator<"[Sidebar/API] SetLoginVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Sidebar/API] SetLoginVisible">>;
    setAppsVisible: _ngrx_store.ActionCreator<"[Sidebar/API] SetAppsVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Sidebar/API] SetAppsVisible">>;
    setSearchVisible: _ngrx_store.ActionCreator<"[Sidebar/API] SetSearchVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Sidebar/API] SetSearchVisible">>;
    setSettingsVisible: _ngrx_store.ActionCreator<"[Sidebar/API] SetSettingsVisible", (props: {
        visible: boolean;
    }) => {
        visible: boolean;
    } & _ngrx_store.Action<"[Sidebar/API] SetSettingsVisible">>;
    setSearchText: _ngrx_store.ActionCreator<"[Sidebar/API] SetSearchText", (props: {
        text: string | null;
    }) => {
        text: string | null;
    } & _ngrx_store.Action<"[Sidebar/API] SetSearchText">>;
    setFooterComponent: _ngrx_store.ActionCreator<"[Sidebar/API] SetFooterComponent", (props: {
        name: string | null;
    }) => {
        name: string | null;
    } & _ngrx_store.Action<"[Sidebar/API] SetFooterComponent">>;
};

declare const AclStore: i0.Type<{
    resources: i0.Signal<_open_rlb_ng_app.UserResource[] | null>;
    loading: i0.Signal<boolean>;
    loaded: i0.Signal<boolean>;
    error: i0.Signal<any>;
    hasPermission: (busId: string, resId: string, action?: string) => boolean;
    loadACL: (providerAcl?: ProviderAclConfiguration) => rxjs.Observable<_open_rlb_ng_app.UserResource[]>;
    reset: () => void;
} & _ngrx_signals.StateSource<{
    resources: _open_rlb_ng_app.UserResource[] | null;
    loading: boolean;
    loaded: boolean;
    error: any;
}>>;

interface BaseState extends AclState, AuthState, SidebarState, NavbarState, AppState {
}

declare const RLB_INIT_PROVIDER: InjectionToken<RlbInitProvider>;
interface RlbInitProvider {
    finalizeApps(resources: UserResource[], store: Store<BaseState>, acl: AclConfiguration | null): Promise<void>;
}

interface CacheItem<T> {
    data: T;
    expire: number;
}

declare class LocalCacheService {
    private options;
    constructor(options: ProjectConfiguration);
    private clear;
    private readData;
    private storeData;
    getData<T>(ob: Observable<T>, cacheKey: string, expirationSec: number): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalCacheService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocalCacheService>;
}

declare abstract class AbstractMdService {
    constructor();
    abstract md2html(md: string): string;
    abstract md2text(md: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractMdService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractMdService>;
}

declare class StrapiService {
    private http;
    private cache;
    private cmsOptions;
    constructor(http: HttpClient, cache: LocalCacheService, cmsOptions: CmsConfiguration);
    fetchHome(lang: string, cid: string): Observable<Home>;
    fetchTopic(id: string): Observable<Topic>;
    fetchTab(id: string): Observable<Tab>;
    fetchFaqGroup(lang: string, cid: string): Observable<FaqGroup>;
    private _getGuideMenuPromise;
    getGuideMenu(lang: string, cid: string): Observable<MenuItem>;
    fetchPage(lang: string, cid: string): Observable<Page>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StrapiService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StrapiService>;
}

interface MenuItem {
    ContentId: string;
    Order: number;
    Title: string;
    page: Page;
    home: Home;
    menu_items: MenuItem[];
}
interface Home {
    ContentId: string;
    MenuName: string;
    Abstract: string;
    Content: string;
    Picture: any;
    Head: any;
    topics: Topic[];
}
interface Page {
    ContentId: string;
    Title: string;
    Content: string;
    page_tabs: Tab[];
    topics: Topic[];
    Cover: any;
}
interface Topic {
    id: string;
    ContentId: string;
    Title: string;
    Content: string;
    Picture: any;
    page: Page;
}
interface Tab {
    id: string;
    ContentId: string;
    Title: string;
    Icon: string;
    Content: string;
    FaqTitle: string;
    FaqContent: string;
    steps: Step[];
    faqs: Faq[];
}
interface Step {
    ContentId: string;
    Title: string;
    Content: string;
    Picture: any;
}
interface FaqGroup {
    ContentId: string;
    Title: string;
    Content: string;
    faqs: Faq[];
}
interface Faq {
    ContentId: string;
    Title: string;
    Content: string;
    Question: string;
    Answer: string;
}

type ErrorOutput = 'dialog' | 'toast' | 'console';

declare class ErrorManagementService {
    private dialogService;
    private toastService;
    private languageService;
    private options;
    constructor(dialogService: ModalService, toastService: ToastService, languageService: LanguageService, options: ProjectConfiguration);
    showError(type?: ModalType, out?: ErrorOutput, error?: any): Observable<_open_rlb_ng_bootstrap.ToastResult<any> | null> | Observable<{
        reason: string;
    }>;
    showDialog(type: ModalType, error?: Error): Observable<_open_rlb_ng_bootstrap.ModalResult<void>>;
    showToast(type: ModalType, error?: any): Observable<_open_rlb_ng_bootstrap.ToastResult<any> | null>;
    manageUI<T>(type?: ModalType, out?: ErrorOutput): OperatorFunction<T, T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorManagementService, [null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorManagementService>;
}

declare function provideRlbI18n(i18n?: InternationalizationConfiguration): (EnvironmentProviders | Provider)[];

declare class LanguageService {
    private readonly translateService;
    private readonly cookiesService;
    private readonly i18nOptions;
    private readonly _language;
    private readonly _contentLanguage;
    readonly language: i0.Signal<string>;
    readonly contentLanguage: i0.Signal<string | undefined>;
    readonly languageChanged$: rxjs.Observable<i3.LangChangeEvent>;
    readonly contentLanguageChanged: i0.Signal<string | undefined>;
    private readonly _ready$;
    readonly ready$: rxjs.Observable<boolean>;
    constructor();
    get currentLanguage(): string;
    setLanguage(value: string | undefined): void;
    setContentLanguage(value: string | undefined): void;
    get languages(): readonly string[];
    set languages(value: string[]);
    get defaultLanguage(): string;
    get browserLanguage(): string;
    translate(key: string | Array<string>, interpolateParams?: Object): any;
    translateAsync(key: string | Array<string>, interpolateParams?: Object): rxjs.Observable<any>;
    getLanguageName(l: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
}

declare class TranslateBrowserLoader implements TranslateLoader {
    private http;
    private transferState;
    private prefix;
    private suffix;
    constructor(http: HttpClient, transferState: TransferState, prefix?: string, suffix?: string);
    getTranslation(lang: string): Observable<any>;
}
declare function translateBrowserLoaderFactory(httpClient: HttpClient, transferState: TransferState): TranslateBrowserLoader;

declare class AppStorageService {
    readLocal(key: string): string | null;
    writeLocal(key: string, value: any): void;
    removeLocal(key: string): void;
    clearLocal(): void;
    readSession(key: string): string | null;
    writeSession(key: string, value: any): void;
    removeSession(key: string): void;
    clearSession(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppStorageService>;
}

declare class CookiesService {
    getCookie(name: string): string | undefined;
    deleteCookie(name: string): void;
    setCookie(name: string, value: string, expireDays?: number, path?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CookiesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CookiesService>;
}

declare class PwaUpdaterService {
    private readonly updates;
    private readonly modalService;
    private readonly languageService;
    private readonly _newVersionAvailable;
    readonly newVersionAvailable: i0.Signal<boolean>;
    get newVersionAvailable$(): rxjs.Observable<boolean>;
    constructor();
    update(): void;
    checkForUpdates(): Promise<boolean>;
    checkWithDialog(): rxjs.Observable<Promise<void>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PwaUpdaterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PwaUpdaterService>;
}

declare class UtilsService {
    isNumber(evt: any): boolean;
    toPlainDataObject(o: ({
        [k: string]: any;
    } | {
        [k: string]: any;
    }[])): any;
    groupBy<T>(xs: T[], predicate: (o: T) => string): {
        [i: string]: T[];
    };
    private s;
    compareArrayUnsort(a1: any, a2: any): boolean;
    removeMD(md: string, options?: {
        listUnicodeChar?: string;
        stripListLeaders?: boolean;
        useImgAltText?: boolean;
        gfm?: boolean;
    }): string;
    floatStr(input: string | number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
}

declare const RLB_CFG: InjectionToken<ProjectConfiguration<{
    [k: string]: any;
}>>;
declare const RLB_CFG_CMS: InjectionToken<CmsConfiguration>;
declare const RLB_CFG_I18N: InjectionToken<InternationalizationConfiguration>;
declare const RLB_CFG_PAGES: InjectionToken<PagesConfiguration>;
declare const RLB_CFG_ENV: InjectionToken<EnvironmentConfiguration>;
declare const RLB_CFG_AUTH: InjectionToken<AuthConfiguration>;
declare const RLB_APP_NAVCOMP: InjectionToken<NavbarComponents>;
declare const RLB_APP_SIDEBARCOMP: InjectionToken<SidebarComponents>;
declare const RLB_CFG_ACL: InjectionToken<AclConfiguration>;
type AuthUrlHandler = (url: string) => void | Promise<void>;
declare const RLB_AUTH_URL_HANDLER: InjectionToken<AuthUrlHandler>;
interface InterceptorMapping {
    [k: string]: string;
}
interface ProviderAclConfiguration {
    endpointKey: string;
    path: string;
}
interface AclConfiguration {
    interceptorMapping?: InterceptorMapping;
    businessIdKey: string;
    resourceIdKey: string;
}
interface ProviderConfiguration extends OpenIdConfiguration {
    configId: string;
    domains?: string[];
    roleClaim?: (data: any) => string | string[];
    acl?: ProviderAclConfiguration;
}
interface NavbarComponents {
    left: {
        component: Type<any>;
        name: string;
    }[];
    right: {
        component: Type<any>;
        name: string;
    }[];
}
interface SidebarComponents {
    footer: {
        component: Type<any>;
        name: string;
    }[];
}
interface CmsConfiguration {
    endpoint: string;
    chacheDuration: number;
    useAppLanguage: boolean;
    contentLanguages: string[];
    markdown: 'ignore' | 'html' | 'text';
}
interface AuthConfiguration {
    protocol: 'oauth';
    storage: 'cookies' | 'localStorage' | 'sessionStorage';
    interceptor?: 'oauth-code-all' | 'oauth-code-ep' | 'none';
    enableCompanyInterceptor?: boolean;
    allowedUrls: string[];
    providers: ProviderConfiguration[];
}
interface InternationalizationConfiguration {
    availableLangs: string[];
    defaultLanguage: string;
    useLanguageBrowser: boolean;
    storeSelectedLanguage: boolean;
    cookieStoreName: string;
}
interface PagesConfiguration {
    [key: string]: {
        path: string;
    };
}
interface EnvironmentConfiguration {
    appLogo: string;
    appTitle: string;
    navbarDisabled?: boolean;
    baseUrl: string;
    ssr: boolean;
    phone: boolean;
    errorDialogName?: string;
    errorDialogSize?: 'sm' | 'lg' | 'xl' | 'md';
    errorToastName?: string;
    errorToastContainer?: string;
    pwaUpdateEnabled?: boolean;
    logLevel?: LogLevel;
}
interface Endpoint {
    baseUrl: string;
    healthPath: string;
    auth?: boolean;
    wss?: boolean;
}
interface IConfiguration {
    environment?: EnvironmentConfiguration;
    cms?: CmsConfiguration;
    auth?: AuthConfiguration;
    i18n?: InternationalizationConfiguration;
    pages?: PagesConfiguration;
    acl?: AclConfiguration;
    endpoints?: {
        [key: string]: Endpoint;
    };
}
type ProjectConfiguration<T = {
    [k: string]: any;
}> = IConfiguration & {
    production: boolean;
} & T;

declare class RlbRole {
    private appsService;
    private templateRef;
    private viewContainer;
    action: i0.InputSignal<string | undefined>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<RlbRole, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RlbRole, "[roles]", never, { "action": { "alias": "roles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const oauthGuard: CanActivateFn;

declare const permissionGuard: CanActivateFn;

declare const oauthPasswordGuard: CanActivateFn;

declare class ParseJwtService {
    private _atob;
    parseJwt(token?: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParseJwtService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ParseJwtService>;
}

declare class AdminApiService {
    private httpClient;
    private config;
    private aclConfig;
    constructor(httpClient: HttpClient, config: ProjectConfiguration, aclConfig: AclConfiguration);
    resourcesByUser$(endpointKey: string, path: string): Observable<UserResource[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminApiService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AdminApiService>;
}

declare class AuthenticationService {
    private oidcSecurityService;
    private cookiesService;
    private router;
    private readonly parseJwtService;
    private readonly store;
    private readonly log;
    private readonly localStorage;
    private readonly adminApi;
    private envConfig;
    private authConfig;
    private appconfig;
    private authUrlHandler;
    modal: Window | null;
    private logger;
    private readonly aclStore;
    private readonly _authReady$;
    readonly authReady$: Observable<void>;
    private readonly _authenticated$;
    readonly authenticated$: Observable<void>;
    constructor(oidcSecurityService: OidcSecurityService, cookiesService: CookiesService, router: Router, parseJwtService: ParseJwtService, store: Store<BaseState>, log: AppLoggerService, localStorage: AppStorageService, adminApi: AdminApiService, envConfig: EnvironmentConfiguration, authConfig: AuthConfiguration, appconfig: IConfiguration, authUrlHandler: AuthUrlHandler | null);
    get oidc(): OidcSecurityService;
    get config(): AuthConfiguration;
    get currentProvider(): _open_rlb_ng_app.ProviderConfiguration | undefined;
    checkAuthMultiple(url?: string | undefined): Observable<LoginResponse[]>;
    login(targetUrl?: string): void;
    private get electronUrlHandler();
    logout(): Promise<void>;
    logout$(): Observable<unknown>;
    get userInfo$(): Observable<any>;
    get isAuthenticated$(): Observable<boolean>;
    get accessToken$(): Observable<string | undefined>;
    get idToken$(): Observable<string | undefined>;
    get refreshToken$(): Observable<string | undefined>;
    get roles$(): Observable<string[]>;
    matchRoles(roles: string[]): Observable<boolean>;
    private handleRedirect;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, [null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationService>;
}

interface Token {
    access_token: string | null;
    expires_in: number;
    token_type: string;
    scope: string;
    id_token: string | null;
    refresh_token: string | null;
}
declare class OauthPasswordService implements HttpInterceptor {
    private readonly httpClient;
    private readonly authenticationService;
    private readonly log;
    private timer;
    private _onUpdateToken;
    private logger;
    constructor(httpClient: HttpClient, authenticationService: AuthenticationService, log: AppLoggerService);
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    private get access_token();
    private set access_token(value);
    private get refresh_token();
    private set refresh_token(value);
    get accessToken(): string | null;
    set onUpdateToken(v: ((token: string | null) => void) | null);
    login(username: string, password: string): Promise<Token>;
    loggedIn(): boolean;
    logout(): void;
    private _login;
    private _refreshToken;
    private initRefreshToken;
    static ɵfac: i0.ɵɵFactoryDeclaration<OauthPasswordService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OauthPasswordService>;
}

declare class TokenOauthInterceptor implements HttpInterceptor {
    private authenticationService;
    private appconfig;
    constructor(authenticationService: AuthenticationService, appconfig: IConfiguration);
    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TokenOauthInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TokenOauthInterceptor>;
}

interface UserClaims {
    exp?: number;
    iat?: number;
    auth_time?: number;
    jti?: string;
    iss?: string;
    aud?: string;
    sub?: string;
    typ?: string;
    azp?: string;
    nonce?: string;
    session_state?: string;
    at_hash?: string;
    acr?: string;
    email_verified?: boolean;
    name?: string;
    preferred_username?: string;
    locale?: string;
    given_name?: string;
    family_name?: string;
    email?: string;
    picture?: string;
}

interface JwtUser {
    email: string;
    email_verified: boolean;
    family_name: string;
    given_name: string;
    name: string;
    preferred_username: string;
    sub: string;
    [key: string]: string | number | boolean;
}

declare function provideRlbCodeBrowserOAuth(auth: AuthConfiguration | undefined): EnvironmentProviders;

interface KeycloakUser {
    attributes: {};
    email: string;
    emailVerified: boolean;
    firstName: string;
    id: string;
    lastName: string;
    userProfileMetadata: {
        attributes: {
            name: string;
            displayName: string;
            multivalued: boolean;
            required: boolean;
            readOnly: boolean;
            validators: {
                [key: string]: any;
            }[];
        }[];
        groups: {
            name: string;
            displayHeader: string;
            displayDescription: string;
        }[];
    };
    username: string;
}

interface KeycloakDevice {
    os: string;
    osVersion: string;
    device: string;
    lastAccess: number;
    current: boolean;
    sessions: KeycloakSession[];
    mobile: boolean;
}
interface KeycloakSession {
    id: string;
    ipAddress: string;
    started: number;
    expires: number;
    clients: KeycloakClient[];
    browser: string;
    os: string;
    osVersion: string;
    device: string;
    lastAccess: number;
    current: boolean;
    mobile: boolean;
    clientslist: string;
}
interface KeycloakClient {
    clientId: string;
    clientName: string;
    userConsentRequired: boolean;
    inUse: boolean;
    offlineAccess: boolean;
}

interface KeycloakCredential {
    type: string;
    category: string;
    displayName: string;
    helptext: string;
    iconCssClass: string;
    updateAction?: string;
    removeable: boolean;
    userCredentialMetadatas: KeycloakUserCredentialMetadata[];
    createAction?: string;
}
interface KeycloakUserCredentialMetadata {
    credential: _KeycloakCredential;
}
interface _KeycloakCredential {
    id: string;
    type: string;
    userLabel: string;
    createdDate: number;
    credentialData: string;
}

declare class KeycloakProfileService {
    private http;
    private readonly authService;
    private readonly errorManagementService;
    private readonly oidcSecurityService;
    constructor(http: HttpClient, authService: AuthenticationService, errorManagementService: ErrorManagementService, oidcSecurityService: OidcSecurityService);
    private get baseUrl();
    getUserProfile(): Observable<KeycloakUser>;
    updateUserProfile(data: KeycloakUser): Observable<void>;
    getDevices(): Observable<KeycloakSession[]>;
    getCredentials(): Observable<KeycloakCredential[]>;
    removeCredential(id: string): Observable<void>;
    configureOTP(): void;
    updatePassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeycloakProfileService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KeycloakProfileService>;
}

interface VerifyDeactivate {
    verifyDeactivate: () => boolean | Observable<boolean>;
}
declare const verifyDeactivate: CanDeactivateFn<VerifyDeactivate>;

declare class ErrorModalComponent implements IModal<string, void>, OnInit {
    data: i0.InputSignal<ModalData<any>>;
    valid: i0.ModelSignal<boolean>;
    onEnter(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorModalComponent, "ng-component", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; }, { "valid": "validChange"; }, never, never, true, [{ directive: typeof _open_rlb_ng_bootstrap.ModalDirective; inputs: { "id": "id"; "data-instance": "data-instance"; "data-options": "data-options"; }; outputs: {}; }]>;
}

declare class ModalAppsComponent implements IModal<AppInfo[], AppInfo> {
    data: i0.InputSignal<ModalData<any>>;
    valid: i0.ModelSignal<boolean>;
    result?: any;
    apps: AppInfo[];
    appSelected(app: AppInfo): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalAppsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalAppsComponent, "ng-component", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; }, { "valid": "validChange"; }, never, never, true, [{ directive: typeof _open_rlb_ng_bootstrap.ModalDirective; inputs: { "id": "id"; "data-instance": "data-instance"; "data-options": "data-options"; }; outputs: {}; }]>;
}

declare function getDefaultRoutes(config?: PagesConfiguration): Routes;

declare class AsMultiPipe implements PipeTransform {
    transform<T>(value: T | T[]): T[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AsMultiPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AsMultiPipe, "asMulti", true>;
}
declare class AsSinglePipe implements PipeTransform {
    transform<T>(value: T | T[]): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<AsSinglePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AsSinglePipe, "asSingle", true>;
}

declare class CmsPipe implements PipeTransform {
    private cmsOptions;
    transform(value: string, ...args: unknown[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CmsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CmsPipe, "cms", true>;
}

declare class LeftComponentPipe implements PipeTransform {
    private config;
    transform(value: string): Type<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LeftComponentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LeftComponentPipe, "leftComponent", true>;
}

declare class RightComponentPipe implements PipeTransform {
    private config;
    transform(value: string): Type<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RightComponentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RightComponentPipe, "rightComponent", true>;
}

declare class SidebarFooterComponentPipe implements PipeTransform {
    private config;
    transform(value: string): Type<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarFooterComponentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SidebarFooterComponentPipe, "sidebarFooterComponent", true>;
}

declare class TruncatePipe implements PipeTransform {
    transform(value?: string, limit?: number, completeWords?: boolean, ellipsis?: string): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
}

declare class AutolinkPipe implements PipeTransform {
    transform(value?: string, target?: string, rel?: string, id?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutolinkPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AutolinkPipe, "autolink", true>;
}

declare class AppContainerComponent {
    protected readonly Array: ArrayConstructor;
    private readonly templateSubject;
    readonly modalContainerId: i0.InputSignal<string>;
    readonly toastContainerIds: i0.InputSignal<string | string[]>;
    private readonly env;
    private readonly store;
    private readonly router;
    private readonly storage;
    private readonly pwaUpdaterService;
    private readonly appsService;
    private readonly loggerService;
    private readonly logger;
    constructor();
    get template$(): rxjs.Observable<PageTemplate>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppContainerComponent, "rlb-app-container", never, { "modalContainerId": { "alias": "modal-container-id"; "required": true; "isSignal": true; }; "toastContainerIds": { "alias": "toast-container-ids"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SettingsDropdownSelectorComponent implements OnDestroy {
    mode: i0.InputSignal<"desktop" | "mobile">;
    apps: i0.InputSignal<AppInfo<any>[]>;
    isAuthenticated: i0.InputSignal<boolean | null>;
    appSelected: i0.OutputEmitterRef<AppInfo<any>>;
    activeSlide: number;
    private readonly pageOptions;
    private readonly store;
    private readonly languageService;
    private readonly toastService;
    private readonly router;
    private readonly menu;
    private appsService;
    readonly pages: i0.Signal<PagesConfiguration | null>;
    readonly languages: i0.Signal<{
        value: string;
        label: string;
    }[]>;
    readonly currentLanguage: i0.Signal<string | null>;
    readonly darkMode: i0.Signal<boolean>;
    readonly currentAppId: i0.Signal<string | undefined>;
    constructor();
    setCurrentLanguage(value: any): void;
    setDarkMode(value: boolean): void;
    selectApp(app: AppInfo): void;
    goToFirstSlide(): void;
    goToInlineSettings(): void;
    logout(): void;
    ngOnDestroy(): void;
    change(event: any): void;
    isAppSelected(appId: string | undefined): boolean;
    private close;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsDropdownSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsDropdownSelectorComponent, "rlb-settings-dropdown-selector", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "apps": { "alias": "apps"; "required": true; "isSignal": true; }; "isAuthenticated": { "alias": "isAuthenticated"; "required": true; "isSignal": true; }; }, { "appSelected": "appSelected"; }, never, never, true, never>;
}

declare class AppTemplateComponent {
    protected readonly Array: ArrayConstructor;
    navSearchText: string | null;
    readonly modalContainerId: i0.InputSignal<string>;
    readonly breadcrumbInput: i0.InputSignal<BreadcrumbItem[] | undefined>;
    readonly breadcrumb: i0.Signal<BreadcrumbItem[]>;
    readonly toastContainerIds: i0.InputSignal<string | string[]>;
    readonly mobileOffcanvas: i0.Signal<OffcanvasComponent | undefined>;
    readonly mobileSettingsMenu: i0.Signal<SettingsDropdownSelectorComponent | undefined>;
    readonly env: _open_rlb_ng_app.EnvironmentConfiguration;
    readonly store: Store<any>;
    readonly appsService: AppsService;
    private readonly authService;
    private readonly router;
    readonly sidebarVisible: i0.Signal<boolean>;
    readonly sidearHasLogin: i0.Signal<boolean>;
    readonly sidearHasSearch: i0.Signal<boolean>;
    readonly sidebarItems: i0.Signal<SidebarNavigableItem[]>;
    readonly sidebarFooter: i0.Signal<string | null>;
    readonly sidearHasSettings: i0.Signal<boolean>;
    readonly sidearAppsVisible: i0.Signal<boolean>;
    readonly navVisible: i0.Signal<boolean>;
    readonly navSearchVisible: i0.Signal<boolean>;
    readonly navHeader: i0.Signal<_open_rlb_ng_app.NavbarHeader | null>;
    readonly navLeftItems: i0.Signal<string[]>;
    readonly navRightItems: i0.Signal<string[]>;
    readonly navbarHasLogin: i0.Signal<boolean>;
    readonly navbarHasSettings: i0.Signal<boolean>;
    readonly navbarHasApps: i0.Signal<any>;
    readonly navbarLayout: i0.Signal<any>;
    readonly separatorVisible: i0.Signal<any>;
    readonly isAuthenticated: i0.Signal<boolean>;
    readonly userInfo: i0.Signal<any>;
    readonly theme: i0.Signal<any>;
    readonly apps: i0.Signal<any>;
    constructor();
    loginNav(event: MouseEvent): void;
    onSideBarItemClick(item: SidebarNavigableItem): void;
    selectApp(app: AppInfo, viewMode: 'app' | 'settings'): void;
    onMobileMenuStatusChange(event: VisibilityEvent): void;
    setSidearSearchText(text: string | null): void;
    setNavbarSearchText(text: string | null): void;
    private closeMobileMenu;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppTemplateComponent, "rlb-app-template", never, { "modalContainerId": { "alias": "modal-container-id"; "required": true; "isSignal": true; }; "breadcrumbInput": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; "toastContainerIds": { "alias": "toast-container-ids"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class BaseComponent {
    private readonly breakpointObserver;
    private readonly platformId;
    readonly breadcrumbInput: i0.InputSignal<BreadcrumbItem[] | undefined>;
    readonly breadcrumb: i0.Signal<BreadcrumbItem[]>;
    readonly title: i0.InputSignal<string>;
    readonly subtitle: i0.InputSignal<string | undefined>;
    readonly isHandset: i0.Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseComponent, "rlb-base-template", never, { "breadcrumbInput": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; }, {}, never, ["[all]", "[default]", "[mobile]"], true, never>;
}

declare class CmsComponent {
    private readonly strapiService;
    private readonly languageService;
    private readonly cmsOptions;
    private readonly mdService;
    readonly contentId: i0.InputSignal<string | undefined>;
    readonly breadcrumbInput: i0.InputSignal<BreadcrumbItem[] | undefined>;
    readonly breadcrumb: i0.Signal<BreadcrumbItem[]>;
    readonly page: i0.Signal<_open_rlb_ng_app.Page | undefined>;
    md(md: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CmsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CmsComponent, "rlb-cms-template", never, { "contentId": { "alias": "contentId"; "required": false; "isSignal": true; }; "breadcrumbInput": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ContentComponent {
    private readonly breakpointObserver;
    private readonly platformId;
    readonly isHandset: i0.Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContentComponent, "rlb-content-template", never, {}, {}, never, ["[all]", "[default]", "[mobile]"], true, never>;
}

declare class ToastComponent implements IToast<string, void> {
    data: i0.InputSignal<ToastData<any>>;
    valid?: boolean;
    result?: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "ng-component", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _open_rlb_ng_bootstrap.ToastDirective; inputs: { "id": "id"; "data-instance": "data-instance"; "data-options": "data-options"; }; outputs: {}; }]>;
}

declare class CmsContentComponent {
    private readonly route;
    readonly contentId: i0.Signal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CmsContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CmsContentComponent, "rlb-cms-content", never, {}, {}, never, never, true, never>;
}

declare class CookiesComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CookiesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CookiesComponent, "rlb-cookies", never, {}, {}, never, never, true, never>;
}

declare class NotFoundComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotFoundComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotFoundComponent, "rlb-not-found", never, {}, {}, never, never, true, never>;
}

declare class PrivacyComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivacyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrivacyComponent, "rlb-privacy", never, {}, {}, never, never, true, never>;
}

declare class SupportComponent implements OnInit {
    private readonly supportService;
    private readonly _location;
    readonly supportForm: FormGroup<{
        name: FormControl<string | null>;
        email: FormControl<string | null>;
        subject: FormControl<string | null>;
        message: FormControl<string | null>;
        legal: FormControl<string | null>;
    }>;
    hasError(form: string, controlName: string, errorName: string): boolean | undefined;
    sendSupport(data: any): void;
    backClicked(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SupportComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SupportComponent, "rlb-support", never, {}, {}, never, never, true, never>;
}

declare class TermsAndConditionsComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TermsAndConditionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TermsAndConditionsComponent, "rlb-terms-and-conditions", never, {}, {}, never, never, true, never>;
}

declare class ForbiddenComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ForbiddenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ForbiddenComponent, "rlb-forbidden", never, {}, {}, never, never, true, never>;
}

declare class AppDropdownSelectorComponent {
    mode: i0.InputSignal<"desktop" | "mobile">;
    apps: i0.InputSignal<AppInfo<any>[]>;
    isAuthenticated: i0.InputSignal<boolean | null>;
    appSelected: i0.OutputEmitterRef<AppInfo<any>>;
    private appsService;
    readonly currentAppId: i0.Signal<string | undefined>;
    selectApp(app: AppInfo): void;
    isAppSelected(appId: string | undefined): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppDropdownSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppDropdownSelectorComponent, "rlb-app-dropdown-selector", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "apps": { "alias": "apps"; "required": true; "isSignal": true; }; "isAuthenticated": { "alias": "isAuthenticated"; "required": true; "isSignal": true; }; }, { "appSelected": "appSelected"; }, never, never, true, never>;
}

declare class RlbAppModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RlbAppModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RlbAppModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.TranslateModule, typeof _open_rlb_ng_bootstrap.RlbBootstrapModule, typeof i5.RouterModule, typeof CmsContentComponent, typeof CookiesComponent, typeof NotFoundComponent, typeof PrivacyComponent, typeof SupportComponent, typeof TermsAndConditionsComponent, typeof ForbiddenComponent, typeof CmsPipe, typeof AsMultiPipe, typeof AsSinglePipe, typeof LeftComponentPipe, typeof RightComponentPipe, typeof TruncatePipe, typeof AutolinkPipe, typeof BaseComponent, typeof CmsComponent, typeof ContentComponent, typeof AppTemplateComponent, typeof AppContainerComponent, typeof SettingsDropdownSelectorComponent, typeof AppDropdownSelectorComponent, typeof RlbRole], [typeof CmsPipe, typeof AsMultiPipe, typeof AsSinglePipe, typeof LeftComponentPipe, typeof RightComponentPipe, typeof TruncatePipe, typeof AutolinkPipe, typeof BaseComponent, typeof CmsComponent, typeof ContentComponent, typeof AppTemplateComponent, typeof AppContainerComponent, typeof i3.TranslateModule, typeof _open_rlb_ng_bootstrap.RlbBootstrapModule, typeof i5.RouterModule, typeof i2.FormsModule, typeof RlbRole]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RlbAppModule>;
}

declare function provideRlbConfig<T = {
    [k: string]: any;
}>(env: ProjectConfiguration<T>): (EnvironmentProviders | Provider)[];
declare function provideApp(app: AppDescriber): (EnvironmentProviders | Provider)[];

export { AbstractMdService, AbstractSupportService, AclStore, AppBreadcrumbService, AppContainerComponent, AppContextActions, AppContextActionsInternal, AppLoggerService, AppStorageService, AppTemplateComponent, AppsService, AsMultiPipe, AsSinglePipe, AuthActions, AuthActionsInternal, AuthFeatureService, AuthenticationService, AutolinkPipe, BaseComponent, CmsComponent, CmsPipe, ContentComponent, CookiesService, ErrorManagementService, ErrorModalComponent, KeycloakProfileService, LanguageService, LeftComponentPipe, LocalCacheService, ModalAppsComponent, NavbarActions, NavbarActionsInternal, OauthPasswordService, ParseJwtService, PwaUpdaterService, RLB_APPS, RLB_APP_NAVCOMP, RLB_APP_SIDEBARCOMP, RLB_AUTH_URL_HANDLER, RLB_CFG, RLB_CFG_ACL, RLB_CFG_AUTH, RLB_CFG_CMS, RLB_CFG_ENV, RLB_CFG_I18N, RLB_CFG_PAGES, RLB_INIT_PROVIDER, RightComponentPipe, RlbAppModule, RlbRole, SidebarActions, SidebarActionsInternal, SidebarFooterComponentPipe, StrapiService, ToastComponent, TokenOauthInterceptor, TranslateBrowserLoader, TruncatePipe, UtilsService, aclFeatureKey, appContextFeatureKey, authsFeatureKey, getDefaultRoutes, initialAclState, initialAppContextState, initialAuthState, initialNavbarState, initialSidebarState, navbarsFeatureKey, oauthGuard, oauthPasswordGuard, permissionGuard, provideApp, provideRlbCodeBrowserOAuth, provideRlbConfig, provideRlbI18n, sidebarsFeatureKey, translateBrowserLoaderFactory, verifyDeactivate };
export type { Acl, AclConfiguration, AclState, AppContext, AppDescriber, AppDetails, AppInfo, AppInfoData, AppState, AppTheme, AppViewMode, Auth, AuthConfiguration, AuthState, AuthUrlHandler, BaseState, CacheItem, CmsConfiguration, Endpoint, EnvironmentConfiguration, ErrorOutput, Faq, FaqGroup, Home, IConfiguration, InterceptorMapping, InternationalizationConfiguration, JwtUser, KeycloakClient, KeycloakCredential, KeycloakDevice, KeycloakSession, KeycloakUser, KeycloakUserCredentialMetadata, LogLevel, LoggerContext, MenuItem, Navbar, NavbarActionsLayout, NavbarComponents, NavbarHeader, NavbarState, Page, PageTemplate, PagesConfiguration, ProjectConfiguration, ProviderAclConfiguration, ProviderConfiguration, Resource, RlbInitProvider, Sidebar, SidebarComponents, SidebarState, Step, Tab, Token, Topic, UserClaims, UserResource, VerifyDeactivate, _KeycloakCredential };