import * as i0 from "@angular/core"; import { EnvironmentProviders, InjectionToken, Injector, OnDestroy, OnInit, PipeTransform, Provider, TemplateRef, TransferState, Type } from "@angular/core"; import { LoginResponse, OidcSecurityService, OpenIdConfiguration } from "angular-auth-oidc-client"; import * as i5 from "@angular/router"; import { CanActivateFn, CanDeactivateFn, Router, Routes } from "@angular/router"; import { HttpClient, HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http"; import { Observable, OperatorFunction } from "rxjs"; import { Store } from "@ngrx/store"; import * as i1$1 from "@open-rlb/ng-bootstrap"; import { BreadcrumbItem, IModal, IToast, ModalData, ModalService, ModalType, OffcanvasComponent, SidebarNavigableItem, ToastData, ToastService, VisibilityEvent } from "@open-rlb/ng-bootstrap"; 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 { FormControl, FormGroup } from "@angular/forms"; /** * Severity levels accepted by {@link AppLoggerService} and by `EnvironmentConfiguration.logLevel`. * * It lives in its own file rather than beside the service because the service depends on * `configuration.ts` for `RLB_CFG_ENV`, while `configuration.ts` needs this type: declaring it * next to the service closed an import cycle. Re-exported from `app-logger.service.ts`, so the * public API is unchanged. */ type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug' | 'log'; export declare const RLB_CFG: InjectionToken>; export declare const RLB_CFG_CMS: InjectionToken; export declare const RLB_CFG_I18N: InjectionToken; export declare const RLB_CFG_PAGES: InjectionToken; export declare const RLB_CFG_ENV: InjectionToken; export declare const RLB_CFG_AUTH: InjectionToken; export declare const RLB_APP_NAVCOMP: InjectionToken; export declare const RLB_APP_SIDEBARCOMP: InjectionToken; export declare const RLB_CFG_ACL: InjectionToken; /** * Which chrome surface a custom navbar component is currently rendered in. * Provided by the shell around each component outlet. Inject it with * `{ optional: true }` — components registered before this token existed * simply don't see it. */ export type NavSurface = 'navbar' | 'mobile-menu'; export declare const RLB_NAV_SURFACE: InjectionToken; export type AuthUrlHandler = (url: string) => void | Promise; export declare const RLB_AUTH_URL_HANDLER: InjectionToken; export interface InterceptorMapping { [k: string]: string; } export interface ProviderAclConfiguration { endpointKey: string; path: string; } export interface AclConfiguration { interceptorMapping?: InterceptorMapping; businessIdKey: string; resourceIdKey: string; } export interface ProviderConfiguration extends OpenIdConfiguration { configId: string; domains?: string[]; roleClaim?: (data: any) => string | string[]; acl?: ProviderAclConfiguration; } export interface NavbarComponent { component: Type; name: string; } export interface NavbarComponents { left: NavbarComponent[]; right: NavbarComponent[]; /** * Components available to the mobile menu (offcanvas below the `lg` breakpoint), * activated with `NavbarActions.setMobileItems`. Falls back to `right` when omitted, * so an app can register one component for both surfaces and branch on * {@link RLB_NAV_SURFACE}. */ mobile?: NavbarComponent[]; } export interface SidebarComponents { footer: { component: Type; name: string; }[]; } export interface CmsConfiguration { endpoint: string; chacheDuration: number; useAppLanguage: boolean; contentLanguages: string[]; markdown: 'ignore' | 'html' | 'text'; } /** * Tuning for the `'oauth-code-ep-retry'` interceptor and the token watchdog behind it. * * The defaults are the ones this design was audited with; change them only with a reason. */ export interface TokenRenewalConfiguration { /** * How far ahead of expiry to renew, in seconds. Default 90. * * Wide enough that the retry ladder below has room to run before the token actually expires: at * the defaults the first three retries all land with time to spare. * * This used to be justified as staying ahead of the 30s the OIDC library uses for its own periodic * check, on the reasoning that ours would land first and the library's would then find a fresh * token and stand down. That only held while ours succeeded — through an outage it never does, and * the library's unguarded check went on to destroy the refresh token. The library's check is * switched off under this interceptor now, so there is no second renewer to stay ahead of. */ renewLeadSeconds?: number; /** Waits between the first failed attempts, in seconds. Default `[5, 20, 60]`. */ retryDelaysSeconds?: number[]; /** Cadence of the slow heartbeat once the ladder above is spent, in seconds. Default 120. */ transientRetrySeconds?: number; /** * How long to keep retrying one outage before standing down, in seconds. Default 1800. * * A dead refresh token is indistinguishable from an unreachable host by the time the failure * arrives — the library replaces the provider's response body with its own `Error` — so this * budget, not any classification of the error, is what stops a rejected token being retried * forever. The interceptor still recovers on the next 401. * * It also bounds how long `oauthGuard` will let a signed-out-looking session keep navigating: for * as long as the watchdog is working on an outage the user stays in the app, and once it stands * down they are sent to the login page. Lower this if you would rather a revoked session reached * the login page sooner, at the cost of giving up on a long outage sooner too. */ maxOutageSeconds?: number; /** Start the watchdog once the user is authenticated. Default true. */ autoStart?: boolean; /** * Renew once at bootstrap when the stored access token has expired but a refresh token outlived * it. Default true. * * This is what makes a session survive the browser being closed. The OIDC library decides * authentication at startup by reading storage — an expired access token means unauthenticated, * and it never tries the refresh token it is holding. So a user coming back the next morning is * sent to the login host, and only stays signed in for as long as the provider's own SSO cookie * outlives the tab. Past that they get a login form, with a perfectly good refresh token still in * storage. With `offline_access` in the provider's `scope` and `storage: 'localStorage'`, one * renewal here is the difference between that and a session that lasts as long as the refresh * token does. * * A failed attempt leaves the startup exactly as it is without this: unauthenticated, guards * redirecting. The refresh token survives it — the renewal runs through the watchdog's * snapshot-protected path — so reloading during an outage cannot destroy the stored session. */ restoreOnBoot?: boolean; /** * Paths on authenticated endpoints that anonymous callers may legitimately reach, matched as * substrings of the request URL (e.g. `['/register']`). * * The interceptor otherwise refuses to send a request to an authenticated endpoint without a * token; registration and similar front-door calls happen before an account exists and would * fail. Default `[]`. */ publicPaths?: string[]; } export interface AuthConfiguration { protocol: 'oauth'; storage: 'cookies' | 'localStorage' | 'sessionStorage'; /** * Which HTTP interceptor attaches the token. * * - `'oauth-code-all'` — the OIDC library's own, matching `allowedUrls`. * - `'oauth-code-ep'` — attaches to the `endpoints` marked `auth`. Sends the request anyway when * there is no token, so the backend sees an anonymous call. * - `'oauth-code-ep-retry'` — as above, plus: never sends an authenticated request without a * token, retries a 401 once with a fresh one, and keeps a watchdog renewing the token so a * single failed refresh cannot end renewal for the life of the page. Tune with {@link renewal}. * * `'oauth-code-ep-retry'` also switches the OIDC library's own `silentRenew` off, because the * watchdog owns renewal in that mode and two renewers spending one refresh token is how a session * dies mid-outage. Set `silentRenew: true` on an individual provider to put it back. */ interceptor?: 'oauth-code-all' | 'oauth-code-ep' | 'oauth-code-ep-retry' | 'none'; enableCompanyInterceptor?: boolean; allowedUrls: string[]; providers: ProviderConfiguration[]; /** Only read when {@link interceptor} is `'oauth-code-ep-retry'`. */ renewal?: TokenRenewalConfiguration; } export interface InternationalizationConfiguration { availableLangs: string[]; defaultLanguage: string; useLanguageBrowser: boolean; storeSelectedLanguage: boolean; cookieStoreName: string; } export interface PageConfiguration { path: string; /** * ACL action required to see this page — the entry in the settings dropdown and list, and the * route itself (guarded with `pagePermissionGuard`). A list grants on **any** of its actions. * * Omitted means visible to everyone, which is what every configuration written before this * existed says. The check is "does the user hold it on any resource", not "in the current app": * these pages belong to no app, and while one is open there is no current app to scope to. * * Routes the kit does not register — `status`, `logger`, anything else the consumer owns — get * their button gated here, but you have to put `pagePermissionGuard` on the route yourself. */ action?: string | string[]; } export interface PagesConfiguration { [key: string]: PageConfiguration; } /** * Per-status messages `ErrorManagementService` renders for a failed HTTP call. * * For an `HttpErrorResponse` the lookup is, first group that resolves a message wins: * `{keyPrefix}.{status}` → `{keyPrefix}.default` → the backend's own text * (`"{status}: {message}"` under an `HttpErrorResponse` title), which is what the handler has * always shown. A key ngx-translate cannot resolve counts as a miss, so a consumer opts in one * status at a time just by adding keys to its i18n files — nothing has to be configured here. * * Each group holds `title`, `message` and an optional `messageRetry` used instead of `message` * when the wait is known (see {@link defaultRetryMinutes}); `messageRetry` may interpolate * `{{minutes}}`, `{{seconds}}` and `{{status}}`. */ export interface HttpErrorMessagesConfiguration { /** i18n namespace holding the per-status groups. Default `'errors.http'`. */ keyPrefix?: string; /** * How long to say the caller must wait when the response carries no usable `Retry-After`. * * `Retry-After` is not a CORS-safelisted response header: a cross-origin gateway has to name it * in `Access-Control-Expose-Headers` or the browser hides it and every 429 looks like it has * none. Without either, only the `message` variant of a group can be used. */ defaultRetryMinutes?: number; /** * Window in ms within which the same (output, title, message) is shown once. * * A rate limit rejects every request already in flight, so without this the user gets one modal * per request instead of one modal. Default 1000; set `0` to show every error. */ dedupeMs?: number; } export 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; httpErrors?: HttpErrorMessagesConfiguration; pwaUpdateEnabled?: boolean; logLevel?: LogLevel; } export interface Endpoint { baseUrl: string; healthPath: string; auth?: boolean; wss?: boolean; } export interface IConfiguration { environment?: EnvironmentConfiguration; cms?: CmsConfiguration; auth?: AuthConfiguration; i18n?: InternationalizationConfiguration; pages?: PagesConfiguration; acl?: AclConfiguration; endpoints?: { [key: string]: Endpoint; }; } export type ProjectConfiguration = IConfiguration & { production: boolean; } & T; export type AppViewMode = 'app' | 'settings'; export interface AppInfoData { appName?: string; } export interface AppInfo { id?: string; type: string; enabled: boolean; core?: AppDetails; settings?: AppDetails; viewMode?: AppViewMode; routes?: string[]; domains?: string[]; actions?: string[]; navigationUrl?: string; data?: T; autoRedirectOnRootEnabled?: boolean; } export interface AppDetails { title: string; description: string; url: string; icon: string; auth: boolean; } export interface AppDescriber { info: AppInfo; routes?: Routes; /** * Providers this app needs, spread into the **root injector on every domain** — `info.domains` * does not scope them. Wrap anything tenant-local (interceptors, app initializers) in * `provideForDomains(domains, providers)`. */ providers?: (Provider | EnvironmentProviders)[]; } export declare const aclFeatureKey = "acl"; export interface UserResource { companyId: string; resources: Resource[]; } export interface Resource { resourceId: string; actions: string[]; friendlyName?: string; } export interface Acl { resources: UserResource[] | null; loading: boolean; loaded: boolean; error: any; } export declare const initialAclState: Acl; export interface AclState { [aclFeatureKey]: Acl; } /** * What a caller may pass where an ACL action is expected: one action, or a list the user only has * to hold **one** of ("management and superior" style checks). */ export type AclAction = string | string[]; /** * Reduces an action input to the list actually checked. * * `undefined`, `null`, `''` and `[]` all collapse to an empty list, which every consumer of this * helper reads as "no action asked for" — public, or "any grant on the resource", depending on the * caller. An empty array must never mean "deny": a consumer computing the list dynamically would * otherwise get a blank UI the first time the list comes back empty. */ export declare function normalizeAclActions(action?: AclAction | null): string[]; declare namespace role_directive_d_exports { export { RlbRole }; } /** * Renders its content only for a user holding the given ACL action in the current app. * * ```html * * * … * … * ``` * * No action — `undefined`, `''` or `[]` — is public. An empty array in particular must not read as * "deny", or a consumer computing the list dynamically gets a blank UI the first time it comes back * empty. `not: true` inverts that decision like any other, so `*roles="[]; not: true"` renders * nothing. */ export declare class RlbRole { private appsService; private templateRef; private viewContainer; /** The action, or the list the user only has to hold one of. */ action: import("@angular/core").InputSignal; /** Render when the user *lacks* the action instead — an upsell or a read-only hint. */ not: import("@angular/core").InputSignalWithTransform; /** Rendered instead when the check fails, mirroring `*ngIf`'s `; else`. */ elseTemplate: import("@angular/core").InputSignal | null>; /** * Which template is on screen right now. * * The effect below re-runs on every ACL or input change, most of which do not change the * outcome. Clearing and recreating unconditionally would remount the subtree each time and drop * whatever state lives inside it, so the view is only touched when the target actually changes. */ private rendered; constructor(); private granted; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } /** * Requires an authenticated session, and sends the visitor to the provider when there is none. * * **Except while the session is merely mid-outage.** A failed token refresh makes the OIDC library * publish `isAuthenticated$: false` even when the session is perfectly alive on the provider and * only the login host was briefly unreachable. Bouncing then is worse than useless: it takes the * user out of the app and hands them to the very host that is failing. So when the renewal watchdog * is still working on the session, navigation is allowed through — requests keep their normal error * handling meanwhile, and everything resumes silently once the host answers again. See * {@link TokenRenewalService.isRecoverable}. * * That only applies under `auth.interceptor: 'oauth-code-ep-retry'`, the mode that runs the * watchdog. Reading the configuration first also keeps this guard usable in an app with no auth * configured at all, where the watchdog's own dependencies would not resolve. */ export declare const oauthGuard: CanActivateFn; /** * Requires the ACL action named in `route.data.action` **in the app that owns the route**. * * `data.action` may be a list, in which case any one of them grants. */ export declare const permissionGuard: CanActivateFn; /** * Requires `action` on **any** resource the user holds — the guard for chrome that no app owns. * * `getDefaultRoutes` puts this on every `pages.*` entry that declares an `action`. Use it for the * pages the kit cannot register for you (`status`, `logger`, …) so the route and the settings * button that links to it agree: * * ```typescript * { path: 'status', component: StatusComponent, canActivate: [pagePermissionGuard('show-status')] } * ``` * * `permissionGuard` is the wrong tool here: while a `pages.*` route is open `AppsService` has * deselected the current app, and no app claims the path, so it denies whatever the user holds. */ export declare function pagePermissionGuard(action?: AclAction): CanActivateFn; export declare const oauthPasswordGuard: CanActivateFn; export declare class ParseJwtService { private _atob; parseJwt(token?: string): any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export type LoggerContext = { error: (...args: any[]) => void; warn: (...args: any[]) => void; info: (...args: any[]) => void; debug: (...args: any[]) => void; log: (...args: any[]) => void; }; export 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; static ɵprov: i0.ɵɵInjectableDeclaration; } export 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; static ɵprov: i0.ɵɵInjectableDeclaration; } export 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; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare const appContextFeatureKey = "app"; export type AppTheme = 'light' | 'dark'; export type PageTemplate = 'app' | 'basic' | 'cms' | 'content'; export declare const RLB_APPS: InjectionToken>; export interface AppContext { apps: AppInfo[]; currentApp: AppInfo | null; language: string | null; theme: AppTheme; supportedLanguages: string[]; } export declare const initialAppContextState: AppContext; export interface AppState { [appContextFeatureKey]: AppContext; } export declare const authsFeatureKey = "auth"; export interface Auth { currentProvider: string | null; loading: boolean; } export declare const initialAuthState: Auth; export interface AuthState { [authsFeatureKey]: Auth; } export declare const navbarsFeatureKey = "navbar"; export type NavbarHeader = { type: 'text'; text: string; } | { type: 'image'; src: string; alt?: string; height?: number; }; export type NavbarActionsLayout = 'default' | 'dropdown'; export interface Navbar { visible: boolean; header: NavbarHeader | null; searchVisible: boolean; searchText: string | null; leftItems: string[]; rightItems: string[]; /** * Named components rendered in the mobile menu (offcanvas below `lg`), resolved against * `NavbarComponents.mobile ?? NavbarComponents.right`. Empty means the mobile menu shows * only core content. */ mobileItems: string[]; loginVisible: boolean; settingsVisible: boolean; appsVisible: boolean; separatorVisible: boolean; actionsLayout: NavbarActionsLayout; } export declare const initialNavbarState: Navbar; export interface NavbarState { [navbarsFeatureKey]: Navbar; } export declare const sidebarsFeatureKey = "sidebar"; export interface Sidebar { items: SidebarNavigableItem[]; visible: boolean; loginVisible: boolean; searchVisible: boolean; appsVisible: boolean; settingsVisible: boolean; searchText: string | null; footerComponent: string | null; } export declare const initialSidebarState: Sidebar; export interface SidebarState { [sidebarsFeatureKey]: Sidebar; } /** * The library's aggregate store shape. * * It lives here rather than in `index.ts` because the barrel re-exports `acl.store`, which itself * needs this type: declaring it in the barrel made every consumer of `BaseState` import the barrel * and closed an import cycle. Re-exported from `index.ts`, so the public API is unchanged. */ export interface BaseState extends AclState, AuthState, SidebarState, NavbarState, AppState {} declare class AdminApiService { private httpClient; private config; private aclConfig; constructor(httpClient: HttpClient, config: ProjectConfiguration, aclConfig: AclConfiguration); resourcesByUser$(endpointKey: string, path: string): Observable; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * The one renewal `AuthenticationService` runs at startup, before deciding nobody is signed in. * * `TokenRenewalService` is what implements this, and it is deliberately reached through a token * rather than injected: it injects `AuthenticationService` itself, and asking for it from a * constructor that is mid-construction on the other side of that edge is a circular dependency * (NG0200). The factory in `auth.provider.ts` resolves it lazily for the same reason. * * Only `'oauth-code-ep-retry'` provides it, so nothing changes for any other interceptor: the * injection is optional and a startup without it behaves as it always did. */ export interface BootSessionRestorer { /** Whether storage still holds a refresh token worth spending on the attempt. */ canRestore(): boolean; /** * Renews through the watchdog's snapshot-protected path, so a failure that wipes storage is put * back rather than costing the session. An empty token means the attempt failed. */ refresh(): Observable; } export declare const RLB_BOOT_SESSION_RESTORER: InjectionToken; export 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; private bootRestorer; modal: Window | null; private logger; private readonly aclStore; private readonly document; private readonly _authReady$; readonly authReady$: Observable; private readonly _authenticated$; readonly authenticated$: Observable; /** Reasons already reported, so a broken configuration logs once instead of once per call. */ private readonly reportedFailures; private storedProviderId; constructor(oidcSecurityService: OidcSecurityService, cookiesService: CookiesService, router: Router, parseJwtService: ParseJwtService, store: Store, log: AppLoggerService, localStorage: AppStorageService, adminApi: AdminApiService, envConfig: EnvironmentConfiguration, authConfig: AuthConfiguration, appconfig: IConfiguration, authUrlHandler: AuthUrlHandler | null, bootRestorer: BootSessionRestorer | null); get oidc(): OidcSecurityService; get config(): AuthConfiguration; private get hostname(); /** A method rather than a field, so specs can override it to exercise the production branch. */ protected isDevelopmentMode(): boolean; private resolve; /** * The provider this page is using, or undefined when none resolves. * * Read speculatively — from templates, and from `KeycloakProfileService` for its base URL — so it * stays quiet and never throws. {@link resolvedConfigId} is the loud path. */ get currentProvider(): import("@open-rlb/ng-app").ProviderConfiguration | undefined; /** * The configId to hand the OIDC library, or undefined when none resolves. * * Never returns undefined *to the library*: callers must skip the call instead. Passing undefined * makes `getConfig` fall back to the first registered configuration, so on a domain whose * provider failed to resolve every token read, login and logout would silently target a different * realm — one holding none of this tenant's tokens. That is invisible wherever environments share * a realm (dev, staging) and only bites in production, which is exactly how it reached production. * * A misconfigured domain throws in dev and logs at error level in prod. Having no providers at * all is not a misconfiguration — it is an app without auth — so that stays silent. */ private resolvedConfigId; checkAuthMultiple(url?: string | undefined): Observable; /** * One renewal before a startup with expired tokens is called a guest session. * * The library decides authentication by reading storage: an expired access token is * unauthenticated, and the refresh token sitting next to it is never tried. That is fine while a * tab stays open — the watchdog renews long before expiry — but a browser that was closed comes * back past it every time, and the user is sent to the login host to be recognised by its SSO * cookie. Once that cookie is gone they get a login form, holding a refresh token that would * have worked. Renewing here is what makes `offline_access` mean anything. * * Only reached when nothing is authenticated, so a callback page — where the library has just * exchanged a code and says so — is left alone, and no refresh runs alongside that exchange. * A success is indistinguishable from an ordinary authenticated startup downstream: the same ACL * load, the same redirect handling, the same `authenticated$`, and so the watchdog starts as * usual. A failure leaves the startup as it would have been, with the refresh token restored by * the path in {@link BootSessionRestorer.refresh}. * * This runs inside the app initializer, so it is finished before the router's first navigation * and no guard can see the in-between state — true while the host leaves initial navigation on * its default, and worth knowing before turning that off. */ private restoreSessionIfPossible; login(targetUrl?: string): void; private get electronUrlHandler(); logout(): Promise; logout$(): Observable; get userInfo$(): Observable; get isAuthenticated$(): Observable; get accessToken$(): Observable; get idToken$(): Observable; get refreshToken$(): Observable; get roles$(): Observable; matchRoles(roles: string[]): Observable; private handleRedirect; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export interface Token { access_token: string | null; expires_in: number; token_type: string; scope: string; id_token: string | null; refresh_token: string | null; } export 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, next: HttpHandler): Observable>; 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; loggedIn(): boolean; logout(): void; private _login; private _refreshToken; private initRefreshToken; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * Why {@link resolveProvider} answered the way it did. * * The three failures are kept apart because they need different words in front of a developer: * nothing configured is a different mistake from a hostname no provider claims, which is a * different mistake again from two providers claiming the same one. */ export type ProviderResolutionReason = 'store' | 'single' | 'domain' | 'no-providers' | 'no-domain-match' | 'ambiguous-domain-match'; export interface ProviderResolution { /** The provider to use, or undefined when none could be resolved. */ provider?: ProviderConfiguration; reason: ProviderResolutionReason; /** Every provider that claimed the hostname. Only interesting for 'ambiguous-domain-match'. */ matched: ProviderConfiguration[]; } /** * Picks the auth provider this page should be using. * * One algorithm, shared by `AuthenticationService` and `AppsService`, because the two used to * re-derive it separately and could therefore disagree: the store-backed getter would return * undefined while the OIDC library — handed that undefined — silently used the first registered * configuration instead, a different realm holding none of this tenant's tokens. * * The order runs from most to least specific: * * 1. the id the store already holds, when it names a configured provider — this is the normal path * once `checkAuthMultiple` or `AppsService` has settled the question; * 2. the only provider there is, when a single one is configured; * 3. the provider whose `domains` claims this hostname, when exactly one does. * * Resolution is by **hostname, never by configId**: the domain is what identifies a portal, while * `configId` is only the OIDC library's storage key and is free to differ between environments. * * Pure and side-effect-free — callers decide how loudly to react to a failure. */ export declare function resolveProvider(providers: ProviderConfiguration[] | undefined, storeConfigId: string | null | undefined, hostname: string): ProviderResolution; /** Whether a resolution failed to name a provider. */ export declare function isProviderResolutionFailure(resolution: ProviderResolution): boolean; /** * The message to put in front of whoever has to fix a failed resolution. * * Names the hostname, every configured provider with the domains it claims, and the change that * would resolve it — a misconfigured domain used to surface as a console warning and an app that * stayed silently unauthenticated forever, which is the failure mode this text exists to end. */ export declare function describeProviderResolutionFailure(resolution: ProviderResolution, hostname: string, providers: ProviderConfiguration[] | undefined, operation?: string): string; export declare class TokenOauthInterceptor implements HttpInterceptor { private authenticationService; private appconfig; constructor(authenticationService: AuthenticationService, appconfig: IConfiguration); intercept(request: HttpRequest, next: HttpHandler): Observable>; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * Keeps the access token fresh for as long as the tab is open. * * The OIDC library already does this, but its periodic check is one-strike: a failed renewal ends * in `finalize(() => refreshTokenFailed && this.intervalService.stopPeriodicTokenCheck())`, which * unsubscribes the interval and nulls the handle — and `startTokenValidationPeriodically` is only * ever reached from the `checkAuth` path, so nothing starts it again. One failed refresh therefore * disables renewal for the life of the page: the token expires a few minutes later, every request * comes back 401, and the route guard bounces the user out to the login host. Reloading appears to * fix it only because bootstrap runs `checkAuth`, which refreshes once and starts the countdown * again. * * This watchdog keeps its own clock, so a failure costs one attempt rather than the mechanism. * * The library has a second, nastier failure mode: on any refresh error that is not a pure network * error — a gateway 504 while the login host is down qualifies — `resetAuthorizationData` erases * the access, id AND refresh token from storage before the error ever reaches this service. The * session is still perfectly alive on the provider's side; only the local copy of the refresh token * is gone, and with it any chance of recovering without a full login. So a snapshot of the stored * auth state is taken before every attempt and put back after a failure ({@link restoreIfWiped}), * so the next attempt has something to work with. A {@link lastKnownGood} copy is carried across * attempts as well, so a wipe by something this service does not drive is recoverable too. * * It should not have to be: `'oauth-code-ep-retry'` switches the library's own periodic check off, * so this is the only renewer running (`auth.provider.ts`). Both were live until 2026-08-11, and * through an outage the library's unguarded check destroyed the refresh token about a minute after * this one's first failed attempt. A host that deliberately puts the library's check back with a * per-provider `silentRenew: true` gets the restore rather than the session loss. * * Retries follow a short ladder and then a slow heartbeat, for as long as a refresh token survives * in storage and the outage stays inside its budget. There is deliberately no attempt to tell a * dead token from an unreachable host: the library destroys that information before the error * arrives, so the budget is what stops a rejected token being retried forever. Once the watchdog * stands down, the retry interceptor still recovers on the next 401 and calls {@link rearm}. * * Everything runs on one chain. {@link start} and {@link rearm} push onto a single trigger whose * `switchMap` cancels whatever was scheduled, so no amount of rearming can leave two chains racing * to spend the same refresh token — with rotation enabled, the second spend revokes the session. * * Provided in root but inert: nothing happens until something starts it. `'oauth-code-ep-retry'` * starts it for you unless `auth.renewal.autoStart` is false. */ export declare class TokenRenewalService { private readonly oidc; private readonly authService; private readonly destroyRef; private readonly storage; private readonly config; private readonly renewLeadSeconds; private readonly retryDelaysSeconds; private readonly transientRetrySeconds; private readonly maxOutageSeconds; /** * The refresh currently in flight, shared by every caller. * * Parallel refreshes are the failure this whole service exists to avoid: several requests failing * at once would each spend the same refresh token, and with rotation enabled all but the first * are rejected — taking the session with them. */ private inFlight?; /** * The last stored state seen holding a refresh token, kept across attempts. * * A snapshot taken immediately before an attempt only covers a wipe by that attempt. Storage can * also be emptied between attempts by something this service does not drive — the OIDC library's * own periodic check is the case that cost a live session on 2026-08-11 — and by the time the next * attempt reads storage there is nothing left to snapshot. This is what it falls back to. */ private lastKnownGood?; private started; /** * Every request to (re)schedule the watchdog. One subscription, `switchMap`ped, so the chain * already on the clock is cancelled rather than joined by a second one. */ private readonly restart$; constructor(); /** Begins watching the current token. Safe to call more than once. */ start(): void; /** The token as currently stored, without renewing anything. */ accessToken(): Observable; /** * Whether a session the OIDC library reports as unauthenticated can still be expected to come * back — because this watchdog is still working on it and storage still holds a refresh token. * * The library's `isAuthenticated$` is a `BehaviorSubject` that only moves when the library itself * sets it, while `AuthStateService.isAuthenticated()` is a pure function of storage. A failed * refresh calls `resetAuthorizationData`, which does both: it empties storage _and_ pushes * `false`. {@link restoreIfWiped} then puts the whole storage blob back — so the storage-backed * truth recovers and the subject does not, and there is no way to correct it: `AuthStateService` * is not exported from the package. * * So a guard reading `isAuthenticated$` sees a signed-out user through an outage and sends them * to a login host that is, by construction, the thing that is down. This is what {@link oauthGuard} * consults instead of bouncing. Once the outage budget is spent the watchdog stands down, this * turns false, and a genuinely dead session reaches the login page as it always did. */ isRecoverable(): boolean; /** * Whether storage holds a refresh token to renew with, in either of the two slots the library * keeps one in. * * Read at startup, before the watchdog is running, to decide whether a session the library calls * unauthenticated is worth one renewal — see {@link BootSessionRestorer}. Deliberately not * `oidc.getRefreshToken()`: that returns nothing unless the access and id tokens are also still * in storage, which is precisely what has expired by then. */ hasStoredRefreshToken(): boolean; /** Renews the token, joining the attempt already running rather than starting a second one. */ refresh(): Observable; /** * Puts the watchdog back on the clock after an outside refresh — the interceptor calls this so a * request that recovered on its own also revives automatic renewal. */ rearm(): void; /** * One renewal cycle, from the token as it stands now until the watchdog stands down. * * `expand` feeds each attempt's outcome back in as the next wait, so the whole cycle is a single * chain: there is no second timer that could fall out of step with this one. */ private watch; /** Waits out a state's delay, renews, and reports where that leaves the watchdog. */ private runAttempt; /** Back on the normal schedule, with the outage budget reset. */ private afterSuccess; /** * Where a failed attempt leaves the watchdog, or undefined to stand down. * * The ladder always runs in full; only once it is spent does the watchdog ask whether carrying on * can still help. It cannot if storage holds no refresh token to try with, or if this outage has * already had its budget. */ private afterFailure; /** Seconds to wait before the next renewal, derived from the token's own expiry. */ private delayFor; /** * The provider for this domain. * * `AuthenticationService` resolves it from the store, or by hostname when the store has not * settled it, and reports a domain no provider claims rather than letting the OIDC library fall * back to the first registered configuration. */ private configId; /** * The library's whole stored state for this config, as the raw string it keeps in storage. * * The single read point, so remembering a usable state here is enough to keep * {@link lastKnownGood} current without a second code path to keep in step with this one. */ private readStoredState; /** * Puts a refresh token back after storage was wiped over a failed refresh. * * The pre-attempt snapshot is preferred, and {@link lastKnownGood} covers the case it cannot: a * wipe by a renewer this service does not drive, which leaves the next attempt nothing to * snapshot. Either way the write is guarded twice — the candidate must actually hold a refresh * token, and the current storage must not. If another tab renewed in the meantime its fresher * tokens win, since restoring an already-rotated token would only earn a rejection next round. * * A token the provider has genuinely rejected does get restored here, whichever source it came * from, because nothing in the error says it was rejected; the outage budget is what stops that * becoming a loop. */ private restoreIfWiped; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * Seconds left on a JWT, or undefined when it carries no readable `exp`. * * Reading the claim beats asking the library: its expiry helpers are not part of the public API, * and a token we cannot read is a case the caller has to handle anyway. */ export declare function secondsUntilExpiry(token: string): number | undefined; /** * Attaches the access token to calls on authenticated endpoints, and recovers the two failures * `TokenOauthInterceptor` leaves to the caller. * * **It never sends an authenticated request anonymously.** `TokenOauthInterceptor` attaches * whatever token it finds and, finding none, sends the request anyway with no `Authorization` * header — so the backend gets a call it cannot attribute to anyone, which is how a stalled * renewal turns into a flood of "missing user id" errors rather than a visible auth failure. Here a * request either leaves with a token or does not leave at all, failing with a 401 raised locally. * * **It retries a 401 once**, with a freshly renewed token. Retrying a 401 is safe in a way retrying * a 500 is not: 401 means the request was rejected before it was acted on, so replaying it cannot * repeat a side effect. The retry is issued downstream of this interceptor, so its own failure * travels straight to the caller and cannot loop back through here. * * Selected with `auth.interceptor: 'oauth-code-ep-retry'`, which also brings up * {@link TokenRenewalService}. It replaces `TokenOauthInterceptor` rather than stacking on it. * * Three things pass through untouched: calls that are not on an authenticated endpoint, calls to * `auth.renewal.publicPaths` — set that for front-door calls like registration, which anonymous * visitors legitimately make — and every call on a domain where no auth provider resolves, which * behaves exactly as `'oauth-code-ep'` did. */ export declare class TokenOauthRetryInterceptor implements HttpInterceptor { private readonly renewal; private readonly authService; private readonly appconfig; private readonly publicPaths; intercept(request: HttpRequest, next: HttpHandler): Observable>; /** Gets a token before the request leaves, rather than letting it go out anonymous. */ private sendAuthenticated; /** * Puts the watchdog back on the clock, but only when this request actually renewed the token. * * Rearming cancels and restarts the renewal chain, which also restarts the outage budget. Doing * that for every request would mean ordinary traffic silently resets the bound that stops a dead * refresh token being retried forever — so only a real renewal counts as recovery. */ private rearmIfRenewed; private handleWithRetry; private retryOnce; /** The same endpoints `TokenOauthInterceptor` matches: only those can answer 401. */ private isAuthenticatedEndpoint; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export 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; } export 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; } /** * The OIDC library configuration each provider is registered with. Exported for its spec — the * providers this file returns are opaque `EnvironmentProviders`, so nothing else can read them back. * * Everything here is written after the spread, so a provider cannot override it — except * `silentRenew`, which a host may need to set explicitly. See below. */ export declare function oidcConfigsFor(auth: AuthConfiguration): OpenIdConfiguration[]; /** * The startup renewal `AuthenticationService` runs before concluding nobody is signed in. * * Exported for its spec, like {@link oidcConfigsFor}. The `TokenRenewalService` lookups are * deliberately inside the methods rather than in the factory: the factory runs while * `AuthenticationService` is being constructed — it is the thing injecting this — and that service * injects `AuthenticationService` right back, so resolving it here would be NG0200. By the time * either method is called both exist. */ export declare function bootSessionRestorer(injector: Injector): BootSessionRestorer; export declare function provideRlbCodeBrowserOAuth(auth: AuthConfiguration | undefined): EnvironmentProviders; export 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; } export interface KeycloakDevice { os: string; osVersion: string; device: string; lastAccess: number; current: boolean; sessions: KeycloakSession[]; mobile: boolean; } export 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; } export interface KeycloakClient { clientId: string; clientName: string; userConsentRequired: boolean; inUse: boolean; offlineAccess: boolean; } export interface KeycloakCredential { type: string; category: string; displayName: string; helptext: string; iconCssClass: string; updateAction?: string; removeable: boolean; userCredentialMetadatas: KeycloakUserCredentialMetadata[]; createAction?: string; } export interface KeycloakUserCredentialMetadata { credential: _KeycloakCredential; } export interface _KeycloakCredential { id: string; type: string; userLabel: string; createdDate: number; credentialData: string; } export type ErrorOutput = 'dialog' | 'toast' | 'console'; export declare class LanguageService { private readonly translateService; private readonly cookiesService; private readonly i18nOptions; private readonly _language; private readonly _contentLanguage; readonly language: import("@angular/core").Signal; readonly contentLanguage: import("@angular/core").Signal; readonly languageChanged$: import("rxjs").Observable; readonly contentLanguageChanged: import("@angular/core").Signal; private readonly _ready$; readonly ready$: import("rxjs").Observable; 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, interpolateParams?: Object): any; translateAsync(key: string | Array, interpolateParams?: Object): import("rxjs").Observable; getLanguageName(l: string): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare class ErrorManagementService { private dialogService; private toastService; private languageService; private options; /** Last time each rendered (output, title, message) was shown. See `isDuplicate`. */ private readonly shownAt; constructor(dialogService: ModalService, toastService: ToastService, languageService: LanguageService, options: ProjectConfiguration); showError(type?: ModalType, out?: ErrorOutput, error?: any): Observable | null> | Observable<{ reason: string; }>; showDialog(type: ModalType, error?: any): Observable>; showToast(type: ModalType, error?: any): Observable | null>; manageUI(type?: ModalType, out?: ErrorOutput): OperatorFunction; /** * The one place a failure becomes words. * * An `HttpErrorResponse` gets the per-status message; anything else is already a message someone * wrote — an interceptor that rewrote a status it alone can recognise (a captcha 403 on two * specific routes, say), or a plain `throw` — and is passed through untouched. */ private describe; /** * True when the same message was already put on screen a moment ago. * * One rate limit or one dropped connection fails every request in flight at once, and each of * them arrives here. Identical text, same output, inside the window is that — not a second thing * for the user to read. */ private isDuplicate; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** * The Keycloak account API, with failures shown as a modal. * * Every method here is gated behind `filter(isAuthenticated)` and ends in * `manageUI('error', 'dialog')`, so a failure — or a token renewal that has stalled — completes the * stream without emitting and without erroring. That is fine for a single call bound straight to a * template, and unusable anywhere the caller needs to know what happened: it cannot distinguish * failure from an empty result, and inside a `forkJoin` it silently aborts every sibling call. * * Prefer `KeycloakAccountService` for anything composed. This service is kept as-is for the * existing callers, and for `configureOTP`/`updatePassword`, which are redirects rather than HTTP. */ export 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; updateUserProfile(data: KeycloakUser): Observable; getDevices(): Observable; getCredentials(): Observable; removeCredential(id: string): Observable; configureOTP(): void; updatePassword(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export interface KeycloakAccountCallOptions { /** Overrides the 10s default for this call. */ timeoutMs?: number; } /** * The Keycloak account API, in a shape a caller can compose with. * * `KeycloakProfileService` covers the same endpoints but cannot be composed: every method is gated * behind `filter(isAuthenticated)`, which after a failed token renewal simply never emits, and ends * in `manageUI('error', 'dialog')`, which opens a blocking modal and completes the stream *empty*. * Both mean the observable finishes without a value and without an error, so a caller can neither * tell success from failure nor stop a `forkJoin` from being silently aborted — one failing section * blanks a whole profile page. That is what happened during a provider outage, and it is why this * service exists. * * Here, reads **degrade**: a failure, a timeout, a missing token or an unresolved provider yields * the documented fallback (`null` / `[]`) rather than nothing at all, so a page renders with the * sections it could load. Writes **propagate**: the caller has to know whether the change landed. * Nothing opens a modal — how loudly to complain is the caller's decision. * * The redirect-based flows (`configureOTP`, `updatePassword`) stay on `KeycloakProfileService`; * they are not HTTP calls and have none of these problems. */ export declare class KeycloakAccountService { private readonly http; private readonly authService; /** The account API lives on the provider's own host, outside the endpoint interceptors' reach. */ private get baseUrl(); /** The signed-in user's profile, or null when it could not be read. */ user(options?: KeycloakAccountCallOptions): Observable; /** The user's sessions, flattened out of the devices that hold them; `[]` when unreadable. */ devices(options?: KeycloakAccountCallOptions): Observable; /** The user's credentials, or `[]` when they could not be read. */ credentials(options?: KeycloakAccountCallOptions): Observable; /** Updates the profile. Errors reach the caller. */ updateUser(data: KeycloakUser, options?: KeycloakAccountCallOptions): Observable; /** Removes a credential. Errors reach the caller. */ removeCredential(id: string, options?: KeycloakAccountCallOptions): Observable; /** * A read that always produces a value. * * No `isAuthenticated$` gate: that is the operator that turns a stalled renewal into a stream * which never emits. A missing token is handled by returning the fallback, which is a state the * caller can actually render. */ private read; /** A write, whose failures are the caller's to handle. */ private write; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export interface VerifyDeactivate { verifyDeactivate: () => boolean | Observable; } export declare const verifyDeactivate: CanDeactivateFn; export declare class ErrorModalComponent implements IModal, OnInit { data: import("@angular/core").InputSignal>; valid: import("@angular/core").ModelSignal; onEnter(): void; ngOnInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } export declare class ModalAppsComponent implements IModal { data: import("@angular/core").InputSignal>; valid: import("@angular/core").ModelSignal; result?: any; apps: AppInfo[]; appSelected(app: AppInfo): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } export declare function getDefaultRoutes(config?: PagesConfiguration): Routes; declare namespace as_pipe_d_exports { export { AsMultiPipe, AsSinglePipe }; } export declare class AsMultiPipe implements PipeTransform { transform(value: T | T[]): T[]; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } export declare class AsSinglePipe implements PipeTransform { transform(value: T | T[]): T; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace cms_pipe_d_exports { export { CmsPipe }; } export declare class CmsPipe implements PipeTransform { private cmsOptions; transform(value: string, ...args: unknown[]): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace left_component_pipe_d_exports { export { LeftComponentPipe }; } export declare class LeftComponentPipe implements PipeTransform { private config; transform(value: string): Type; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace mobile_component_pipe_d_exports { export { MobileComponentPipe }; } export declare class MobileComponentPipe implements PipeTransform { private config; transform(value: string): Type; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace right_component_pipe_d_exports { export { RightComponentPipe }; } export declare class RightComponentPipe implements PipeTransform { private config; transform(value: string): Type; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } export declare class SidebarFooterComponentPipe implements PipeTransform { private config; transform(value: string): Type; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace truncate_pipe_d_exports { export { TruncatePipe }; } export declare class TruncatePipe implements PipeTransform { transform(value?: string, limit?: number, completeWords?: boolean, ellipsis?: string): string | undefined; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare namespace autolink_pipe_d_exports { export { AutolinkPipe }; } export declare class AutolinkPipe implements PipeTransform { transform(value?: string, target?: string, rel?: string, id?: string): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } export declare abstract class AbstractSupportService { abstract sendSupport(data: any): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export 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; /** A method rather than a field, so specs can override it to exercise the production branch. */ protected isDevelopmentMode(): boolean; constructor(); readonly currentDomain: string; readonly apps: import("@angular/core").Signal; readonly currentApp: import("@angular/core").Signal | null>; readonly currentAppId: import("@angular/core").Signal; readonly currentAppAclInfo: import("@angular/core").Signal<{ busId: any; resId: any; } | null>; isAppSelected(appId: string): boolean; /** * Whether the user holds `action` in the app that is currently selected. * * `action` may be a list — any one of them grants. Note the asymmetry with * {@link AclStore.hasPermission}, which is deliberate and load-bearing: with no current app this * denies, while the store's no-action case means "any grant on the resource". */ checkPermissionInCurrentApp(action?: AclAction): boolean; /** * Whether the user holds `action` on any resource at all. * * For surfaces that no app owns — the `pages.*` chrome entries — where a resource-scoped check * has nothing to scope to. With no ACL configured nothing is gated, matching {@link apps}. */ checkPermissionAnywhere(action?: AclAction): 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?: AclAction): boolean; selectApp(app?: AppInfo, viewMode?: 'app' | 'settings', url?: string): void; /** * Settles which auth provider this domain uses, once, at startup. * * A domain no provider claims — or one that two claim — used to be a console warning, after which * the app carried on permanently and silently unauthenticated: every guard bounced, and `login()` * authorized against whichever configuration happened to be registered first. That is a * deployment error, not a warning, so it now throws in dev and logs at error level in prod. * * Configuring no providers at all stays a warning: an app without auth is legitimate. */ private initAuthProviders; private initRouterListener; private resolveRouteAndApps; private handleResolvedApps; private findDeepestChild; private getStoredAppId; private getAppViewMode; private isDefaultRoute; private getConfigPath; private getActualPath; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare class AppBreadcrumbService { private readonly router; private readonly route; private readonly loggerService; private readonly languageService; private readonly idService; private readonly _breadcrumbs; readonly breadcrumbs: import("@angular/core").Signal; /** * @deprecated Use `breadcrumbs` (signal-based) instead. */ readonly breadcrumbs$: import("rxjs").Observable; private logger; constructor(); private updateBreadcrumbs; private buildBreadcrumbFromRoot; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare const RLB_INIT_PROVIDER: InjectionToken; export interface RlbInitProvider { finalizeApps(resources: UserResource[], store: Store, acl: AclConfiguration | null): Promise; } /** * Registers `providers` only on the domains that should have them. * * `provideApp` spreads an `AppDescriber`'s providers into the **root** injector, unconditionally * and on every domain — `AppInfo.domains` filters what the shell *shows*, never what it *provides*. * So a host that registers several describers gives every tenant every describer's interceptors, * initializers and services. That is easy to miss: a tenant-local HTTP interceptor added to one * app's describer silently joins the chain on all the others, where it was never tested. * * Wrap anything tenant-local in this helper: * * ```ts * providers: [ * ...provideForDomains(PARTNER_DOMAINS, [ * { provide: HTTP_INTERCEPTORS, useClass: PartnerInterceptor, multi: true }, * ]), * ] * ``` * * The check runs while the providers array is being built — before bootstrap, in the browser — so * the providers are genuinely never registered rather than registered and then disabled at runtime. * * On the server there is no `location`, so nothing is registered; pass `hostname` explicitly for * SSR, and in specs, where it also makes the intent readable. */ export declare function provideForDomains(domains: readonly string[], providers: (Provider | EnvironmentProviders)[], hostname?: string): (Provider | EnvironmentProviders)[]; export interface CacheItem { data: T; expire: number; } export declare class LocalCacheService { private options; constructor(options: ProjectConfiguration); private clear; private readData; private storeData; getData(ob: Observable, cacheKey: string, expirationSec: number): Observable; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare abstract class AbstractMdService { constructor(); abstract md2html(md: string): string; abstract md2text(md: string): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export interface MenuItem { ContentId: string; Order: number; Title: string; page: Page; home: Home; menu_items: MenuItem[]; } export interface Home { ContentId: string; MenuName: string; Abstract: string; Content: string; Picture: any; Head: any; topics: Topic[]; } export interface Page { ContentId: string; Title: string; Content: string; page_tabs: Tab[]; topics: Topic[]; Cover: any; } export interface Topic { id: string; ContentId: string; Title: string; Content: string; Picture: any; page: Page; } export interface Tab { id: string; ContentId: string; Title: string; Icon: string; Content: string; FaqTitle: string; FaqContent: string; steps: Step[]; faqs: Faq[]; } export interface Step { ContentId: string; Title: string; Content: string; Picture: any; } export interface FaqGroup { ContentId: string; Title: string; Content: string; faqs: Faq[]; } export interface Faq { ContentId: string; Title: string; Content: string; Question: string; Answer: string; } export declare class StrapiService { private http; private cache; private cmsOptions; constructor(http: HttpClient, cache: LocalCacheService, cmsOptions: CmsConfiguration); fetchHome(lang: string, cid: string): Observable; fetchTopic(id: string): Observable; fetchTab(id: string): Observable; fetchFaqGroup(lang: string, cid: string): Observable; private _getGuideMenuPromise; getGuideMenu(lang: string, cid: string): Observable; fetchPage(lang: string, cid: string): Observable; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } /** i18n namespace searched when {@link HttpErrorMessagesConfiguration.keyPrefix} is unset. */ export declare const DEFAULT_HTTP_ERROR_KEY_PREFIX = "errors.http"; /** See {@link HttpErrorMessagesConfiguration.dedupeMs}. */ export declare const DEFAULT_HTTP_ERROR_DEDUPE_MS = 1000; /** What the error modal/toast actually renders. */ export interface HttpErrorDescription { title: string; message: string; } /** `LanguageService.translate`, narrowed to what the description needs. */ export type TranslateFn = (key: string, params?: object) => unknown; /** * `instanceof` plus the duck-type check the handler has always used. * * Both are needed. A response thrown by an `HttpClient` from a *different* copy of * `@angular/common/http` — a lazily loaded remote, a library bundled with its own — fails * `instanceof` while still being an `HttpErrorResponse` in every way that matters here. */ export declare function isHttpErrorResponse(error: unknown): error is HttpErrorResponse; /** * Seconds the server asked the caller to wait, or `undefined` when it did not say. * * RFC 9110 allows either delta-seconds or an HTTP-date, and both are seen in the wild. */ export declare function retryAfterSeconds(error: HttpErrorResponse): number | undefined; /** * Turns an `HttpErrorResponse` into the title and message to show the user. * * Falls back to the backend's own text when nothing is translated, so adding this to an app that * ships no `errors.http.*` keys changes nothing. */ export declare function describeHttpError(error: HttpErrorResponse, translate: TranslateFn, config?: HttpErrorMessagesConfiguration): HttpErrorDescription; export declare function provideRlbI18n(i18n?: InternationalizationConfiguration): (EnvironmentProviders | Provider)[]; export 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; } export declare function translateBrowserLoaderFactory(httpClient: HttpClient, transferState: TransferState): TranslateBrowserLoader; export declare class PwaUpdaterService { private readonly updates; private readonly modalService; private readonly languageService; private readonly _newVersionAvailable; readonly newVersionAvailable: import("@angular/core").Signal; get newVersionAvailable$(): import("rxjs").Observable; constructor(); update(): void; checkForUpdates(): Promise; checkWithDialog(): import("rxjs").Observable>; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare class UtilsService { isNumber(evt: any): boolean; toPlainDataObject(o: ({ [k: string]: any; } | { [k: string]: any; }[])): any; groupBy(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; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare const AppContextActionsInternal: { setLanguage: import("@ngrx/store").ActionCreator<"[AppContext/Internal] setLanguage", (props: { language: string; }) => { language: string; } & import("@ngrx/store").Action<"[AppContext/Internal] setLanguage">>; setCurrentApp: import("@ngrx/store").ActionCreator<"[AppContext/Internal] setCurrentApp", (props: { app: AppInfo | null; mode?: AppViewMode; url?: string; }) => { app: AppInfo | null; mode?: AppViewMode; url?: string; } & import("@ngrx/store").Action<"[AppContext/Internal] setCurrentApp">>; setSupportedLanguages: import("@ngrx/store").ActionCreator<"[AppContext/Internal] setSupportedLanguages", (props: { supportedLanguages: string[]; }) => { supportedLanguages: string[]; } & import("@ngrx/store").Action<"[AppContext/Internal] setSupportedLanguages">>; setTheme: import("@ngrx/store").ActionCreator<"[AppContext/Internal] setTheme", (props: { theme: AppTheme; }) => { theme: AppTheme; } & import("@ngrx/store").Action<"[AppContext/Internal] setTheme">>; addApp: import("@ngrx/store").ActionCreator<"[AppContext/Internal] addApp", (props: { app: AppInfo; }) => { app: AppInfo; } & import("@ngrx/store").Action<"[AppContext/Internal] addApp">>; setViewMode: import("@ngrx/store").ActionCreator<"[AppContext/Internal] setViewMode", (props: { viewMode?: AppViewMode; }) => { viewMode?: AppViewMode; } & import("@ngrx/store").Action<"[AppContext/Internal] setViewMode">>; }; export declare const AppContextActions: { setLanguage: import("@ngrx/store").ActionCreator<"[AppContext/API] setLanguage", (props: { language: string; }) => { language: string; } & import("@ngrx/store").Action<"[AppContext/API] setLanguage">>; setSupportedLanguages: import("@ngrx/store").ActionCreator<"[AppContext/API] setSupportedLanguages", (props: { supportedLanguages: string[]; }) => { supportedLanguages: string[]; } & import("@ngrx/store").Action<"[AppContext/API] setSupportedLanguages">>; setCurrentApp: import("@ngrx/store").ActionCreator<"[AppContext/API] setCurrentApp", (props: { app: AppInfo | null; mode?: AppViewMode; url?: string; }) => { app: AppInfo | null; mode?: AppViewMode; url?: string; } & import("@ngrx/store").Action<"[AppContext/API] setCurrentApp">>; removeApp: import("@ngrx/store").ActionCreator<"[AppContext/API] removeApp", (props: { appType: string; }) => { appType: string; } & import("@ngrx/store").Action<"[AppContext/API] removeApp">>; setTheme: import("@ngrx/store").ActionCreator<"[AppContext/API] setTheme", (props: { theme: AppTheme; }) => { theme: AppTheme; } & import("@ngrx/store").Action<"[AppContext/API] setTheme">>; finalizeApp: import("@ngrx/store").ActionCreator<"[AppContext/API] finalizeApp", (props: { appType: string; appId: string; data?: any; }) => { appType: string; appId: string; data?: any; } & import("@ngrx/store").Action<"[AppContext/API] finalizeApp">>; }; export declare class AuthFeatureService { private store; constructor(store: Store); login(): void; logout(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } export declare const AuthActionsInternal: { setCurrentProvider: import("@ngrx/store").ActionCreator<"[Auth/Internal] SetCurrentProvider", (props: { currentProvider: string; }) => { currentProvider: string; } & import("@ngrx/store").Action<"[Auth/Internal] SetCurrentProvider">>; setLoading: import("@ngrx/store").ActionCreator<"[Auth/Internal] SetLoading", (props: { loading: boolean; }) => { loading: boolean; } & import("@ngrx/store").Action<"[Auth/Internal] SetLoading">>; reset: import("@ngrx/store").ActionCreator<"[Auth/Internal] Reset", () => import("@ngrx/store").Action<"[Auth/Internal] Reset">>; }; export declare const AuthActions: { login: import("@ngrx/store").ActionCreator<"[Auth/API] Login", () => import("@ngrx/store").Action<"[Auth/API] Login">>; logout: import("@ngrx/store").ActionCreator<"[Auth/API] Logout", () => import("@ngrx/store").Action<"[Auth/API] Logout">>; setCurrentProvider: import("@ngrx/store").ActionCreator<"[Auth/API] SetCurrentProvider", (props: { currentProvider: string; }) => { currentProvider: string; } & import("@ngrx/store").Action<"[Auth/API] SetCurrentProvider">>; }; export declare const NavbarActionsInternal: {}; export declare const NavbarActions: { setVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetVisible">>; setSearchVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetSearchVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetSearchVisible">>; setHeader: import("@ngrx/store").ActionCreator<"[Navbar/API] SetHeader", (props: { header: NavbarHeader | null; }) => { header: NavbarHeader | null; } & import("@ngrx/store").Action<"[Navbar/API] SetHeader">>; setSearchText: import("@ngrx/store").ActionCreator<"[Navbar/API] SetSearchText", (props: { text: string | null; }) => { text: string | null; } & import("@ngrx/store").Action<"[Navbar/API] SetSearchText">>; setLeftItems: import("@ngrx/store").ActionCreator<"[Navbar/API] SetLeftItems", (props: { items: string[]; }) => { items: string[]; } & import("@ngrx/store").Action<"[Navbar/API] SetLeftItems">>; setRightItems: import("@ngrx/store").ActionCreator<"[Navbar/API] SetRightItems", (props: { items: string[]; }) => { items: string[]; } & import("@ngrx/store").Action<"[Navbar/API] SetRightItems">>; setMobileItems: import("@ngrx/store").ActionCreator<"[Navbar/API] SetMobileItems", (props: { items: string[]; }) => { items: string[]; } & import("@ngrx/store").Action<"[Navbar/API] SetMobileItems">>; setLoginVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetLoginVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetLoginVisible">>; setSettingsVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetSettingsVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetSettingsVisible">>; setAppsVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetAppsVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetAppsVisible">>; setSeparatorVisible: import("@ngrx/store").ActionCreator<"[Navbar/API] SetSeparatorVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Navbar/API] SetSeparatorVisible">>; setActionsLayout: import("@ngrx/store").ActionCreator<"[Navbar/API] SetActionsLayout", (props: { layout: NavbarActionsLayout; }) => { layout: NavbarActionsLayout; } & import("@ngrx/store").Action<"[Navbar/API] SetActionsLayout">>; }; export declare const SidebarActionsInternal: {}; export declare const SidebarActions: { setItems: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetItems", (props: { items: SidebarNavigableItem[]; }) => { items: SidebarNavigableItem[]; } & import("@ngrx/store").Action<"[Sidebar/API] SetItems">>; setVisible: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Sidebar/API] SetVisible">>; setLoginVisible: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetLoginVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Sidebar/API] SetLoginVisible">>; setAppsVisible: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetAppsVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Sidebar/API] SetAppsVisible">>; setSearchVisible: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetSearchVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Sidebar/API] SetSearchVisible">>; setSettingsVisible: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetSettingsVisible", (props: { visible: boolean; }) => { visible: boolean; } & import("@ngrx/store").Action<"[Sidebar/API] SetSettingsVisible">>; setSearchText: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetSearchText", (props: { text: string | null; }) => { text: string | null; } & import("@ngrx/store").Action<"[Sidebar/API] SetSearchText">>; setFooterComponent: import("@ngrx/store").ActionCreator<"[Sidebar/API] SetFooterComponent", (props: { name: string | null; }) => { name: string | null; } & import("@ngrx/store").Action<"[Sidebar/API] SetFooterComponent">>; }; export declare const AclStore: import("@angular/core").Type<{ resources: import("@angular/core").Signal; loading: import("@angular/core").Signal; loaded: import("@angular/core").Signal; error: import("@angular/core").Signal; hasPermission: (busId: string, resId: string, action?: AclAction) => boolean; hasPermissionAnywhere: (action?: AclAction) => boolean; loadACL: (providerAcl?: ProviderAclConfiguration) => import("rxjs").Observable; reset: () => void; } & import("@ngrx/signals").StateSource<{ resources: import("@open-rlb/ng-app").UserResource[] | null; loading: boolean; loaded: boolean; error: any; }>>; declare namespace app_container_component_d_exports { export { AppContainerComponent }; } export declare class AppContainerComponent { protected readonly Array: ArrayConstructor; private readonly templateSubject; readonly modalContainerId: import("@angular/core").InputSignal; readonly toastContainerIds: import("@angular/core").InputSignal; 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$(): import("rxjs").Observable; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace settings_dropdown_selector_component_d_exports { export { SettingsDropdownSelectorComponent }; } declare class SettingsDropdownSelectorComponent implements OnDestroy { mode: import("@angular/core").InputSignal<"desktop" | "mobile">; apps: import("@angular/core").InputSignal[]>; isAuthenticated: import("@angular/core").InputSignal; appSelected: import("@angular/core").OutputEmitterRef>; activeSlide: number; private readonly pageOptions; private readonly store; private readonly languageService; private readonly toastService; private readonly router; private readonly menu; private appsService; readonly pages: import("@angular/core").Signal; readonly languages: import("@angular/core").Signal<{ value: string; label: string; }[]>; readonly currentLanguage: import("@angular/core").Signal; readonly darkMode: import("@angular/core").Signal; readonly currentAppId: import("@angular/core").Signal; 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; /** * Whether this app's settings entry is offered to the current visitor. * * An app declaring `settings.auth: false` is public and is listed without a session — it used to * be hidden in exactly that case, which made the flag mean the opposite of its name. */ isAppVisible(app: AppInfo): boolean; /** * Whether a `pages.*` chrome entry is offered to the current visitor. * * Configured-or-not is the original condition; `action` is the ACL one, and omitting it keeps the * entry public. The route carries the same action (`getDefaultRoutes`), but a guard alone would * leave the button visible and bouncing. */ isPageVisible(key: string): boolean; private close; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace app_component_d_exports { export { AppTemplateComponent }; } export declare class AppTemplateComponent { protected readonly Array: ArrayConstructor; navSearchText: string | null; readonly modalContainerId: import("@angular/core").InputSignal; readonly breadcrumbInput: import("@angular/core").InputSignal; readonly breadcrumb: import("@angular/core").Signal; readonly toastContainerIds: import("@angular/core").InputSignal; readonly mobileOffcanvas: import("@angular/core").Signal; readonly mobileSettingsMenu: import("@angular/core").Signal; readonly env: import("@open-rlb/ng-app").EnvironmentConfiguration; readonly store: Store; readonly appsService: AppsService; private readonly authService; private readonly router; private readonly injector; readonly navbarSurfaceInjector: import("@angular/core").DestroyableInjector; readonly mobileSurfaceInjector: import("@angular/core").DestroyableInjector; readonly sidebarVisible: import("@angular/core").Signal; readonly sidearHasLogin: import("@angular/core").Signal; readonly sidearHasSearch: import("@angular/core").Signal; readonly sidebarItems: import("@angular/core").Signal; readonly sidebarFooter: import("@angular/core").Signal; readonly sidearHasSettings: import("@angular/core").Signal; readonly sidearAppsVisible: import("@angular/core").Signal; readonly navVisible: import("@angular/core").Signal; readonly navSearchVisible: import("@angular/core").Signal; readonly navHeader: import("@angular/core").Signal; readonly navLeftItems: import("@angular/core").Signal; readonly navRightItems: import("@angular/core").Signal; readonly navMobileItems: import("@angular/core").Signal; readonly navbarHasLogin: import("@angular/core").Signal; readonly navbarHasSettings: import("@angular/core").Signal; readonly navbarHasApps: import("@angular/core").Signal; readonly navbarLayout: import("@angular/core").Signal; readonly separatorVisible: import("@angular/core").Signal; readonly isAuthenticated: import("@angular/core").Signal; readonly userInfo: import("@angular/core").Signal; readonly theme: import("@angular/core").Signal; readonly apps: import("@angular/core").Signal; /** * Whether any registered app exposes settings that need no session. * * The chrome below is otherwise authenticated-only by design. This keeps the anonymous case * additive: with no public settings app — every consumer whose apps all declare `auth: true` — * this is false and the gates reduce to `isAuthenticated()`, exactly as before. */ readonly hasPublicSettings: import("@angular/core").Signal; /** Mirrors the mobile offcanvas body: false means the panel would render empty. */ readonly mobileMenuHasContent: import("@angular/core").Signal; 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; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace base_component_d_exports { export { BaseComponent }; } export declare class BaseComponent { private readonly breakpointObserver; private readonly platformId; readonly breadcrumbInput: import("@angular/core").InputSignal; readonly breadcrumb: import("@angular/core").Signal; readonly title: import("@angular/core").InputSignal; readonly subtitle: import("@angular/core").InputSignal; readonly isHandset: import("@angular/core").Signal; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace cms_component_d_exports { export { CmsComponent }; } export declare class CmsComponent { private readonly strapiService; private readonly languageService; private readonly cmsOptions; private readonly mdService; readonly contentId: import("@angular/core").InputSignal; readonly breadcrumbInput: import("@angular/core").InputSignal; readonly breadcrumb: import("@angular/core").Signal; readonly page: import("@angular/core").Signal; md(md: string): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace content_component_d_exports { export { ContentComponent }; } export declare class ContentComponent { private readonly breakpointObserver; private readonly platformId; readonly isHandset: import("@angular/core").Signal; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } export declare class ToastComponent implements IToast { data: import("@angular/core").InputSignal>; valid?: boolean; result?: any; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace cms_content_component_d_exports { export { CmsContentComponent }; } declare class CmsContentComponent { private readonly route; readonly contentId: import("@angular/core").Signal; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace cookies_component_d_exports { export { CookiesComponent }; } declare class CookiesComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace not_found_component_d_exports { export { NotFoundComponent }; } declare class NotFoundComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace privacy_component_d_exports { export { PrivacyComponent }; } declare class PrivacyComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace support_component_d_exports { export { SupportComponent }; } declare class SupportComponent implements OnInit { private readonly supportService; private readonly _location; readonly supportForm: FormGroup<{ name: FormControl; email: FormControl; subject: FormControl; message: FormControl; legal: FormControl; }>; hasError(form: string, controlName: string, errorName: string): boolean | undefined; sendSupport(data: any): void; backClicked(): void; ngOnInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace terms_and_conditions_component_d_exports { export { TermsAndConditionsComponent }; } declare class TermsAndConditionsComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace forbidden_component_d_exports { export { ForbiddenComponent }; } declare class ForbiddenComponent { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare namespace app_dropdown_selector_component_d_exports { export { AppDropdownSelectorComponent }; } declare class AppDropdownSelectorComponent { mode: import("@angular/core").InputSignal<"desktop" | "mobile">; apps: import("@angular/core").InputSignal[]>; isAuthenticated: import("@angular/core").InputSignal; appSelected: import("@angular/core").OutputEmitterRef>; private appsService; readonly currentAppId: import("@angular/core").Signal; selectApp(app: AppInfo): void; isAppSelected(appId: string | undefined): boolean; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } export declare class RlbAppModule { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } export declare function provideRlbConfig(env: ProjectConfiguration): (EnvironmentProviders | Provider)[]; /** * Registers an app with the shell: its `AppInfo`, its routes and its providers. * * **`app.providers` and `app.routes` land in the root injector on every domain.** `AppInfo.domains` * gates what the shell shows and which app the router selects — it does not gate registration, and * cannot: `AppsService` needs every `AppInfo` for the app hub, for domain filtering and for * `findAppForPath`, and unregistering routes would turn a cross-tenant deep link into a shell 404 * instead of letting the guards answer it. * * So anything in `providers` that must only run on some domains — an HTTP interceptor, an app * initializer — has to say so itself. Wrap it in {@link provideForDomains}. */ export declare function provideApp(app: AppDescriber): (EnvironmentProviders | Provider)[]; export type { LogLevel };