@reforgium/presentia 1.4.4 → 2.0.0

package/types/reforgium-presentia.d.ts

@@ -1,7 +1,7 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { InjectionToken, Signal, PipeTransform, EnvironmentProviders } from '@angular/core';
 import * as _reforgium_internal from '@reforgium/internal';
-import { Devices, Langs, Themes } from '@reforgium/internal';
+import { Devices, Langs, Themes as Themes$1 } from '@reforgium/internal';
 import { HttpHeaders, HttpParams, HttpContext } from '@angular/common/http';
 
 /** Breakpoints for different device types */
@@ -75,35 +75,44 @@ declare class AdaptiveService {
      * Updates automatically when screen width changes
      * or when specified breakpoints are crossed (`DEVICE_BREAKPOINTS`).
      */
-    device: i0.Signal<Devices>;
+    device: _angular_core.Signal<Devices>;
     /**
      * Current browser window width in pixels.
      * Updates reactively on `resize` event.
      */
-    width: i0.Signal<number>;
+    width: _angular_core.Signal<number>;
     /**
      * Current browser window height in pixels.
      * Updates reactively on `resize` event.
      */
-    height: i0.Signal<number>;
+    height: _angular_core.Signal<number>;
     /**
      * Computed signal indicating whether the current device is a desktop.
      * Used for conditional rendering or layout configuration.
      */
-    isDesktop: i0.Signal<boolean>;
+    isDesktop: _angular_core.Signal<boolean>;
+    isMobile: _angular_core.Signal<boolean>;
+    isTablet: _angular_core.Signal<boolean>;
+    isDesktopSmall: _angular_core.Signal<boolean>;
     /**
      * Computed signal determining whether the screen is in portrait orientation.
      * Returns `true` if window height is greater than width.
      */
-    isPortrait: i0.Signal<boolean>;
+    isPortrait: _angular_core.Signal<boolean>;
     private deviceBreakpoints;
     private devicePriority;
     private destroyRef;
     private breakpointObserver;
     private isBrowser;
+    private resizeDebounceId;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AdaptiveService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AdaptiveService>;
+    breakpoint(): Devices;
+    is(device: Devices | readonly Devices[]): boolean;
+    isAtLeast(device: Devices): boolean;
+    isBetween(min: Devices, max: Devices): boolean;
+    private deviceRank;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdaptiveService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AdaptiveService>;
 }
 
 /**
@@ -128,6 +137,8 @@ declare class AdaptiveService {
  */
 declare class IfDeviceDirective {
     private readonly deviceInput;
+    private readonly atLeastInput;
+    private readonly betweenInput;
     private readonly inverseInput;
     private readonly tpl;
     private readonly vcr;
@@ -137,10 +148,12 @@ declare class IfDeviceDirective {
     private readonly currentDevice;
     constructor();
     set reIfDevice(value: Devices | Devices[] | undefined);
+    set reIfDeviceAtLeast(value: Devices | undefined);
+    set reIfDeviceBetween(value: readonly [Devices, Devices] | undefined);
     set inverse(value: boolean | undefined);
     private updateView;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IfDeviceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<IfDeviceDirective, "[reIfDevice]", never, { "reIfDevice": { "alias": "reIfDevice"; "required": false; }; "inverse": { "alias": "inverse"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IfDeviceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IfDeviceDirective, "[reIfDevice],[reIfDeviceAtLeast],[reIfDeviceBetween]", never, { "reIfDevice": { "alias": "reIfDevice"; "required": false; }; "reIfDeviceAtLeast": { "alias": "reIfDeviceAtLeast"; "required": false; }; "reIfDeviceBetween": { "alias": "reIfDeviceBetween"; "required": false; }; "inverse": { "alias": "inverse"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -221,6 +234,38 @@ type LangNamespaceCacheConfig = {
     maxNamespaces?: number;
     ttlMs?: number;
 };
+type LangRouteNamespaceManifest = Record<string, readonly string[]>;
+type LangRouteNamespacePreloadMode = 'blocking' | 'lazy';
+type LangRouteNamespacePreloadMergeStrategy = 'append' | 'replace';
+type LangRouteNamespacePreloadErrorMode = 'continue' | 'throw';
+type LangRouteNamespacePreloadConfig = {
+    mode?: LangRouteNamespacePreloadMode;
+    dataKey?: string;
+    manifest?: LangRouteNamespaceManifest;
+    mergeStrategy?: LangRouteNamespacePreloadMergeStrategy;
+    onError?: LangRouteNamespacePreloadErrorMode;
+    diagnostics?: boolean;
+};
+/**
+ * Adapter for custom persistence of language/theme selection.
+ * Implement this interface to replace the default `localStorage` storage.
+ */
+type PersistenceAdapter = {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+};
+/**
+ * Describes a failed namespace load attempt.
+ * Exposed via `LangService.errors()` signal.
+ */
+type LoadNamespaceError = {
+    namespace: string;
+    lang: Langs;
+    /** HTTP status code, or `null` for non-HTTP failures. */
+    status: number | null;
+    /** Request URL that produced the error. */
+    url: string;
+};
 /**
  * Represents configuration settings for localization.
  *
@@ -243,6 +288,7 @@ type LangNamespaceCacheConfig = {
  * - `batchRequestBuilder` optional URL builder hook for batched namespace loading.
  * - `batchResponseAdapter` optional transformer hook for batched API payloads.
  * - `namespaceCache` optional ttl/lru-like cache controls for loaded namespaces.
+ * - `routeNamespacePreload` optional route-aware namespace preload settings.
  */
 interface LocaleConfig {
     url: string;
@@ -259,11 +305,31 @@ interface LocaleConfig {
     batchRequestBuilder?: LangBatchRequestBuilder;
     batchResponseAdapter?: LangBatchResponseAdapter;
     namespaceCache?: LangNamespaceCacheConfig;
+    routeNamespacePreload?: LangRouteNamespacePreloadConfig;
+    /**
+     * Maximum number of namespaces per batch request.
+     * When the namespace list exceeds this limit the load is split into multiple batch requests.
+     * No limit by default.
+     */
+    maxBatchSize?: number;
 }
 declare const innerLangVal: unique symbol;
 
 declare const LANG_MISSING_KEY_HANDLER: InjectionToken<LangMissingKeyHandler>;
 
+/**
+ * Optional DI token for a custom persistence adapter used by `LangService`
+ * to store and retrieve the selected language (default key: `'lang'`).
+ *
+ * When not provided the service falls back to `localStorage` directly.
+ *
+ * Example:
+ * ```ts
+ * { provide: LANG_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
+ * ```
+ */
+declare const LANG_PERSISTENCE_ADAPTER: InjectionToken<PersistenceAdapter>;
+
 /**
  * Injection token for providing locale configuration to the language module.
  *
@@ -313,6 +379,7 @@ declare class LangService {
     private readonly http;
     private readonly isBrowser;
     private readonly missingKeyHandler;
+    private readonly routeNamespaceDiagnostics;
     private readonly supportedLangSet;
     /**
      * Computed property determining the current language setting.
@@ -322,7 +389,7 @@ declare class LangService {
      * - If `config.kgValue` is not defined, the property will return the default value 'kg'.
      * - For other languages (e.g. `ru`, `en`) returns source language as-is.
      */
-    readonly currentLang: Signal<"ru" | "kg" | "en" | (string & {}) | "ky">;
+    readonly currentLang: Signal<(string & {}) | "ru" | "kg" | "en" | "ky">;
     /**
      * Extracts readonly value from private property `#lang` and assigns it to `innerLangVal`.
      * Expected that property `#lang` has `asReadonly` method that returns immutable representation.
@@ -347,6 +414,8 @@ declare class LangService {
      */
     get(query: LangKey, params?: LangParams): string;
     get(query: string, params?: LangParams): string;
+    has(query: LangKey): boolean;
+    has(query: string): boolean;
     /**
      * Observes changes to a specified translation key and dynamically computes its value.
      *
@@ -368,6 +437,9 @@ declare class LangService {
     loadNamespace(ns: string): Promise<void>;
     isNamespaceLoaded(ns: string): boolean;
     loadNamespaces(namespaces: readonly string[]): Promise<void>;
+    private loadNamespaceBatch;
+    private normalizeMaxBatchSize;
+    private chunkNamespaces;
     evictNamespace(ns: string): void;
     clearNamespaceCache(): void;
     private parseModelToRecord;
@@ -393,8 +465,8 @@ declare class LangService {
     private resolveMissingValue;
     private normalizeLang;
     private normalizeSupportedLangs;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LangService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LangService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LangService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LangService>;
 }
 
 /**
@@ -445,7 +517,7 @@ declare class LangDirective {
      * Localization mode: defines which parts of the element will be translated.
      * @default 'all'
      */
-    lang: i0.InputSignal<string | LangDirectiveConfig>;
+    lang: _angular_core.InputSignal<string | LangDirectiveConfig>;
     /**
      * Explicit key for text content translation.
      */
@@ -457,7 +529,7 @@ declare class LangDirective {
     /**
      * Name of an additional attribute to localize (besides standard `title`, `label`, `placeholder`).
      */
-    langForAttr: i0.InputSignal<string | undefined>;
+    langForAttr: _angular_core.InputSignal<string | undefined>;
     private el;
     private renderer;
     private service;
@@ -509,8 +581,8 @@ declare class LangDirective {
      * @returns localized string
      */
     private getLangValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LangDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LangDirective, "[reLang]", never, { "lang": { "alias": "reLang"; "required": false; "isSignal": true; }; "langForAttr": { "alias": "langForAttr"; "required": false; "isSignal": true; }; "reLangKey": { "alias": "reLangKey"; "required": false; }; "reLangAttrs": { "alias": "reLangAttrs"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LangDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LangDirective, "[reLang]", never, { "lang": { "alias": "reLang"; "required": false; "isSignal": true; }; "langForAttr": { "alias": "langForAttr"; "required": false; "isSignal": true; }; "reLangKey": { "alias": "reLangKey"; "required": false; }; "reLangAttrs": { "alias": "reLangAttrs"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -529,6 +601,7 @@ declare class LangDirective {
  */
 declare class LangPipe implements PipeTransform {
     private readonly cache;
+    private readonly warnedUnresolved;
     private readonly lang;
     private readonly injector;
     private readonly config;
@@ -538,8 +611,9 @@ declare class LangPipe implements PipeTransform {
     transform(query: string | null | undefined, params?: LangParams | null): string;
     private makeKey;
     private evictIfNeeded;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LangPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<LangPipe, "lang", true>;
+    private warnUnresolvedKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LangPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LangPipe, "lang", true>;
 }
 
 type LangPipeConfig = {
@@ -549,21 +623,49 @@ type LangPipeConfig = {
 };
 declare const LANG_PIPE_CONFIG: InjectionToken<LangPipeConfig>;
 
+type BaseTheme = _reforgium_internal.Themes;
+type Theme = BaseTheme | (string & {});
+/**
+ * @deprecated Prefer `Theme`.
+ */
+type Themes = Theme;
+
+type ThemeDomStrategy = 'root-class' | 'data-attribute';
+type ThemeClassNameBuilder = (theme: Theme) => string;
+interface ThemeDomConfig {
+    strategy?: ThemeDomStrategy;
+    rootSelector?: string;
+    darkThemePrefix?: string;
+    attributeName?: string;
+    themeClassPrefix?: string;
+    classNameBuilder?: ThemeClassNameBuilder;
+}
 /**
  * Configuration options for theme management.
  * Defines the default theme and prefix for dark theme variants.
  */
 interface ThemeConfig {
+    /**
+     * Explicit list of supported themes.
+     * Values outside this registry are ignored and fallback to the default theme.
+     * @optional
+     */
+    registry?: readonly Theme[];
     /**
      * The default theme to be applied when no other theme is specified.
      * @optional
      */
-    defaultTheme?: Themes;
+    defaultTheme?: Theme;
     /**
      * Prefix string used to identify and apply dark theme variants.
      * @optional
      */
     darkThemePrefix?: string;
+    /**
+     * DOM application strategy for the active theme.
+     * @optional
+     */
+    dom?: ThemeDomConfig;
 }
 
 /**
@@ -582,29 +684,14 @@ interface ThemeConfig {
  * const isDarkTheme = theme === themes.dark;
  * ```
  */
-declare const themes: Record<Themes, Themes>;
+declare const themes: Record<Themes$1, Themes$1>;
 /**
- * CSS class prefix used for dark theme styling.
- *
- * This constant defines the prefix applied to HTML elements when the dark theme is active.
- * It is typically added to the root element or specific components to enable dark theme styles.
- *
- * @example
- * ```typescript
- * document.body.classList.add(darkThemePrefix); // Applies 're-dark' class
- * ```
+ * @deprecated Prefer `theme.dom.darkClassName` via `providePresentia(...)`.
  */
 declare const darkThemePrefix = "re-dark";
 
 /**
- * Default theme configuration object.
- *
- * Defines the initial theme settings for the application.
- * By default, sets the light theme as the active theme.
- *
- * This configuration can be overridden when providing `THEME_CONFIG` token
- * at the module or application level.
- * ```
+ * @deprecated Prefer configuring themes through `providePresentia({ theme: ... })`.
  */
 declare const defaultThemeConfig: {
     defaultTheme: _reforgium_internal.Themes;
@@ -628,6 +715,23 @@ declare const defaultThemeConfig: {
  */
 declare const THEME_CONFIG: InjectionToken<ThemeConfig>;
 
+/**
+ * @deprecated Prefer configuring theme persistence through `providePresentia({ theme: { persistence... } })`.
+ */
+declare const defaultThemePersistenceAdapter: PersistenceAdapter;
+/**
+ * DI token for the persistence adapter used by `ThemeService`
+ * to store and retrieve the selected theme (default key: `'theme'`).
+ *
+ * By default `presentia` provides a `localStorage`-backed adapter.
+ *
+ * Example:
+ * ```ts
+ * { provide: THEME_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
+ * ```
+ */
+declare const THEME_PERSISTENCE_ADAPTER: InjectionToken<PersistenceAdapter>;
+
 /**
  * Service for managing application theme.
  *
@@ -644,8 +748,15 @@ declare const THEME_CONFIG: InjectionToken<ThemeConfig>;
 declare class ThemeService {
     #private;
     private readonly config;
+    private readonly registry;
     private readonly themeDefault;
+    private readonly domStrategy;
     private readonly darkPrefix;
+    private readonly attributeName;
+    private readonly themeClassPrefix;
+    private readonly classNameBuilder;
+    private readonly rootSelector;
+    private readonly persistence;
     private readonly isBrowser;
     private readonly document;
     /**
@@ -657,12 +768,13 @@ declare class ThemeService {
      * <div [class]="themeService.theme()"></div>
      * ```
      */
-    theme: i0.Signal<Themes>;
+    theme: _angular_core.Signal<Theme>;
     /**
      * Convenient flag returning `true` if the light theme is active.
      * Suitable for conditional style application or resource selection.
      */
-    isLight: i0.Signal<boolean>;
+    isLight: _angular_core.Signal<boolean>;
+    isDark: _angular_core.Signal<boolean>;
     constructor();
     /**
      * Switches theme.
@@ -672,11 +784,25 @@ declare class ThemeService {
      *
      * @param theme — explicit theme value (`'light'` or `'dark'`).
      */
-    switch(theme?: Themes): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+    switch(theme?: Theme): void;
+    is(theme: Theme | readonly Theme[]): boolean;
+    private resolveTheme;
+    private resolveRegistry;
+    private resolveInitialTheme;
+    private getStoredTheme;
+    private persistTheme;
+    private applyThemeToDom;
+    private nextTheme;
+    private resolveRootElement;
+    private resolveThemeClassName;
+    private clearThemeClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
 }
 
+/**
+ * @deprecated Prefer `PresentiaConfig` with `providePresentia(...)` for the grouped v2 API.
+ */
 interface AppConfig {
     locale: LocaleConfig;
     theme?: ThemeConfig;
@@ -684,8 +810,67 @@ interface AppConfig {
     langPipe?: LangPipeConfig;
     langMissingKeyHandler?: LangMissingKeyHandler;
 }
+/**
+ * @deprecated Prefer `providePresentia(...)` for new integrations.
+ */
 declare function provideReInit(config: AppConfig): EnvironmentProviders;
 
+type PresentiaLangConfig = {
+    source: {
+        url: string;
+        fromAssets: boolean;
+        defaultLang?: Langs;
+        fallbackLang?: Langs;
+        supportedLangs?: readonly string[];
+        kgValue?: 'kg' | 'ky';
+    };
+    rendering?: {
+        placeholder?: string | ((query: string) => string);
+        missingValue?: string;
+    };
+    preload?: {
+        global?: readonly string[];
+        routes?: LangRouteNamespacePreloadConfig;
+    };
+    transport?: {
+        requestBuilder?: LangRequestBuilder;
+        requestOptionsFactory?: LangRequestOptionsFactory;
+        responseAdapter?: LangResponseAdapter;
+        batchRequestBuilder?: LangBatchRequestBuilder;
+        batchResponseAdapter?: LangBatchResponseAdapter;
+        maxBatchSize?: number;
+    };
+    cache?: LangNamespaceCacheConfig;
+    diagnostics?: {
+        lateNamespaceLoads?: boolean;
+    };
+    missingKeyHandler?: LangMissingKeyHandler;
+};
+type PresentiaThemeConfig = {
+    registry?: readonly Theme[];
+    defaultTheme?: ThemeConfig['defaultTheme'];
+    persistence?: 'localStorage' | 'none';
+    persistenceAdapter?: PersistenceAdapter;
+    dom?: {
+        strategy?: 'root-class' | 'data-attribute';
+        rootSelector?: string;
+        darkClassName?: string;
+        attributeName?: string;
+        classPrefix?: string;
+        classNameBuilder?: (theme: Theme) => string;
+    };
+};
+type PresentiaAdaptiveConfig = {
+    breakpoints?: DeviceBreakpoints;
+    strategy?: 'width';
+};
+interface PresentiaConfig {
+    lang: PresentiaLangConfig;
+    theme?: PresentiaThemeConfig;
+    adaptive?: PresentiaAdaptiveConfig;
+}
+declare function providePresentia(config: PresentiaConfig): EnvironmentProviders;
+
 /**
  * Open Graph meta tags type definition.
  * Used for social media sharing preview configuration.
@@ -775,8 +960,8 @@ declare class SeoService {
     setJsonLd(schema: object): void;
     private upsert;
     private upsertLink;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SeoService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SeoService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeoService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SeoService>;
 }
 
 /**
@@ -800,8 +985,9 @@ declare class SeoService {
 declare class SeoRouteListener {
     private router;
     private seo;
-    private ar;
     private destroyRef;
+    private initialized;
+    private baseUrl;
     /**
      * Initializes the route listener to monitor navigation events and update SEO metadata.
      * Subscribes to router NavigationEnd events and automatically unsubscribes on component destruction.
@@ -810,60 +996,77 @@ declare class SeoRouteListener {
      *                  Trailing slashes will be removed automatically.
      */
     init(baseUrl: string): void;
-    /**
-     * Recursively finds the deepest (most nested) activated route in the route tree.
-     * This is used to extract route data from the currently active leaf route.
-     *
-     * @param r - The root activated route to start traversing from.
-     * @returns The deepest child route in the hierarchy.
-     */
-    private deepest;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SeoRouteListener, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SeoRouteListener>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeoRouteListener, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SeoRouteListener>;
 }
 
+type RouteWatcherReadStrategy = 'deepest' | 'merged';
+
+type RouteWatcherState = {
+    params: Record<string, string>;
+    deepestParams: Record<string, string>;
+    query: Record<string, string>;
+    data: Record<string, unknown>;
+    mergedData: Record<string, unknown>;
+    url: string;
+    routePattern: string;
+    fragment: string | null;
+};
 /**
  * Reactive snapshot of the current route (the deepest active route).
  * Updates on every `NavigationEnd` event.
- *
- * Provides:
- * - `params` / `query` — strings (as in Angular Router)
- * - `data` — arbitrary data (from route configuration/resolvers)
- * - `url` — string assembled from `UrlSegment[]`
- * - `fragment` — hash (#section)
- * - `selectData(key)` — type-safe selector for `data`
- * - `state` — combined computed object (convenient for single subscriber)
  */
 declare class RouteWatcher {
     #private;
     private readonly router;
     private readonly destroyRef;
-    /** Signal for tracking and retrieving URL parameters */
-    readonly params: i0.Signal<Record<string, string>>;
-    /** Signal for tracking and retrieving query parameters */
-    readonly query: i0.Signal<Record<string, string>>;
-    /** Signal for tracking and retrieving route data */
-    readonly data: i0.Signal<Record<string, unknown>>;
-    /** Signal for tracking and retrieving URL */
-    readonly url: i0.Signal<string>;
-    /** Signal for tracking and retrieving URL fragment */
-    readonly fragment: i0.Signal<string | null>;
-    /** Combined computed snapshot (to avoid multiple effects) */
-    readonly state: i0.Signal<{
-        params: Record<string, string>;
-        query: Record<string, string>;
-        data: Record<string, unknown>;
-        url: string;
-        fragment: string | null;
-    }>;
+    /** Params merged from root to deepest route. */
+    readonly params: _angular_core.Signal<Record<string, string>>;
+    /** Params declared on the deepest route only. */
+    readonly deepestParams: _angular_core.Signal<Record<string, string>>;
+    /** Query params from the current navigation. */
+    readonly query: _angular_core.Signal<Record<string, string>>;
+    /** Deepest route data only. */
+    readonly data: _angular_core.Signal<Record<string, unknown>>;
+    /** Route data merged from root to deepest route. */
+    readonly mergedData: _angular_core.Signal<Record<string, unknown>>;
+    /** Full current url path assembled from root to deepest route. */
+    readonly url: _angular_core.Signal<string>;
+    /** Current route config pattern, e.g. `orgs/:orgId/users/:id`. */
+    readonly routePattern: _angular_core.Signal<string>;
+    /** Current url fragment without `#`. */
+    readonly fragment: _angular_core.Signal<string | null>;
+    /** Combined computed snapshot. */
+    readonly state: _angular_core.Signal<RouteWatcherState>;
     constructor();
-    /** Convenient selector for a data key with type-safe casting */
-    selectData<T = unknown>(key: string): i0.Signal<T | undefined>;
+    selectData<T = unknown>(key: string, strategy?: RouteWatcherReadStrategy): _angular_core.Signal<T | undefined>;
+    selectParam(key: string, strategy?: RouteWatcherReadStrategy): _angular_core.Signal<string | undefined>;
+    matchesPath(path: string | RegExp): boolean;
     private deepestSnapshot;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RouteWatcher, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RouteWatcher>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouteWatcher, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RouteWatcher>;
+}
+
+declare const PRESENTIA_ROUTE_NAMESPACES_DATA_KEY = "presentiaNamespaces";
+declare function providePresentiaRouteNamespacePreload(): _angular_core.EnvironmentProviders;
+
+/**
+ * @deprecated Diagnostics are usually enabled through route preload config, not by consuming this service directly.
+ */
+declare class RouteNamespaceDiagnosticsService {
+    private readonly router;
+    private readonly enabled;
+    private readonly warned;
+    private currentUrl;
+    private currentNamespaces;
+    private navigationSettled;
+    constructor();
+    registerRouteNamespaces(url: string, namespaces: readonly string[]): void;
+    warnLateNamespaceLoad(namespace: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouteNamespaceDiagnosticsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RouteNamespaceDiagnosticsService>;
 }
 
-export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, innerLangVal, provideReInit, themes };
-export type { AppConfig, DeviceBreakpoints, LangBatchRequestBuilder, LangBatchRequestContext, LangBatchResponseAdapter, LangBatchResponseContext, LangDirectiveConfig, LangDirectiveMode, LangDto, LangHttpRequestOptions, LangKey, LangKeyRegistry, LangMissingKeyHandler, LangModel, LangNamespaceCacheConfig, LangParamValue, LangParams, LangPipeConfig, LangRequestBuilder, LangRequestContext, LangRequestOptionsFactory, LangResponseAdapter, LangResponseContext, LocaleConfig, OgType, ThemeConfig, TwitterCardType };
+export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PERSISTENCE_ADAPTER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, PRESENTIA_ROUTE_NAMESPACES_DATA_KEY, RouteNamespaceDiagnosticsService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, THEME_PERSISTENCE_ADAPTER, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, defaultThemePersistenceAdapter, innerLangVal, providePresentia, providePresentiaRouteNamespacePreload, provideReInit, themes };
+export type { AppConfig, BaseTheme, DeviceBreakpoints, LangBatchRequestBuilder, LangBatchRequestContext, LangBatchResponseAdapter, LangBatchResponseContext, LangDirectiveConfig, LangDirectiveMode, LangDto, LangHttpRequestOptions, LangKey, LangKeyRegistry, LangMissingKeyHandler, LangModel, LangNamespaceCacheConfig, LangParamValue, LangParams, LangPipeConfig, LangRequestBuilder, LangRequestContext, LangRequestOptionsFactory, LangResponseAdapter, LangResponseContext, LangRouteNamespaceManifest, LangRouteNamespacePreloadConfig, LangRouteNamespacePreloadMergeStrategy, LangRouteNamespacePreloadMode, LoadNamespaceError, LocaleConfig, OgType, PersistenceAdapter, PresentiaAdaptiveConfig, PresentiaConfig, PresentiaLangConfig, PresentiaThemeConfig, RouteWatcherReadStrategy, RouteWatcherState, Theme, ThemeConfig, Themes, TwitterCardType };
 //# sourceMappingURL=reforgium-presentia.d.ts.map