@open-rlb/ng-app 3.0.0

package/index.d.ts

@@ -0,0 +1,1156 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, Provider, EnvironmentProviders, EventEmitter, TransferState, OnInit, TemplateRef, ViewContainerRef, PipeTransform, OnDestroy } from '@angular/core';
+import { OpenIdConfiguration, AbstractLoggerService, OidcSecurityService, LoginResponse } from 'angular-auth-oidc-client';
+import * as i22 from '@angular/router';
+import { Routes, ActivatedRoute, Router, CanActivateFn, CanDeactivateFn } from '@angular/router';
+import * as _open_rlb_ng_app from '@open-rlb/ng-app';
+import * as _ngrx_store from '@ngrx/store';
+import { Store } from '@ngrx/store';
+import * as rxjs from 'rxjs';
+import { Observable, OperatorFunction } from 'rxjs';
+import * as _open_rlb_ng_bootstrap from '@open-rlb/ng-bootstrap';
+import { SidebarNavigableItem, BreadcrumbItem, ModalService, ToastService, ModalType, IModal, ModalData, NavigableItem, IToast, ToastData } from '@open-rlb/ng-bootstrap';
+import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i20 from '@ngx-translate/core';
+import { TranslateService, TranslateLoader } from '@ngx-translate/core';
+import { SwUpdate } from '@angular/service-worker';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import * as i19 from '@angular/forms';
+import { FormGroup } from '@angular/forms';
+import * as i18 from '@angular/common';
+import { Location } from '@angular/common';
+
+declare const RLB_CFG = "rlb.options";
+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>;
+interface ProviderConfiguration extends OpenIdConfiguration {
+    configId: string;
+    domains?: string[];
+    roleClaim?: (data: any) => string | string[];
+}
+interface NavbarComponents {
+    left: {
+        component: Type<any>;
+        name: string;
+    }[];
+    right: {
+        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';
+    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;
+}
+interface Endpoint {
+    baseUrl: string;
+    healthPath: string;
+    auth?: boolean;
+    wss?: boolean;
+}
+interface IConfiguration {
+    environment?: EnvironmentConfiguration;
+    cms?: CmsConfiguration;
+    auth?: AuthConfiguration;
+    i18n?: InternationalizationConfiguration;
+    pages?: PagesConfiguration;
+    endpoints?: {
+        [key: string]: Endpoint;
+    };
+}
+type ProjectConfiguration<T = {
+    [k: string]: any;
+}> = IConfiguration & {
+    production: boolean;
+} & T;
+
+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[];
+    navigationUrl?: string;
+    data?: T;
+}
+interface AppDetails {
+    title: string;
+    description: string;
+    url: string;
+    icon: string;
+    auth: boolean;
+}
+
+interface AppDescriber<T = any> {
+    info: AppInfo;
+    routes?: Routes;
+    providers?: (Provider | EnvironmentProviders)[];
+}
+
+declare abstract class AbstractSupportService {
+    abstract sendSupport(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSupportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractSupportService>;
+}
+
+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";
+interface Navbar {
+    visible: boolean;
+    header: string | null;
+    searchVisible: boolean;
+    searchText: string | null;
+    leftItems: string[];
+    rightItems: string[];
+    loginVisible: boolean;
+    settingsVisible: boolean;
+    appsVisible: boolean;
+    separatorVisible: boolean;
+}
+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;
+}
+declare const initialSidebarState: Sidebar;
+interface SidebarState {
+    [sidebarsFeatureKey]: Sidebar;
+}
+
+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: string | null;
+    }) => {
+        header: string | 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">>;
+};
+
+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">>;
+};
+
+interface BaseState extends AuthState, SidebarState, NavbarState, AppState {
+}
+
+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 extends AbstractLoggerService {
+    private currentLevel;
+    private timestamps;
+    constructor();
+    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 class AppsService {
+    private store;
+    private activatedRoute;
+    private router;
+    private loggerService;
+    private logger;
+    constructor(store: Store<BaseState>, activatedRoute: ActivatedRoute, router: Router, loggerService: AppLoggerService, confAuth: AuthConfiguration | undefined);
+    get currentDomain(): string;
+    get apps(): AppInfo<any>[];
+    get currentApp(): AppInfo<any> | null;
+    selectApp(app?: AppInfo, viewMode?: 'app' | 'settings', url?: string): void;
+    private initAuthProviders;
+    private initRouterListener;
+    private resolveRouteAndApps;
+    private handleResolvedApps;
+    private findDeepestChild;
+    private getStoredAppId;
+    private isSettingsRoute;
+    private isDefaultRoute;
+    private getFullPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppsService, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppsService>;
+}
+
+declare class LanguageService {
+    private translateService;
+    private cookiesService;
+    private i18nOptions;
+    private _contentLanguage;
+    contentLanguageChanged$: EventEmitter<string>;
+    constructor(translateService: TranslateService, cookiesService: CookiesService, i18nOptions: InternationalizationConfiguration);
+    get language(): string | undefined;
+    set language(value: string | undefined);
+    get contentLanguage(): string | undefined;
+    set contentLanguage(value: string | undefined);
+    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>;
+    get languageChanged$(): rxjs.Observable<i20.LangChangeEvent>;
+    getLanguageName(l: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
+}
+
+declare class AppBreadcrumbService {
+    private router;
+    private route;
+    private loggerService;
+    private languageService;
+    private readonly _breadcrumbs$;
+    readonly breadcrumbs$: rxjs.Observable<BreadcrumbItem[]>;
+    private logger;
+    constructor(router: Router, route: ActivatedRoute, loggerService: AppLoggerService, languageService: LanguageService);
+    private updateBreadcrumbs;
+    private buildBreadcrumbFromRoot;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppBreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppBreadcrumbService>;
+}
+
+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 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 _newVersionAvailable$;
+    get newVersionAvailable$(): rxjs.Observable<void>;
+    constructor(updates: SwUpdate, modalService: ModalService, languageService: LanguageService);
+    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 class ParseJwtService {
+    private _atob;
+    parseJwt(token?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParseJwtService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ParseJwtService>;
+}
+
+declare class AuthenticationService {
+    private oidcSecurityService;
+    private cookiesService;
+    private router;
+    private readonly parseJwtService;
+    private readonly store;
+    private envConfig;
+    private authConfig;
+    modal: Window | null;
+    constructor(oidcSecurityService: OidcSecurityService, cookiesService: CookiesService, router: Router, parseJwtService: ParseJwtService, store: Store<BaseState>, envConfig: EnvironmentConfiguration, authConfig: AuthConfiguration);
+    get oidc(): OidcSecurityService;
+    get config(): AuthConfiguration;
+    get currentProvider(): _open_rlb_ng_app.ProviderConfiguration | undefined;
+    checkAuthMultiple(url?: string | undefined): Observable<LoginResponse[]>;
+    login(): void;
+    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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, [null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationService>;
+}
+
+declare class RlbRole implements OnInit {
+    private readonly templateRef;
+    private readonly viewContainer;
+    private readonly authenticationService;
+    private readonly parseJwtService;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, authenticationService: AuthenticationService, parseJwtService: ParseJwtService);
+    set roles(roles: string[] | string);
+    private updateView;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RlbRole, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RlbRole, "[roles]", never, { "roles": { "alias": "roles"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const oauthGuard: CanActivateFn;
+
+declare const oauthPasswordGuard: CanActivateFn;
+
+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 timer;
+    private _onUpdateToken;
+    constructor(httpClient: HttpClient, authenticationService: AuthenticationService);
+    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: ModalData<string>;
+    onEnter(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorModalComponent, "ng-component", never, {}, {}, 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: ModalData<any>;
+    valid?: boolean;
+    result?: any;
+    apps: AppInfo[];
+    appSelected(app: AppInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalAppsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalAppsComponent, "ng-component", never, {}, {}, 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", false>;
+}
+declare class AsSinglePipe implements PipeTransform {
+    transform<T>(value: T | T[]): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsSinglePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsSinglePipe, "asSingle", false>;
+}
+
+declare class CmsPipe implements PipeTransform {
+    private cmsOptions;
+    constructor(cmsOptions: CmsConfiguration);
+    transform(value: string, ...args: unknown[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmsPipe, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmsPipe, "cms", false>;
+}
+
+declare class LeftComponentPipe implements PipeTransform {
+    private config;
+    constructor(config: NavbarComponents);
+    transform(value: string): Type<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LeftComponentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LeftComponentPipe, "leftComponent", false>;
+}
+
+declare class RightComponentPipe implements PipeTransform {
+    private config;
+    constructor(config: NavbarComponents);
+    transform(value: string): Type<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RightComponentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RightComponentPipe, "rightComponent", false>;
+}
+
+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", false>;
+}
+
+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", false>;
+}
+
+declare class AppContainerComponent implements OnInit, OnDestroy {
+    env: EnvironmentConfiguration;
+    store: Store<BaseState>;
+    private readonly router;
+    private storage;
+    private readonly pwaUpdaterService;
+    private readonly appsService;
+    private readonly loggerService;
+    private swUpdateSubscription;
+    private readonly templateSubject;
+    modalContainerId: string;
+    toastContainerIds: string | string[];
+    private logger;
+    constructor(env: EnvironmentConfiguration, store: Store<BaseState>, router: Router, storage: AppStorageService, pwaUpdaterService: PwaUpdaterService, appsService: AppsService, loggerService: AppLoggerService);
+    get template$(): rxjs.Observable<PageTemplate>;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppContainerComponent, "rlb-app", never, { "modalContainerId": { "alias": "modal-container-id"; "required": false; }; "toastContainerIds": { "alias": "toast-container-ids"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AppTemplateComponent implements OnDestroy {
+    env: EnvironmentConfiguration;
+    store: Store<BaseState>;
+    appsService: AppsService;
+    private readonly authService;
+    private navbarItemsSubscription;
+    private sidebarItemsSubscription;
+    private sidebarFooterItemsSubscription;
+    navSearchText: string | null;
+    navbarItems: NavigableItem[];
+    sidebarItems: NavigableItem[];
+    sidebarFooterItems: NavigableItem[];
+    modalContainerId: string;
+    toastContainerIds: string | string[];
+    constructor(env: EnvironmentConfiguration, store: Store<BaseState>, appsService: AppsService, authService: AuthenticationService);
+    ngOnDestroy(): void;
+    get sidebarVisible$(): rxjs.Observable<boolean>;
+    get sidearHasLogin$(): rxjs.Observable<boolean>;
+    get sidearHasSearch$(): rxjs.Observable<boolean>;
+    get sidebarItems$(): rxjs.Observable<SidebarNavigableItem[]>;
+    setSidearSearchText(text: string | null): void;
+    setNavbarSearchText(text: string | null): void;
+    get sidearHasSettings$(): rxjs.Observable<boolean>;
+    get sidearAppsVisible$(): rxjs.Observable<boolean>;
+    get navVisible$(): rxjs.Observable<boolean>;
+    get navSearchVisible$(): rxjs.Observable<boolean>;
+    get navHeader$(): rxjs.Observable<string | null>;
+    get isAuth$(): rxjs.Observable<boolean>;
+    get user$(): rxjs.Observable<any>;
+    get navLeftItems$(): rxjs.Observable<string[]>;
+    get navRightItems$(): rxjs.Observable<string[]>;
+    get theme(): _open_rlb_ng_app.AppTheme;
+    get navbarHasLogin$(): rxjs.Observable<boolean>;
+    get navbarHasSettings$(): rxjs.Observable<boolean>;
+    get navbarHasApps$(): rxjs.Observable<boolean>;
+    get apps(): _open_rlb_ng_app.AppInfo<any>[];
+    get separatorVisible$(): rxjs.Observable<boolean>;
+    loginNav(event: MouseEvent): void;
+    login(): void;
+    onSideBarItemClick(item: SidebarNavigableItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppTemplateComponent, "rlb-app-template", never, { "modalContainerId": { "alias": "modal-container-id"; "required": false; }; "toastContainerIds": { "alias": "toast-container-ids"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaseComponent implements OnInit {
+    private breakpointObserver;
+    private platformId;
+    constructor(breakpointObserver: BreakpointObserver, platformId: Object);
+    breadcrumb: BreadcrumbItem[] | undefined;
+    title: string;
+    subtitle: string;
+    get isHandset$(): Observable<boolean>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseComponent, "rlb-base-template", never, { "breadcrumb": { "alias": "breadcrumb"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; }, {}, never, ["[all]", "[default]", "[mobile]"], false, never>;
+}
+
+declare class CmsComponent {
+    private strapiService;
+    private languageService;
+    private cmsOptions;
+    private mdService?;
+    constructor(strapiService: StrapiService, languageService: LanguageService, cmsOptions: CmsConfiguration, mdService?: AbstractMdService | undefined);
+    contentId: string | undefined;
+    breadcrumb: BreadcrumbItem[] | undefined;
+    page: Page | undefined;
+    private subscriptionLang;
+    private subscriptionPage;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    md(md: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmsComponent, [null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmsComponent, "rlb-cms-template", never, { "contentId": { "alias": "contentId"; "required": false; }; "breadcrumb": { "alias": "breadcrumb"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ContentComponent {
+    private breakpointObserver;
+    private platformId;
+    constructor(breakpointObserver: BreakpointObserver, platformId: Object);
+    get isHandset$(): Observable<boolean>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentComponent, "rlb-content-template", never, {}, {}, never, ["[all]", "[default]", "[mobile]"], false, never>;
+}
+
+declare class ToastComponent implements IToast<string, void> {
+    data: ToastData<string>;
+    valid?: boolean;
+    result?: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "ng-component", never, {}, {}, 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 route;
+    constructor(route: ActivatedRoute);
+    get contentId(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmsContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmsContentComponent, "rlb-cms-content", never, {}, {}, never, never, false, never>;
+}
+
+declare class CookiesComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CookiesComponent, "rlb-cookies", never, {}, {}, never, never, false, never>;
+}
+
+declare class NotFoundComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotFoundComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotFoundComponent, "rlb-not-found", never, {}, {}, never, never, false, never>;
+}
+
+declare class PrivacyComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrivacyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrivacyComponent, "rlb-privacy", never, {}, {}, never, never, false, never>;
+}
+
+declare class SupportComponent {
+    private supportService;
+    private _location;
+    supportForm: FormGroup;
+    constructor(supportService: AbstractSupportService, _location: Location);
+    hasError(form: string, controlName: string, errorName: string): boolean;
+    sendSupport(data: any): void;
+    backClicked(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SupportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SupportComponent, "rlb-support", never, {}, {}, never, never, false, never>;
+}
+
+declare class TermsAndConditionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermsAndConditionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TermsAndConditionsComponent, "rlb-terms-and-conditions", never, {}, {}, never, never, false, never>;
+}
+
+declare class RlbAppModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RlbAppModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RlbAppModule, [typeof CmsContentComponent, typeof CookiesComponent, typeof NotFoundComponent, typeof PrivacyComponent, typeof SupportComponent, typeof TermsAndConditionsComponent, 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 i18.CommonModule, typeof i19.FormsModule, typeof i19.ReactiveFormsModule, typeof i20.TranslateModule, typeof _open_rlb_ng_bootstrap.RlbBootstrapModule, typeof i22.RouterModule], [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 i20.TranslateModule, typeof _open_rlb_ng_bootstrap.RlbBootstrapModule, typeof i22.RouterModule, typeof i19.FormsModule]>;
+    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, 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_CFG, RLB_CFG_AUTH, RLB_CFG_CMS, RLB_CFG_ENV, RLB_CFG_I18N, RLB_CFG_PAGES, RightComponentPipe, RlbAppModule, RlbRole, SidebarActions, SidebarActionsInternal, StrapiService, ToastComponent, TokenOauthInterceptor, TranslateBrowserLoader, TruncatePipe, UtilsService, appContextFeatureKey, authsFeatureKey, getDefaultRoutes, initialAppContextState, initialAuthState, initialNavbarState, initialSidebarState, navbarsFeatureKey, oauthGuard, oauthPasswordGuard, provideApp, provideRlbCodeBrowserOAuth, provideRlbConfig, provideRlbI18n, sidebarsFeatureKey, translateBrowserLoaderFactory, verifyDeactivate };
+export type { AppContext, AppDescriber, AppDetails, AppInfo, AppInfoData, AppState, AppTheme, AppViewMode, Auth, AuthConfiguration, AuthState, BaseState, CacheItem, CmsConfiguration, Endpoint, EnvironmentConfiguration, ErrorOutput, Faq, FaqGroup, Home, IConfiguration, InternationalizationConfiguration, JwtUser, KeycloakClient, KeycloakCredential, KeycloakDevice, KeycloakSession, KeycloakUser, KeycloakUserCredentialMetadata, LogLevel, LoggerContext, MenuItem, Navbar, NavbarComponents, NavbarState, Page, PageTemplate, PagesConfiguration, ProjectConfiguration, ProviderConfiguration, Sidebar, SidebarState, Step, Tab, Token, Topic, UserClaims, VerifyDeactivate, _KeycloakCredential };