@ethlete/core 5.0.0-next.4 → 5.0.0-next.41

package/types/ethlete-core.d.ts

@@ -1,15 +1,16 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, AfterViewInit, Signal, ComponentRef, StaticProvider, EmbeddedViewRef, Provider, InjectOptions, TemplateRef, QueryList, InputSignal, InputSignalWithTransform, PipeTransform, TrackByFunction, ElementRef, WritableSignal, DestroyRef, Injector, RendererStyleFlags2, OnInit, OnDestroy } from '@angular/core';
+import { InjectionToken, AfterViewInit, EmbeddedViewRef, ElementRef, QueryList, Signal, WritableSignal, InputSignalWithTransform, Provider, RendererStyleFlags2, Type, ComponentRef, Injector, ViewContainerRef, StaticProvider, Binding, computed, InjectOptions, TemplateRef, InputSignal, PipeTransform, TrackByFunction, ApplicationRef } from '@angular/core';
 import * as rxjs from 'rxjs';
 import { Observable, BehaviorSubject, Subject } from 'rxjs';
 import * as _ethlete_core from '@ethlete/core';
-import { OverlayRef } from '@angular/cdk/overlay';
-import { ComponentPortal, ComponentType } from '@angular/cdk/portal';
-import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
+import * as _floating_ui_dom from '@floating-ui/dom';
+import { VirtualElement, Placement, OffsetOptions, Padding } from '@floating-ui/dom';
 import { MatchListView, ParticipantViewUnion, MatchRankingView, StageType } from '@ethlete/types';
 import * as _angular_platform_browser from '@angular/platform-browser';
-import { FormGroup, AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
-import { Data, Params, Event as Event$1 } from '@angular/router';
+import { AbstractControl, FormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+import * as _angular_router from '@angular/router';
+import { Data, Params, Router } from '@angular/router';
+import { FieldTree } from '@angular/forms/signals';
 
 declare const ANIMATABLE_TOKEN: InjectionToken<AnimatableDirective>;
 type AnimationEndEvent = {
@@ -36,6 +37,14 @@ declare class AnimatableDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatableDirective, "[etAnimatable]", ["etAnimatable"], {}, {}, never, never, true, never>;
 }
 
+declare const ANIMATION_DEBUG_STORAGE_KEY = "et-overlay-debug";
+/**
+ * Debug logging for overlay and animation lifecycle internals.
+ * Enable via `localStorage.setItem('et-overlay-debug', 'true')` and reload.
+ */
+declare const isAnimationDebugEnabled: () => boolean;
+declare const animationDebugLog: (scope: string, ...args: unknown[]) => void;
+
 declare const ANIMATED_IF_TOKEN: InjectionToken<AnimatedIfDirective>;
 declare class AnimatedIfDirective {
     private templateRef;
@@ -77,187 +86,23 @@ declare class AnimatedLifecycleDirective implements AfterViewInit {
     private removeClass;
     private removeClasses;
     private updateState;
+    private debugLog;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatedLifecycleDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatedLifecycleDirective, "[etAnimatedLifecycle]", ["etAnimatedLifecycle"], { "skipNextEnter": { "alias": "skipNextEnter"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "skipNextEnter": "skipNextEnterChange"; }, never, never, true, [{ directive: typeof AnimatableDirective; inputs: {}; outputs: {}; }]>;
 }
 
-type ThemeRGBColor = `${number} ${number} ${number}`;
-type ThemeHSLColor = `${number} ${number}% ${number}%`;
-type ThemeColor = ThemeRGBColor | ThemeHSLColor;
-type ThemeColorMap = {
-    default: ThemeColor;
-    hover: ThemeColor;
-    focus?: ThemeColor;
-    active: ThemeColor;
-    disabled: ThemeColor;
-};
-type OnThemeColorMap = {
-    default: ThemeColor;
-    hover?: ThemeColor;
-    focus?: ThemeColor;
-    active?: ThemeColor;
-    disabled?: ThemeColor;
-};
-type ThemeSwatch = {
-    color: ThemeColorMap;
-    onColor: OnThemeColorMap;
-};
-type Theme = {
-    name: string;
-    isDefault?: boolean;
-    isDefaultAlt?: boolean;
-    primary: ThemeSwatch;
-    secondary?: ThemeSwatch;
-    tertiary?: ThemeSwatch;
-};
-declare const createCssThemeName: (name: string) => string;
-declare const ɵProvideColorThemes: (valueOverride?: (string | undefined)[] | undefined) => _angular_core.Provider[];
-declare const injectColorThemes: {
-    (): string[];
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): string[];
-    (options: _angular_core.InjectOptions): string[] | null;
-};
-declare const ɵProvideThemesPrefix: (valueOverride?: string | undefined) => _angular_core.Provider[];
-declare const injectThemesPrefix: {
-    (): string;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): string;
-    (options: _angular_core.InjectOptions): string | null;
-};
-declare const provideColorThemesWithTailwind4: (themes: Theme[], prefix?: string) => _angular_core.Provider[][];
-
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createSwatchCss: (swatch: string, isAlt: boolean, data: ThemeSwatch) => string;
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createRootThemeCss: (themes: Theme[]) => void;
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createThemeStyle: (theme: Theme, isAlt: boolean) => void;
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createTailwindCssVar: (name: string | undefined) => string | null;
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createTailwindRgbVar: (val: string | undefined) => string | null;
-/**
- * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
- */
-declare const createTailwindColorThemes: (themes: Theme[], prefix?: string) => Record<string, {
-    DEFAULT: string;
-    hover: string;
-    focus: string;
-    active: string;
-    disabled: string;
-}>;
-/**
- * @deprecated Use provideColorThemesWithTailwind4 instead after migrating to Tailwind CSS v4. Intent to remove in v6.
- */
-declare const provideColorThemes: (themes: Theme[]) => _angular_core.Provider[][];
-
-declare const THEME_PROVIDER: InjectionToken<ProvideThemeDirective>;
-declare class ProvideThemeDirective {
-    private themes;
-    private prefix;
-    private injector;
-    private currentProviderSync;
-    mainTheme: _angular_core.InputSignal<string | null | undefined>;
-    altTheme: _angular_core.InputSignal<string | null | undefined>;
-    mainThemeName: _angular_core.Signal<string | undefined>;
-    altThemeName: _angular_core.Signal<string | undefined>;
-    protected themeClass: _angular_core.Signal<string>;
-    syncWithProvider(provider: ProvideThemeDirective): void;
-    stopSyncWithProvider(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProvideThemeDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ProvideThemeDirective, "[etProvideTheme]", never, { "mainTheme": { "alias": "etProvideTheme"; "required": false; "isSignal": true; }; "altTheme": { "alias": "etProvideAltTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-type AnimatedOverlayComponentBase = {
-    animatedLifecycle: Signal<AnimatedLifecycleDirective | undefined>;
-    setThemeFromProvider: (provider: ProvideThemeDirective) => void;
-};
-type AnimatedOverlayMountConfig<T> = {
-    component: ComponentType<T>;
-    providers?: StaticProvider[];
-    data?: Partial<T>;
-    themeProvider?: ProvideThemeDirective | null;
-};
-type AnimatedOverlayState = 'init' | 'mounting' | 'mounted' | 'unmounting' | 'unmounted';
-declare class AnimatedOverlayDirective<T extends AnimatedOverlayComponentBase> {
-    private overlayService;
-    private injector;
-    private viewContainerRef;
-    private zone;
-    private elementRef;
-    private rootBoundary;
-    private destroyRef;
-    private floatingElCleanupFn;
-    private unmountSubscription;
-    placement: _angular_core.InputSignal<Placement | undefined>;
-    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
-    offset: _angular_core.InputSignal<OffsetOptions | null>;
-    arrowPadding: _angular_core.InputSignal<Padding | null>;
-    viewportPadding: _angular_core.InputSignal<Padding | null>;
-    autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    shift: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    autoHide: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    autoCloseIfReferenceHidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    referenceElement: _angular_core.InputSignal<HTMLElement>;
-    mirrorWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    portal: ComponentPortal<T> | null;
-    overlayRef: OverlayRef | null;
-    componentRef: ComponentRef<T> | null;
-    beforeOpened$: Subject<void>;
-    afterOpened$: Subject<void>;
-    beforeClosed$: Subject<void>;
-    afterClosed$: Subject<void>;
-    state: _angular_core.WritableSignal<AnimatedOverlayState>;
-    isMounted: Signal<boolean>;
-    isMounting: Signal<boolean>;
-    isUnmounted: Signal<boolean>;
-    isUnmounting: Signal<boolean>;
-    canMount: Signal<boolean>;
-    canUnmount: Signal<boolean>;
-    isHidden: _angular_core.WritableSignal<boolean>;
-    isMounted$: rxjs.Observable<boolean>;
-    isMounting$: rxjs.Observable<boolean>;
-    isUnmounted$: rxjs.Observable<boolean>;
-    isUnmounting$: rxjs.Observable<boolean>;
-    canMount$: rxjs.Observable<boolean>;
-    canUnmount$: rxjs.Observable<boolean>;
-    isHidden$: rxjs.Observable<boolean>;
-    referenceElementDimensions: Signal<_ethlete_core.NullableElementDimensions>;
-    constructor();
-    mount(config: AnimatedOverlayMountConfig<T>): T | undefined;
-    unmount(): void;
-    private applyComponentData;
-    private applyThemeProvider;
-    private updateOverlaySize;
-    private setupFloatingUI;
-    private getFloatingArrow;
-    private updateFloatingPosition;
-    private buildFloatingMiddleware;
-    private applyFloatingStyles;
-    private applyArrowStyles;
-    private handleReferenceHidden;
-    private waitForRenderAndAnimate;
-    private destroy;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatedOverlayDirective<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatedOverlayDirective<any>, "[etAnimatedOverlay]", ["etAnimatedOverlay"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; "isSignal": true; }; "referenceElement": { "alias": "referenceElement"; "required": false; "isSignal": true; }; "mirrorWidth": { "alias": "mirrorWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 declare const nextFrame: (cb: () => void) => void;
 declare const fromNextFrame: () => Observable<void>;
 declare const forceReflow: (element?: HTMLElement) => number;
+/**
+ * Whether the user asked for reduced motion, read straight from `matchMedia`.
+ *
+ * Inside a component, prefer the reactive `injectPrefersReducedMotion()`. This is for the animation
+ * helpers that run from effects, event handlers and imperative APIs, where there is no injection
+ * context. Pass the element being animated so the query resolves against its own window - otherwise
+ * an animation inside an iframe would read the top-level document's preference.
+ */
+declare const matchesReducedMotion: (element?: Element) => boolean;
 
 type FlipAnimationGroupConfig = {
     /**
@@ -277,6 +122,15 @@ type FlipAnimationGroupConfig = {
      * @default 'cubic-bezier(0.4, 0, 0.2, 1)'
      */
     easing?: string;
+    /**
+     * Play the animation even when the user prefers reduced motion.
+     *
+     * Only set this for movement that carries meaning the user would otherwise miss - decorative
+     * movement should stay gated.
+     *
+     * @default false
+     */
+    ignoreReducedMotion?: boolean;
 };
 declare const createFlipAnimationGroup: (config: FlipAnimationGroupConfig) => {
     updateInit: () => void;
@@ -306,6 +160,15 @@ type FlipAnimationConfig = {
      * @default 'cubic-bezier(0.4, 0, 0.2, 1)'
      */
     easing?: string;
+    /**
+     * Play the animation even when the user prefers reduced motion.
+     *
+     * Only set this for movement that carries meaning the user would otherwise miss - decorative
+     * movement should stay gated.
+     *
+     * @default false
+     */
+    ignoreReducedMotion?: boolean;
 };
 declare const createFlipAnimation: (config: FlipAnimationConfig) => {
     updateInit: () => void;
@@ -335,1287 +198,2248 @@ declare class RepeatDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RepeatDirective, "[etRepeat]", never, { "repeatCount": { "alias": "etRepeat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const createComponentId: (prefix: string) => string;
+declare class ScrollObserverEndDirective {
+    private elementRef;
+    private host;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollObserverEndDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollObserverEndDirective, "[etScrollObserverEnd]", never, {}, {}, never, never, true, never>;
+}
 
-declare const createDestroy: () => rxjs.Observable<boolean>;
+declare class ScrollObserverStartDirective {
+    private elementRef;
+    private host;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollObserverStartDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollObserverStartDirective, "[etScrollObserverStart]", never, {}, {}, never, never, true, never>;
+}
 
-declare const injectHostElement: <T = HTMLElement>() => T;
-declare const injectTemplateRef: <C = unknown>() => TemplateRef<C>;
-type CreateProviderOptions = {
+type SignalElementBindingComplexType = HTMLElement | ElementRef<HTMLElement> | QueryList<ElementRef<HTMLElement> | HTMLElement> | Array<ElementRef<HTMLElement> | HTMLElement> | null | undefined;
+type SignalElementBindingType = HTMLElement | ElementRef<HTMLElement> | Observable<SignalElementBindingComplexType> | Signal<SignalElementBindingComplexType> | QueryList<ElementRef<HTMLElement> | HTMLElement> | ElementSignal;
+type ElementSignal = Signal<{
+    currentElements: HTMLElement[];
+    previousElements: HTMLElement[];
+}>;
+type ElementSignalValue = ReturnType<ElementSignal>;
+declare const isElementSignal: (el: unknown) => el is ElementSignal;
+declare const createDocumentElementSignal: () => ElementSignal;
+declare const createEmptyElementSignal: () => ElementSignal;
+declare const buildElementSignal: (el: SignalElementBindingType | null | undefined) => ElementSignal;
+declare const firstElementSignal: (el: ElementSignal) => Signal<{
+    currentElement: HTMLElement | null;
+    previousElement: HTMLElement | null;
+}>;
+
+type AnimatedSizeAxis = 'block' | 'inline';
+type AnimatedBlockSizeConfig = {
+    /** The element whose size is animated. Defaults to the host `ElementRef`. */
+    host?: SignalElementBindingType;
     /**
-     * Optional name for the provider, useful for debugging.
-     * If not provided, the name will be a generated string.
+     * The content element(s) whose size changes drive the animation. Observe the content (children),
+     * **not** the animated host - observing the host would feed the animation back into itself.
+     * For the `inline` axis this also means the observed content must be content-sized (e.g.
+     * `inline-size: max-content`); a plain block child just mirrors the host's animated width back.
      */
-    name?: string;
+    observe: SignalElementBindingType | SignalElementBindingType[];
     /**
-     * Optional existing InjectionToken to also provide the created provider under.
+     * The axes to animate. May be a signal - e.g. to drop the `inline` axis while a panel is in a
+     * presentation whose width follows the viewport instead of its content. @default ['block']
      */
-    extraInjectionToken?: InjectionToken<unknown>;
+    axes?: AnimatedSizeAxis[] | Signal<AnimatedSizeAxis[]>;
+    /** Animation duration in ms. @default 160 */
+    duration?: number;
+    /** Animation easing. @default 'ease' */
+    easing?: string;
+    /** Class toggled on the host while animating - use it to `overflow: clip` during the resize. */
+    resizingClass?: string;
 };
-type ProviderResult<T> = readonly [
-    provide: () => Provider[],
-    inject: {
-        (): T;
-        (options: InjectOptions & {
-            optional?: false;
-        }): T;
-        (options: InjectOptions): T | null;
-    },
-    token: InjectionToken<T>
-];
-type StaticProviderResult<T> = readonly [
-    provide: (valueOverride?: Partial<T>) => Provider[],
-    inject: {
-        (): T;
-        (options: InjectOptions & {
-            optional?: false;
-        }): T;
-        (options: InjectOptions): T | null;
-    },
-    token: InjectionToken<T>
-];
-type RootProviderResult<T> = readonly [
-    inject: {
-        (): T;
-        (options: InjectOptions & {
-            optional?: false;
-        }): T;
-        (options: InjectOptions): T | null;
-    },
-    token: InjectionToken<T>
-];
-declare const createProvider: <T>(factory: () => T, options?: CreateProviderOptions) => ProviderResult<T>;
-declare const createRootProvider: <T>(factory: () => T, options?: CreateProviderOptions) => ProviderResult<T>;
-declare const createStaticProvider: <T>(defaultValue?: T, options?: CreateProviderOptions) => StaticProviderResult<T>;
-declare const createStaticRootProvider: <T>(defaultValue?: T, options?: CreateProviderOptions) => StaticProviderResult<T>;
-
-declare const cloneFormGroup: <T extends FormGroup<any>>(formGroup: T) => T;
-declare const getFormGroupValue: <T extends FormGroup>(formGroup: T) => Record<string, unknown>;
-
-declare const createRxHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, options?: EventListenerOptions) => rxjs.Observable<HTMLElementEventMap[K]>;
-declare const applyHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, options?: EventListenerOptions) => rxjs.Subscription;
-declare const applyHostListeners: (listeners: Partial<{ [K in keyof HTMLElementEventMap]: (event: HTMLElementEventMap[K]) => void; }>, options?: EventListenerOptions) => void;
-
-declare class TypedQueryList<T> extends QueryList<T> {
-    get changes(): Observable<TypedQueryList<T>>;
-}
-declare function switchQueryListChanges(): <T extends TypedQueryList<unknown> | null | undefined>(source: Observable<T>) => Observable<T>;
-
 /**
- * Sets the value of an input signal.
- * See issue: https://github.com/angular/angular/issues/54782
+ * Smoothly animates an element's `block-size` (and optionally `inline-size`, via `axes`) when its
+ * content changes size (e.g. a list filtering, a loading state resolving, a column being added).
+ * Set up once in an injection context; it observes the given content element(s) and animates the
+ * host from its previous size to its new natural size.
+ *
+ * Robustness notes: the baseline size is captured on the first render (via `afterNextRender`) and
+ * only later changes animate, so the initial layout settling never plays as a grow-from-0.
+ * A change that interrupts an in-flight animation continues from the current animated size, and
+ * zero/pre-layout measurements are ignored. Respects `prefers-reduced-motion`.
+ *
+ * The animation starts synchronously inside the `ResizeObserver` callback - it runs after layout
+ * but **before paint**, so the host never paints a frame at its new natural size. Routing the
+ * resize through a signal + effect instead would apply the animation one change-detection cycle
+ * (= one painted frame) late: a growing panel would flash at its final size, snap back, and only
+ * then animate.
  */
-declare const setInputSignal: <T>(input: InputSignal<T> | InputSignalWithTransform<T, unknown>, value: T) => void;
+declare const injectAnimatedBlockSize: (config: AnimatedBlockSizeConfig) => void;
 
-type NgClassType = string | string[] | Set<string> | {
-    [klass: string]: any;
-} | null | undefined;
-
-declare const AT_LEAST_ONE_REQUIRED = "atLeastOneRequired";
-type ValidateAtLeastOneRequiredConfig = {
+declare const previousSignalValue: <T>(signal: Signal<T>) => Signal<T | undefined>;
+type SyncSignalOptions = {
     /**
-     * Keys of form controls to validate in the supplied form group
+     * If true, the target signal will not be updated with the source signal's value in a sync operation.
+     * This should be set to true for signals that need to be initialized first before syncing (eg. required inputs)
+     * @default false
      */
-    keys: string[];
+    skipSyncRead?: boolean;
     /**
-     * If true, the value `false` will result in a validation error
+     * If true, the first time the effect will be triggered will be skipped.
      * @default false
      */
-    checkFalse?: boolean;
-};
-declare const ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
-declare const IS_ARRAY_NOT_EMPTY = "isArrayNotEmpty";
-declare const IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
-declare const IS_EMAIL = "isEmail";
-declare const IsEmail: (control: AbstractControl) => ValidationErrors | null;
-declare const MUST_MATCH = "mustMatch";
-declare const MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
-    mustMatch: boolean;
-} | null;
-declare const Validators: {
-    readonly MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
-        mustMatch: boolean;
-    } | null;
-    readonly IsEmail: (control: AbstractControl) => ValidationErrors | null;
-    readonly IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
-    readonly ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
-};
-
-declare const clone: <T>(original: T) => T;
-declare const equal: (foo: any, bar: any) => boolean;
-
-declare const hasCookie: (name: string) => boolean;
-declare const getCookie: (name: string) => string | null | undefined;
-declare const setCookie: (name: string, data: string, expiresInDays?: number | null, domain?: string | null, path?: string, sameSite?: "strict" | "none" | "lax") => void;
-declare const deleteCookie: (name: string, path?: string, domain?: string | null) => void;
-declare const getDomain: () => string | null;
-
-type Translatable = {
-    i18n: string;
-    text: string;
-};
-
-declare class KeyPressManager {
-    readonly key: number;
-    private readonly _isKeyPressed$;
-    private readonly _keyPressCount$;
-    private readonly _stopTimeout$;
-    constructor(key: number);
-    isPressed(event: KeyboardEvent): boolean;
-    clear(): void;
-}
-
-declare const DISABLE_LOGGER_PARAM = "et-logger-quiet";
-type CreateLoggerConfig = {
-    scope: string;
-    feature: string;
-};
-declare const createLogger: (config: CreateLoggerConfig) => {
-    log: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
+    skipFirstRun?: boolean;
 };
-
-declare const clamp: (value: number, min?: number, max?: number) => number;
-declare const round: (value: number, precision?: number) => number;
-
-declare const isObject: (value: unknown) => value is Record<string, unknown>;
-declare const isArray: (value: unknown) => value is unknown[];
-declare const getObjectProperty: (obj: Record<string, unknown>, prop: string) => unknown;
-
-declare const RUNTIME_ERROR_NO_DATA = "__ET_NO_DATA__";
-declare class RuntimeError<T extends number> extends Error {
-    code: T;
-    devOnly: boolean;
-    data: unknown;
-    constructor(code: T, message: null | false | string, devOnly?: boolean, data?: unknown);
-}
-declare function formatRuntimeError<T extends number>(code: T, message: null | false | string, devOnly: boolean): string;
-
+declare const syncSignal: <T>(from: Signal<T>, to: WritableSignal<T>, options?: SyncSignalOptions) => _angular_core.EffectRef;
+type MaybeSignal<T> = T | Signal<T>;
+declare const maybeSignalValue: <T>(value: MaybeSignal<T>) => T;
+/**
+ * A computed that will only be reactive until the source signal contains a truthy value.
+ * All subsequent changes inside the computation will be ignored.
+ */
+declare const computedTillTruthy: <T>(source: Signal<T>) => Signal<T | null>;
 /**
- * Checks if an element or the viewport can scroll in a given direction.
- * @param element The element to check. If null/undefined, checks if the viewport can scroll.
- * @param direction The direction to check. If not provided, checks both directions.
- * @returns true if the element or viewport can scroll in the given direction.
+ * A computed that will only be reactive until the source signal contains a falsy value.
+ * All subsequent changes inside the computation will be ignored.
  */
-declare const elementCanScroll: (element?: HTMLElement | null, direction?: "x" | "y") => boolean;
-type IsElementVisibleOptions = {
+declare const computedTillFalsy: <T>(source: Signal<T>) => Signal<T | null>;
+/**
+ * A writeable signal that will be set to the provided value once all inputs are set.
+ * During that time, the signal will be set to `null`.
+ */
+declare const deferredSignal: <T extends () => unknown>(valueFn: T) => WritableSignal<ReturnType<T> | null>;
+declare const memoizeSignal: <T>(factory: () => Signal<T>) => () => Signal<T>;
+
+type SignalAnimatedNumberOptions = {
     /**
-     * The element to check if it is visible inside a container.
+     * The initial value to start animating from.
+     * If not provided, the animation will start from 0
      */
-    element?: HTMLElement | null;
+    initialValue?: number;
     /**
-     * The container to check if the element is visible inside.
-     * If null or undefined, uses the viewport as the container.
-     * @default null (viewport)
-     */
-    container?: HTMLElement | null;
-    /**
-     * The container's rect to check if the element is visible inside. Can be supplied to reduce the amount of DOM reads.
-     * Only used when container is provided and not null.
-     * @default container.getBoundingClientRect()
-     */
-    containerRect?: DOMRect | null;
-    /**
-     * The element's rect. Can be supplied to reduce the amount of DOM reads.
-     * @default element.getBoundingClientRect()
-     */
-    elementRect?: DOMRect | null;
-};
-type CurrentElementVisibility = {
-    /**
-     * Whether the element is visible in the inline direction.
-     */
-    inline: boolean;
-    /**
-     * Whether the element is visible in the block direction.
-     */
-    block: boolean;
-    /**
-     * The percentage of the element that is visible in the inline direction.
-     */
-    inlineIntersection: number;
-    /**
-     * The percentage of the element that is visible in the block direction.
-     */
-    blockIntersection: number;
-    /**
-     * Whether the element is intersecting the container.
+     * Duration of the animation in milliseconds.
+     * @default 1000
      */
-    isIntersecting: boolean;
+    duration?: number;
     /**
-     * The ratio of the element that is intersecting the container.
+     * Easing function that takes a progress value (0 to 1) and returns an eased value (0 to 1).
+     * Options:
+     * - `easeLinear()`
+     * - `easeIn()`
+     * - `easeOut()`
+     * - `easeInOut()`
+     * - `easeElastic()`
+     * - `easeOutBack()`
+     * - `easeOutBackStrong()`
+     * @default easeOut()
      */
-    intersectionRatio: number;
+    easing?: (t: number) => number;
     /**
-     * The element that is being checked for visibility.
+     * Function to round the animated value.
+     * @default (v: number) => Math.round(v)
      */
-    element: HTMLElement;
+    round?: (value: number) => number;
     /**
-     * The container's rect used for the calculation.
+     * Callback invoked when the animation starts.
      */
-    containerRect: DOMRect;
+    onAnimationStart?: () => void;
     /**
-     * The element's rect used for the calculation.
+     * Callback invoked when the animation ends.
      */
-    elementRect: DOMRect;
+    onAnimationEnd?: () => void;
 };
-declare const isElementVisible: (options: IsElementVisibleOptions) => CurrentElementVisibility | null;
-declare const getElementScrollCoordinates: (options: ScrollToElementOptions) => ScrollToOptions;
-type ScrollToElementOptions = {
-    /**
-     * The element to scroll to.
-     */
-    element?: HTMLElement | null;
-    /**
-     * The scroll container to scroll to the element in.
-     * Must be provided - cannot scroll the viewport programmatically with this function.
-     */
-    container?: HTMLElement | null;
-    /**
-     * The direction to scroll in.
-     * @default 'both'
-     */
-    direction?: 'inline' | 'block' | 'both';
-    /**
-     * The origin of the element to scroll to.
-     * @default 'nearest'
-     */
-    origin?: 'start' | 'end' | 'center' | 'nearest';
+type AnimatedNumberSignal = Signal<number> & {
     /**
-     * The scroll behavior.
-     * @default 'smooth'
+     * Starts the animation from the current value to the target value.
+     * @returns The animated signal for chaining
      */
-    behavior?: ScrollBehavior;
+    play: () => AnimatedNumberSignal;
     /**
-     * The scroll inline-margin
-     * @default 0
+     * Resets the animation to the initial value and stops any ongoing animation.
+     * @returns The animated signal for chaining
      */
-    scrollInlineMargin?: number;
+    reset: () => AnimatedNumberSignal;
     /**
-     * The scroll block-margin
-     * @default 0
+     * Stops the current animation at its current position.
+     * @returns The animated signal for chaining
      */
-    scrollBlockMargin?: number;
+    stop: () => AnimatedNumberSignal;
 };
-declare const scrollToElement: (options: ScrollToElementOptions) => void;
+/**
+ * Creates a signal that animates the transition of a numeric signal's value over time.
+ */
+declare const signalAnimatedNumber: (source: MaybeSignal<number>, options?: SignalAnimatedNumberOptions) => AnimatedNumberSignal;
+declare const easeLinear: (t: number) => number;
+declare const easeIn: (t: number) => number;
+declare const easeOut: (t: number) => number;
+declare const easeInOut: (t: number) => number;
+/** Elastic easing function (overshoots) */
+declare const easeElastic: (t: number) => number;
+/** Back easing function (overshoots slightly then settles) */
+declare const easeOutBack: (t: number) => number;
+/** Back easing function with more overshoot */
+declare const easeOutBackStrong: (t: number) => number;
 
-declare class NormalizeGameResultTypePipe implements PipeTransform {
-    transform: (type: string | null) => NormalizedGameResultType | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeGameResultTypePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeGameResultTypePipe, "etNormalizeGameResultType", true>;
-}
-type NormalizedGameResultType = Translatable & {
-    shortCode: string;
+type Vec2 = [number, number];
+type ViewportConfig = {
+    breakpoints: {
+        xs: Vec2;
+        sm: Vec2;
+        md: Vec2;
+        lg: Vec2;
+        xl: Vec2;
+        '2xl': Vec2;
+    };
 };
-declare const normalizeGameResultType: (type: string | null) => NormalizedGameResultType | null;
-
-declare class NormalizeMatchParticipantsPipe implements PipeTransform {
-    transform: (match: MatchListView | null) => NormalizedMatchParticipants | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchParticipantsPipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchParticipantsPipe, "etNormalizeMatchParticipants", true>;
-}
-type NormalizedMatchParticipants = {
-    home: NormalizedMatchParticipant | null;
-    away: NormalizedMatchParticipant | null;
+type Breakpoint = keyof ViewportConfig['breakpoints'];
+declare const BREAKPOINT_ORDER: Breakpoint[];
+/**
+ * Default viewport config based on Tailwind CSS.
+ * @see https://tailwindcss.com/docs/screens
+ */
+declare const DEFAULT_VIEWPORT_CONFIG: ViewportConfig;
+declare const provideViewportConfig: (valueOverride?: Partial<ViewportConfig> | undefined) => _angular_core.Provider[];
+declare const injectViewportConfig: _ethlete_core.InjectFn<ViewportConfig>;
+type BuildMediaQueryOptions = {
+    min?: number | Breakpoint;
+    max?: number | Breakpoint;
 };
-type NormalizedParticipantType = 'team' | 'player' | 'unknown';
-type NormalizedMatchParticipant = ({
-    type: 'tbd';
-    participantType: NormalizedParticipantType;
-    data: ParticipantViewUnion | null;
-} & Translatable) | {
-    type: 'participant';
-    participantType: NormalizedParticipantType;
-    data: ParticipantViewUnion;
-} | ({
-    type: 'none';
-    participantType: NormalizedParticipantType;
-    data: ParticipantViewUnion | null;
-} & Translatable);
-declare const normalizeMatchParticipants: (match: MatchListView | null) => NormalizedMatchParticipants | null;
-declare const normalizeMatchParticipant: (match: MatchListView | null, side: "home" | "away") => NormalizedMatchParticipant | null;
+declare const provideBreakpointObserver: () => _angular_core.Provider[];
+declare const injectBreakpointObserver: _ethlete_core.InjectFn<{
+    observeBreakpoint: (options: BuildMediaQueryOptions) => Signal<boolean>;
+    isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
+    getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
+    buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
+    observeMediaQuery: (mediaQuery: string) => Signal<boolean>;
+    isMediaQueryMatched: (mediaQuery: string) => boolean;
+}>;
 
-declare class NormalizeMatchScorePipe implements PipeTransform {
-    transform: (match: MatchListView | null | undefined) => NormalizedMatchScore | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchScorePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchScorePipe, "etNormalizeMatchScore", true>;
-}
-declare const enum MatchStateType {
-    PREPARING_ROUND = "preparingRound",
-    PRE_MATCH = "preMatch",
-    LIVE = "live",
-    POST_MATCH = "postMatch",
-    AUTO_WIN = "autoWin"
-}
-type NormalizedMatchScore = {
-    home: {
-        score: string | number | null;
-        isWinner: boolean;
-    };
-    away: {
-        score: string | number | null;
-        isWinner: boolean;
-    };
-    subLine: string | null;
-    isNumeric: boolean;
+type BreakpointMap<T> = Partial<Record<Breakpoint, T>>;
+type BreakpointInput<T> = T | BreakpointMap<T>;
+declare const breakpointTransformBase: <T, WriteT = BreakpointInput<T>>(coerce: (value: WriteT) => T) => ((value: WriteT) => T);
+/**
+ * Transform factory for boolean inputs.
+ * Coerces plain values with `booleanAttribute`; resolves {@link BreakpointMap} mobile-first.
+ *
+ * @example
+ * snap = input(false, { transform: boolBreakpointTransform() });
+ * // Template: `snap` | `[snap]="true"` | `[snap]="{ xs: false, md: true }"`
+ */
+declare const boolBreakpointTransform: () => ((value: BreakpointInput<boolean> | string) => boolean);
+/**
+ * Transform factory for number inputs.
+ * Coerces plain values with `numberAttribute`; resolves {@link BreakpointMap} mobile-first.
+ *
+ * @example
+ * scrollMargin = input(0, { transform: numberBreakpointTransform() });
+ * // Template: `[scrollMargin]="16"` | `[scrollMargin]="{ xs: 0, md: 16 }"`
+ */
+declare const numberBreakpointTransform: () => ((value: BreakpointInput<number> | string) => number);
+/**
+ * Transform factory for any typed input (string unions, arrays, objects, etc.).
+ * Passes plain values through as-is; resolves {@link BreakpointMap} mobile-first.
+ * A value is treated as a {@link BreakpointMap} only when all its keys are valid breakpoint names.
+ *
+ * @example
+ * itemSize = input('auto', { transform: typedBreakpointTransform<ScrollableItemSize>() });
+ * tags = input([], { transform: typedBreakpointTransform<string[]>() });
+ * // Template: `[itemSize]="'third'"` | `[itemSize]="{ xs: 'full', md: 'third' }"`
+ */
+declare const typedBreakpointTransform: <T>() => ((value: BreakpointInput<T>) => T);
+type BoolBreakpointSignal = InputSignalWithTransform<boolean, BreakpointInput<boolean> | string>;
+type NumberBreakpointSignal = InputSignalWithTransform<number, BreakpointInput<number> | string>;
+type TypedBreakpointSignal<T> = InputSignalWithTransform<T, BreakpointInput<T>>;
+declare const injectBreakpointInput: <T>(inputSignal: Signal<BreakpointInput<T>>, defaultValue: T) => Signal<T>;
+declare const booleanBreakpointAttribute: (value: unknown) => BreakpointInput<boolean>;
+declare const numberBreakpointAttribute: (value: unknown) => BreakpointInput<number>;
+declare const BREAKPOINT_INSTANCE_TOKEN: InjectionToken<unknown>;
+declare const provideBreakpointInstance: (componentClass: unknown) => {
+    provide: InjectionToken<unknown>;
+    useExisting: unknown;
 };
-declare const normalizeMatchScore: (match: MatchListView | null | undefined) => NormalizedMatchScore | null;
-declare const isKnockoutMatch: (match: MatchListView | null | undefined) => boolean;
-declare const isGroupMatch: (match: MatchListView | null | undefined) => boolean;
-declare const getKnockoutMatchScore: (score: MatchRankingView | null | undefined) => "match-score.knockout.won" | "match-score.knockout.lost" | "match-score.knockout.tie" | null;
-declare const getMatchScoreSubLine: (match: MatchListView | null | undefined) => "match-score.groups.sub-line" | null;
-declare const getGroupMatchScore: (match: MatchListView | null | undefined) => {
-    home: {
-        score: number;
-        isWinner: boolean;
-    };
-    away: {
-        score: number;
-        isWinner: boolean;
-    };
-} | null;
-declare const getGroupMatchPoints: (match: MatchListView | null | undefined) => {
-    home: {
-        score: number;
-        isWinner: boolean;
-    };
-    away: {
-        score: number;
-        isWinner: boolean;
-    };
-} | null;
 
-declare class NormalizeMatchStatePipe implements PipeTransform {
-    transform: (match: MatchListView | null | undefined) => MatchStateType | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchStatePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchStatePipe, "etNormalizeMatchState", true>;
-}
-declare const normalizeMatchState: (match: MatchListView | null | undefined) => MatchStateType | null;
+type ControlValueSignalOptions = {
+    debounceTime?: number;
+    /**
+     * @default false
+     */
+    debounceFirst?: boolean;
+};
+declare const controlValueSignal: <TControlInput extends Signal<AbstractControl | null> | AbstractControl, TControl extends (TControlInput extends Signal<infer TSignalControl> ? TSignalControl : TControlInput)>(control: TControlInput, options?: ControlValueSignalOptions) => Signal<ReturnType<NonNullable<TControl>["getRawValue"]> | null>;
+/**
+ * The first item in the pair is the previous value and the second item is the current value.
+ */
+declare const controlValueSignalWithPrevious: <T extends AbstractControl>(control: T, options?: ControlValueSignalOptions) => Signal<[ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null, ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null]>;
 
-declare class NormalizeMatchTypePipe implements PipeTransform {
-    transform: (matchType: StageType | null | undefined) => Translatable | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchTypePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchTypePipe, "etNormalizeMatchType", true>;
-}
-declare const normalizeMatchType: (matchType: StageType | null | undefined) => Translatable | null;
+type SignalElementChildrenOptions = {
+    /**
+     * What the underlying `MutationObserver` watches for. The default is deliberately broad, because any DOM
+     * change *might* change which children an element has.
+     *
+     * Narrow it wherever the consumer knows better. `attributes: true` in particular makes every inline style
+     * or class write anywhere in the subtree re-run this - which for a scroll container whose descendants are
+     * written to per animation frame is a change detection tick per frame for nothing. Pass an
+     * `attributeFilter` (or drop `attributes`) in that case.
+     */
+    mutations?: MutationObserverInit;
+};
+declare const signalElementChildren: (el: SignalElementBindingType, options?: SignalElementChildrenOptions) => _angular_core.Signal<HTMLElement[]>;
 
-declare class InferMimeTypePipe implements PipeTransform {
-    transform: (srcset: string) => string | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InferMimeTypePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InferMimeTypePipe, "inferMimeType", true>;
-}
+type BuildSignalEffectsConfig<T extends Record<string, Signal<unknown>>> = {
+    /** The tokens to apply and their signal value  */
+    tokenMap: T;
+    /** This function will be invoked for elements that were removed from the signal effects */
+    cleanupFn: (el: HTMLElement, tokens: string[]) => void;
+    /** This function will be invoked for elements that were added to the signal effects or when their signal value changes */
+    updateFn: (el: HTMLElement, tokens: string[], conditionResult: unknown) => void;
+};
+declare const buildSignalEffects: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, config: BuildSignalEffectsConfig<T>) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalClasses: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, classMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostClasses: <T extends Record<string, Signal<unknown>>>(classMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalAttributes: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, attributeMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostAttributes: <T extends Record<string, Signal<unknown>>>(attributeMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalStyles: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, styleMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostStyles: <T extends Record<string, Signal<unknown>>>(styleMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+
+type LogicalSize = {
+    inlineSize: number;
+    blockSize: number;
+};
+type ElementRect = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type ElementSize = {
+    width: number;
+    height: number;
+};
+declare const boundingClientRectToElementRect: (rect: DOMRectReadOnly) => ElementRect;
+declare const createElementDimensions: (el: HTMLElement | null, rect?: DOMRect) => NullableElementDimensions;
+type ElementDimensions = {
+    rect: () => ElementRect;
+    client: ElementSize;
+    scroll: ElementSize;
+    offset: ElementSize;
+};
+type NullableElementDimensions = {
+    [K in keyof ElementDimensions]: ElementDimensions[K] | null;
+};
+declare const signalElementDimensions: (el: SignalElementBindingType) => Signal<NullableElementDimensions>;
+declare const signalHostElementDimensions: () => Signal<NullableElementDimensions>;
+declare const injectViewportSize: () => Signal<ElementSize>;
+
+type SignalElementIntersectionOptions = Omit<IntersectionObserverInit, 'root'> & {
+    root?: SignalElementBindingType;
+    enabled?: Signal<boolean>;
+};
+type IntersectionObserverEntryWithDetails = IntersectionObserverEntry & {
+    isAbove: boolean;
+    isBelow: boolean;
+    isLeft: boolean;
+    isRight: boolean;
+    isVisible: boolean;
+};
+declare const signalElementIntersection: (el: SignalElementBindingType, options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
+declare const signalHostElementIntersection: (options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
+
+declare const signalElementMutations: (el: SignalElementBindingType, options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
+declare const signalHostElementMutations: (options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
+
+type ElementLastScrollDirectionType = 'up' | 'down' | 'left' | 'right';
+type ElementLastScrollDirection = {
+    type: ElementLastScrollDirectionType;
+    time: number;
+};
+declare const signalElementLastScrollDirection: (el: SignalElementBindingType) => _angular_core.Signal<ElementLastScrollDirection | null>;
+declare const signalHostElementLastScrollDirection: () => _angular_core.Signal<ElementLastScrollDirection | null>;
+
+/**
+ * A signal for whether this page is the one the reader is actually looking at - `false` for a backgrounded
+ * tab or a minimised window.
+ *
+ * Not the same question as whether an element is on screen: an IntersectionObserver reports a fully visible
+ * element in a background tab, because the tab's own visibility is no part of what it measures. Anything
+ * that moves on its own needs to ask both, and a timer is not a substitute - browsers throttle timers in a
+ * hidden tab rather than stopping them, so work keeps piling up out of sight.
+ */
+declare const injectIsDocumentVisible: () => _angular_core.Signal<boolean>;
+
+type SignalElementScrollStateOptions = {
+    /** The initial scroll position to scroll to. Once a truthy value get's emitted, all further values will be ignored. */
+    initialScrollPosition?: Signal<ScrollToOptions | null>;
+    /**
+     * What the underlying `MutationObserver` watches for - a proxy for "the content may have changed size, so
+     * re-measure whether it still overflows". The default is deliberately broad.
+     *
+     * Narrow it wherever the consumer knows better. `attributes: true` means every inline style or class write
+     * anywhere in the subtree re-runs the measurement, and the measurement reads `scrollWidth`/`scrollHeight`
+     * - so a descendant written to per animation frame buys a forced layout per frame.
+     */
+    mutations?: MutationObserverInit;
+};
+type ElementScrollState = {
+    canScroll: boolean;
+    canScrollHorizontally: boolean;
+    canScrollVertically: boolean;
+    elementDimensions: NullableElementDimensions;
+};
+declare const areScrollStatesEqual: (a: ElementScrollState, b: ElementScrollState) => boolean;
+declare const signalElementScrollState: (el: SignalElementBindingType, options?: SignalElementScrollStateOptions) => Signal<ElementScrollState>;
+declare const signalHostElementScrollState: () => Signal<ElementScrollState>;
+
+declare const injectAngularRootElement: _ethlete_core.InjectFn<_angular_core.WritableSignal<HTMLElement | null>>;
+
+declare const provideBoundaryElement: () => _angular_core.Provider[];
+declare const injectBoundaryElement: _ethlete_core.InjectFn<{
+    value: _angular_core.Signal<HTMLElement>;
+    override: _angular_core.WritableSignal<HTMLElement | null>;
+}>;
+declare const BOUNDARY_ELEMENT_TOKEN: _angular_core.InjectionToken<{
+    value: _angular_core.Signal<HTMLElement>;
+    override: _angular_core.WritableSignal<HTMLElement | null>;
+}>;
+
+declare const provideFocusVisibleTracker: () => _angular_core.Provider[];
+declare const injectFocusVisibleTracker: _ethlete_core.InjectFn<{
+    isFocusVisible: _angular_core.Signal<boolean>;
+}>;
+declare const FOCUS_VISIBLE_TRACKER_TOKEN: _angular_core.InjectionToken<{
+    isFocusVisible: _angular_core.Signal<boolean>;
+}>;
+
+/**
+ * A label set, or a function building one for a locale. The function form is called again whenever
+ * {@link injectLocale}'s `currentLocale` changes, so a locale switch re-renders the wording without
+ * reloading - that is the seam an app's i18n library plugs into.
+ */
+type LabelsSource<T> = Partial<T> | ((locale: string) => Partial<T>);
+/** What {@link defineLabels} returns. */
+type LabelsDefinition<T> = {
+    readonly provide: (labels: LabelsSource<T>) => Provider;
+    readonly inject: () => Signal<T>;
+    readonly token: InjectionToken<LabelsSource<T>>;
+};
+/**
+ * The one mechanism for the strings a component renders or announces itself. Every domain in the UI
+ * library that has such strings exposes exactly this pair - `provide<Domain>Labels` to localize a
+ * subtree, `inject<Domain>Labels()` to read the result - so localizing an app is the same move
+ * repeated per domain rather than a different one each time.
+ *
+ * `defaults` may itself be locale-derived, for a domain that ships more than one language (the
+ * `@ethlete/query` error tables, say). Overrides are partial and layer on top of whatever the locale
+ * resolved to, so translating into a third language while keeping a shipped one as the base is the
+ * same call.
+ *
+ * The injector returns a **signal**, because both halves can change at runtime - read it in a
+ * template or computed, never destructure it once.
+ *
+ * @example
+ * export type BreadcrumbLabels = { navigation: string; overflow: string };
+ *
+ * export const DEFAULT_BREADCRUMB_LABELS: BreadcrumbLabels = {
+ *   navigation: 'Breadcrumb',
+ *   overflow: 'Show hidden levels',
+ * };
+ *
+ * const BREADCRUMB_LABELS_DEF = defineLabels<BreadcrumbLabels>('BREADCRUMB_LABELS', DEFAULT_BREADCRUMB_LABELS);
+ *
+ * export const provideBreadcrumbLabels = toProvideFn(BREADCRUMB_LABELS_DEF);
+ * export const injectBreadcrumbLabels = toInjectFn(BREADCRUMB_LABELS_DEF);
+ * export const BREADCRUMB_LABELS = toToken(BREADCRUMB_LABELS_DEF);
+ *
+ * @example
+ * // consumer, fixed wording
+ * provideBreadcrumbLabels({ navigation: 'Brotkrumen' });
+ *
+ * // consumer, driven by the app's i18n and re-resolved on a locale change
+ * provideBreadcrumbLabels((locale) => ({ navigation: translate('breadcrumb.nav', locale) }));
+ */
+declare const defineLabels: <T extends object>(name: string, defaults: T | ((locale: string) => T)) => LabelsDefinition<T>;
+
+declare const provideLocale: () => _angular_core.Provider[];
+declare const injectLocale: _ethlete_core.InjectFn<{
+    currentLocale: _angular_core.WritableSignal<string>;
+}>;
+
+declare const provideRenderer: () => _angular_core.Provider[];
+declare const injectRenderer: _ethlete_core.InjectFn<{
+    addClass: (element: HTMLElement, ...classes: string[]) => void;
+    removeClass: (element: HTMLElement, ...classes: string[]) => void;
+    toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
+    setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
+    removeStyle: (element: HTMLElement, style: keyof CSSStyleDeclaration | string, flags?: RendererStyleFlags2) => void;
+    removeStyles: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration | string)[]) => void;
+    setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
+    removeAttribute: (element: HTMLElement, ...names: string[]) => void;
+    setProperty: (element: HTMLElement, name: string, value: unknown) => void;
+    setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
+    createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
+    createText: (value: string) => Text;
+    createComment: (value: string) => Comment;
+    appendChild: (parent: HTMLElement, newChild: Node) => void;
+    insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
+    removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
+    selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
+    parentNode: (node: Node) => Node | null;
+    nextSibling: (node: Node) => Node | null;
+    setValue: (node: Node, value: string) => void;
+    listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
+    destroyNode: (node: Node) => void;
+    replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
+    empty: (element: HTMLElement) => void;
+    setTextContent: (element: HTMLElement, text: string) => void;
+    setInnerHTML: (element: HTMLElement, html: string) => void;
+    setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
+    setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
+    setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
+    setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
+    moveBefore: (config: {
+        newParent: HTMLElement;
+        child: HTMLElement;
+        before?: Node | null;
+    }) => void;
+    renderer: _angular_core.Renderer2;
+}>;
+type AngularRenderer = NonNullable<ReturnType<typeof injectRenderer>>;
+
+type StyleManager = {
+    mount: <TComponent>(component: Type<TComponent>) => ComponentRef<TComponent>;
+};
+declare const provideStyleManager: () => _angular_core.Provider[];
+declare const injectStyleManager: _ethlete_core.InjectFn<StyleManager>;
+
+type ConsentHandler = {
+    /** Signal that is `true` when consent has been granted. */
+    isGranted: Signal<boolean>;
+    /** Grants consent and writes the decision back to the source. */
+    grant: () => void;
+    /** Revokes consent and writes the decision back to the source. */
+    revoke?: () => void;
+};
+type CreateUserConsentProviderOptions = {
+    /** The provider result returned by `createStaticProvider` that this consent provider should be associated with. */
+    for: InjectionToken<ConsentHandler | null>;
+    /**
+     * Factory executed inside the injection context that returns a `Signal<boolean>`.
+     *
+     * @example
+     * isGranted: () => inject(CookieService).hasMediaConsent
+     */
+    isGranted: () => Signal<boolean>;
+    /**
+     * Factory executed inside the injection context that returns the grant function.
+     *
+     * @example
+     * grant: () => () => inject(CookieService).acceptAll()
+     */
+    grant: () => () => void;
+    /**
+     * Factory executed inside the injection context that returns the revoke  function.
+     *
+     * @example
+     * revoke : () => () => inject(CookieService).revokeAll()
+     */
+    revoke?: () => () => void;
+};
+declare const createUserConsentProvider: (options: CreateUserConsentProviderOptions) => Provider;
+
+/** Inject a signal containing a boolean value indicating if the viewport is xs */
+declare const injectIsXs: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is sm */
+declare const injectIsSm: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is md */
+declare const injectIsMd: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is lg */
+declare const injectIsLg: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is xl */
+declare const injectIsXl: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is 2xl */
+declare const injectIs2Xl: () => _angular_core.Signal<boolean>;
+/**
+ * Inject a boolean value indicating if the viewport is matching the provided options.
+ * This value is not reactive. If you want to react to changes, use the {@link injectObserveBreakpoint} function instead.
+ */
+declare const injectBreakpointIsMatched: (options: BuildMediaQueryOptions) => boolean;
+/**
+ * Inject a boolean value indicating if the media query is matched.
+ * This value is not reactive. If you want to react to changes, use the {@link injectObserveMediaQuery} function instead.
+ */
+declare const injectMediaQueryIsMatched: (mediaQuery: string) => boolean;
+/**
+ * Inject a signal containing a boolean value indicating if the viewport is matching the provided options.
+ */
+declare const injectObserveBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
+/**
+ * Inject a signal containing a boolean value indicating if the media query is matched.
+ */
+declare const injectObserveMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current breakpoint. */
+declare const injectCurrentBreakpoint: () => _angular_core.Signal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+/** Inject a signal that indicates if the user is using a portrait display */
+declare const injectIsPortrait: () => _angular_core.Signal<boolean>;
+/** Inject a signal that indicates if the user is using a landscape display */
+declare const injectIsLandscape: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current display orientation */
+declare const injectDisplayOrientation: () => _angular_core.Signal<"portrait" | "landscape">;
+/** Inject a signal that indicates if the device has a touch input */
+declare const injectHasTouchInput: () => _angular_core.Signal<boolean>;
+/** Inject a signal that indicates if the device has a fine input (mouse or stylus)  */
+declare const injectHasPrecisionInput: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current device input type */
+declare const injectDeviceInputType: () => _angular_core.Signal<"touch" | "mouse">;
+/** Inject a signal that indicates if the user prefers reduced motion */
+declare const injectPrefersReducedMotion: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the user can hover (eg. using a mouse) */
+declare const injectCanHover: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the viewport dimensions */
+declare const injectViewportDimensions: () => _angular_core.Signal<_ethlete_core.NullableElementDimensions>;
+/** Inject a signal containing the scrollbar dimensions. Dimensions will be 0 if scrollbars overlap the page contents (like on mobile). */
+declare const injectScrollbarDimensions: () => _angular_core.Signal<{
+    width: number;
+    height: number;
+} | null>;
+
+/**
+ * Applies scrollbar size CSS variables to the documentElement (html tag) in pixels.
+ * - `--et-sw`: scrollbar width
+ * - `--et-sh`: scrollbar height
+ */
+declare const writeScrollbarSizeToCssVariables: () => void;
+/**
+ * Applies viewport size CSS variables to the documentElement (html tag) in pixels.
+ * - `--et-vw`: viewport width excluding scrollbar width
+ * - `--et-vh`: viewport height excluding scrollbar height
+ */
+declare const writeViewportSizeToCssVariables: () => void;
+
+type CursorDragScrollDirection = 'horizontal' | 'vertical' | 'both';
+type CursorDragScrollOptions = {
+    /** If true, cursor drag scrolling will be enabled. */
+    enabled?: Signal<boolean>;
+    /** The allowed scroll direction. */
+    allowedDirection?: MaybeSignal<CursorDragScrollDirection>;
+    /**
+     * Whether the element overflows in the allowed direction - there is nothing to drag if it does not.
+     *
+     * Measured here when it isn't supplied, which means a MutationObserver and a ResizeObserver of its own.
+     * Hand it over wherever the caller already knows: a scrollable that tracks its own scroll state was ending
+     * up with two observers watching the same element for the same thing, and both of them re-measured
+     * `scrollWidth` - a forced layout - on every inline style written anywhere inside it.
+     */
+    canScroll?: Signal<boolean>;
+};
+/** A function to apply cursor drag scroll behavior to an element. */
+declare const useCursorDragScroll: (el: SignalElementBindingType, options?: CursorDragScrollOptions) => {
+    isDragging: Signal<boolean>;
+    currentDragAmount: Signal<{
+        x: number;
+        y: number;
+    }>;
+};
+
+/**
+ * The element that gets scrolled. Pass a function if the scroll container is created per route or
+ * only exists after the app shell rendered - it is resolved on every navigation instead of once at
+ * setup time.
+ * @default document.documentElement
+ */
+type ScrollRestorationScrollElement = HTMLElement | (() => HTMLElement | null | undefined);
+type ScrollRestorationRestoreConfig = {
+    /**
+     * Restore the previous scroll offset when the user navigates back or forward through the browser
+     * history, instead of scrolling to top.
+     *
+     * The offset is not applied on the loading frame: query driven pages render skeletons/empty states
+     * first, so the document is far shorter than it was when the user left. Restoration waits until
+     * the content is tall enough to actually reach the saved offset (see `timeout`).
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * How long to keep waiting (in ms) for the content to grow tall enough to reach the saved offset.
+     * The clock is suspended while a {@link holdScrollRestoration} registration reads `true`.
+     * @default 1000
+     */
+    timeout?: number;
+    /**
+     * Absolute upper bound (in ms) for a single restoration attempt, regardless of
+     * {@link holdScrollRestoration} registrations. Guards against a page that never stops loading.
+     * @default 10000
+     */
+    maxTimeout?: number;
+    /**
+     * Whether to apply the saved offset clamped to the reachable maximum once `timeout` elapsed
+     * without the content getting tall enough. Landing close to the previous position is usually
+     * better than staying at the top.
+     * @default true
+     */
+    clampOnTimeout?: boolean;
+};
+type SetupScrollRestorationConfig = {
+    /**
+     * The scrollable container.
+     * @default document.documentElement
+     */
+    scrollElement?: ScrollRestorationScrollElement;
+    /**
+     * A list of query params that should trigger a scroll to top.
+     * @default []
+     * @example ['page'] // will scroll to top when the page query param changes
+     */
+    queryParamTriggerList?: string[];
+    /**
+     * Config for fragment scrolling.
+     */
+    fragment?: {
+        /**
+         * Enable fragment scrolling (scroll to element with id)
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Whether to use smooth scrolling or not.
+         * @default false
+         */
+        smooth?: boolean;
+    };
+    /**
+     * Config for restoring the previous scroll offset on browser back/forward navigation.
+     * Disabled by default - without it, history navigation scrolls to top like any other navigation.
+     */
+    restore?: ScrollRestorationRestoreConfig;
+};
+declare const ET_DISABLE_SCROLL_TOP: unique symbol;
+declare const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE: unique symbol;
+declare const ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE: unique symbol;
+type RouterDisableScrollTopConfig = {
+    /**
+     * Whether to disable scroll to top ONLY when navigating back to this route.
+     * @default false
+     */
+    asReturnRoute?: boolean;
+    /**
+     * Whether to disable scroll to top when a path param changes.
+     * @default false
+     */
+    onPathParamChange?: boolean;
+};
+declare const routerDisableScrollTop: (config?: RouterDisableScrollTopConfig) => {
+    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
+    [ET_DISABLE_SCROLL_TOP]: boolean;
+} | {
+    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
+    [ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE]: boolean;
+};
+/**
+ * Suspend scroll restoration while `isPending` reads `true`.
+ *
+ * Restoration already waits for the scroll container to grow tall enough to reach the saved offset,
+ * so this is only needed when the content may take longer than `restore.timeout` to get there -
+ * a slow list request, for instance. Registers for the lifetime of the current injection context.
+ *
+ * @example
+ * // inside a route component
+ * holdScrollRestoration(() => query.isLoading());
+ */
+declare const holdScrollRestoration: (isPending: () => boolean) => void;
+declare const setupScrollRestoration: (config?: SetupScrollRestorationConfig) => void;
+
+declare const signalIsRendered: () => _angular_core.Signal<boolean>;
+declare const createIsRenderedSignal: () => {
+    state: _angular_core.WritableSignal<boolean>;
+    bind: () => _angular_core.EffectRef;
+};
+declare const createCanAnimateSignal: () => {
+    state: _angular_core.Signal<boolean>;
+};
+
+type RouterState = {
+    data: Data;
+    pathParams: Params;
+    queryParams: Params;
+    title: string | null;
+    fragment: string | null;
+};
+declare const ET_PROPERTY_REMOVED: unique symbol;
+type InjectUtilConfig = {
+    /** The injector to use for the injection. Must be provided if the function is not called from within a injection context. */
+    injector?: Injector;
+};
+type InjectUtilTransformConfig<In, Out> = {
+    /**
+     * A transform function similar to the `transform` function in Angular input bindings.
+     * Can be used to transform the value before it is returned.
+     * E.g. transforming `"true"` to `true` for a boolean attribute.
+     */
+    transform?: (value: In) => Out;
+};
+declare const transformOrReturn: <In, Out>(src: Signal<In>, config?: InjectUtilTransformConfig<In, Out>) => Signal<Out>;
+/** Inject the current router event */
+declare const injectRouterEvent: () => Signal<_angular_router.Event>;
+/**
+ * Signal that indicates whether the router has been initialized.
+ * The router is considered initialized once the first NavigationEnd event with an id different than -1 has been emitted.
+ */
+declare const injectIsRouterInitialized: () => Signal<boolean>;
+/**
+ * Inject the current url.
+ * The url includes query params as well as the fragment. Use `injectRoute` instead if you are not intrusted in those.
+ * @example "/my-page?query=1&param=true#fragment"
+ */
+declare const injectUrl: () => Signal<string>;
+/**
+ * Inject the current route
+ * @example "/my-page"
+ */
+declare const injectRoute: () => Signal<string>;
+declare const createRouterState: (router: Router) => RouterState;
+/**
+ * Read the current route (the committed url without query params and fragment) straight from the router.
+ * Unlike the `injectRoute` signal this reads synchronously, so it can be used inside a `router.events` handler
+ * where `router.url` is already committed. Falls back to the browser location before the first navigation commits.
+ */
+declare const createRoute: (router: Router) => string;
+/**
+ * Inject the complete router state. This includes the current route data, path params, query params, title and fragment.
+ */
+declare const injectRouterState: () => Signal<RouterState>;
+/** Inject a signal containing the current route fragment (the part after the # inside the url if present) */
+declare const injectFragment: <T = string | null>(config?: InjectUtilConfig & InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+/** Inject all currently available query parameters as a signal */
+declare const injectQueryParams: () => Signal<Params>;
+/** Inject all currently available route data as a signal */
+declare const injectRouteData: () => Signal<Data>;
+/** Inject the current route title as a signal */
+declare const injectRouteTitle: <T = string | null>(config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+/** Inject all currently available path parameters as a signal */
+declare const injectPathParams: () => Signal<Params>;
+type InjectQueryParamConfig<T> = InjectUtilTransformConfig<string | null, T> & {
+    /**
+     * If true, the initial value will be read from the browser's url.
+     * Note that this will not work with arrays or complex objects.
+     */
+    requireSync?: boolean;
+};
+/** Inject a specific query parameter as a signal */
+declare const injectQueryParam: <T = string | null>(key: string, config?: InjectQueryParamConfig<T>) => Signal<T>;
+/** Inject a specific route data item as a signal */
+declare const injectRouteDataItem: <T = unknown>(key: string, config?: InjectUtilTransformConfig<unknown, T>) => Signal<T>;
+/** Inject a specific path parameter as a signal */
+declare const injectPathParam: <T = string | null>(key: string, config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
 /**
- * Infers the mime type of a given url or srcset.
- * If a srcset is provided, it will infer the mime type of the first url in the srcset.
- * If the srcset contains a query parameter `?fm=`, it will use the value of that parameter, since it is often used to specify the file format in image api's like contentful.
+ * Inject query params that changed during navigation. Unchanged query params will be ignored.
+ * Removed query params will be represented by the symbol `ET_PROPERTY_REMOVED`.
  */
-declare const inferMimeType: (srcset: string) => string | null;
+declare const injectQueryParamChanges: () => Signal<Record<string, unknown>>;
+/**
+ * Inject path params that changed during navigation. Unchanged path params will be ignored.
+ * Removed path params will be represented by the symbol `ET_PROPERTY_REMOVED`.
+ */
+declare const injectPathParamChanges: () => Signal<Record<string, unknown>>;
+/**
+ * The state handed to the navigation that is currently in progress, i.e. what
+ * `router.navigate(…, { state })` passed - typed to whatever you expect.
+ *
+ * Read **synchronously**, in a constructor or a resolver, and deliberately not a signal: navigation state exists
+ * only for the duration of the navigation that carries it. By the time an effect flushed, the navigation would be
+ * over and the answer always `null`. Returns `null` when there is no navigation in flight or it carried no state -
+ * which is the normal case for a page arrived at by typing its URL, so always handle it.
+ *
+ * Use it for the things a URL should not carry: a "you were redirected because…" reason, a pre-fetched object the
+ * previous page already had, a scroll intent. Anything the page needs to survive a reload belongs in the URL.
+ *
+ * @example
+ * type CheckoutNavState = { fromCart: boolean };
+ *
+ * export class CheckoutComponent {
+ *   private navState = injectRouterNavigationState<CheckoutNavState>();
+ *
+ *   protected cameFromCart = this.navState?.fromCart ?? false;
+ * }
+ */
+declare const injectRouterNavigationState: <T>() => T | null;
 
-declare class ToArrayPipe implements PipeTransform {
-    transform: (value: number) => number[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToArrayPipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToArrayPipe, "toArray", true>;
+declare class ScrollObserverDirective {
+    private elementRef;
+    enabled: _angular_core.ModelSignal<MaybeSignal<boolean>>;
+    private enabledValue;
+    private _startEl;
+    private _endEl;
+    private _startIntersection;
+    private _endIntersection;
+    isAtStart: Signal<boolean>;
+    isAtEnd: Signal<boolean>;
+    _registerStart(el: ElementRef<HTMLElement>): void;
+    _registerEnd(el: ElementRef<HTMLElement>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollObserverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollObserverDirective, "[etScrollObserver]", ["etScrollObserver"], { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "enabled": "enabledChange"; }, never, never, true, never>;
 }
-declare const toArray: (value: number) => number[];
-declare const toArrayTrackByFn: TrackByFunction<number>;
 
-declare const createPropHandlers: () => {
-    classes: {
-        remove: (tokens: string) => void;
-        removeMany: (tokens: string[]) => void;
-        has: (tokens: string) => boolean;
-        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-    };
-    attributes: {
-        remove: (tokens: string) => void;
-        removeMany: (tokens: string[]) => void;
-        has: (tokens: string) => boolean;
-        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-    };
-    styles: {
-        remove: (tokens: string) => void;
-        removeMany: (tokens: string[]) => void;
-        has: (tokens: string) => boolean;
-        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-    };
+type DragStartEvent = {
+    /** Pointer position at pointerdown - NOT at commit-threshold crossing. */
+    readonly clientX: number;
+    readonly clientY: number;
+};
+type DragMoveEvent = {
+    readonly stepX: number;
+    readonly stepY: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    /** Cumulative delta from the pointerdown position. */
+    readonly totalDx: number;
+    readonly totalDy: number;
+};
+type DragGestureEvent = {
+    readonly type: 'tapped';
+} | {
+    readonly type: 'start';
+    readonly data: DragStartEvent;
+} | {
+    readonly type: 'move';
+    readonly data: DragMoveEvent;
+} | {
+    readonly type: 'end';
+};
+/**
+ * Observe one drag gesture, starting from a `pointerdown` on `element`.
+ *
+ * Emits `start` once the pointer has travelled `commitThreshold` px (so a click is not a drag),
+ * immediately followed by a catch-up `move`, then a `move` per pointer move, and finally `end`. A
+ * pointer released before crossing the threshold emits a single `tapped` instead. The stream
+ * completes with the gesture, so there is nothing to unsubscribe on the happy path.
+ *
+ * This is the primitive behind {@link DragHandleDirective}. Prefer the directive; reach for this when
+ * the draggable element belongs to someone else's template (e.g. a table feature attaching a drag to
+ * header cells the table itself renders) and you can only work from a delegated `pointerdown`.
+ */
+declare const dragGestureFrom: (event: PointerEvent, element: HTMLElement, options?: {
+    commitThreshold?: number;
+}) => Observable<DragGestureEvent>;
+
+declare class DragHandleDirective {
+    private el;
+    commitThreshold: _angular_core.InputSignal<number>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private gestureStart$;
+    private gesture$;
+    dragTapped: _angular_core.OutputRef<void>;
+    dragStarted: _angular_core.OutputRef<DragStartEvent>;
+    dragMoved: _angular_core.OutputRef<DragMoveEvent>;
+    dragEnded: _angular_core.OutputRef<void>;
+    isDragging: _angular_core.Signal<boolean>;
+    constructor();
+    startGesture(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragHandleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DragHandleDirective, "[etDragHandle]", never, { "commitThreshold": { "alias": "commitThreshold"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "dragTapped": "dragTapped"; "dragStarted": "dragStarted"; "dragMoved": "dragMoved"; "dragEnded": "dragEnded"; }, never, never, true, never>;
+}
+
+/**
+ * The browser's notification permission, widened with `'unsupported'` - which covers both a browser
+ * without the Notification API and the server, where there is no `Notification` global to ask.
+ */
+type NotificationPermissionState = NotificationPermission | 'unsupported';
+/**
+ * Which of the two ways of putting a notification on screen was used.
+ *
+ * - `page` - the `Notification` constructor. Its events come back to the page, so `onClick`,
+ *   `onClose`, `onShow` and `onError` all work, but the notification dies with the tab.
+ * - `service-worker` - `ServiceWorkerRegistration.showNotification()`. The only path Android Chrome
+ *   and installed iOS web apps have, and the only one that can render `actions` - but its clicks are
+ *   delivered to the service worker rather than to the page, see {@link ShowNotificationConfig.onClick}.
+ * - `unavailable` - nothing was shown: no API, permission not granted, the page path threw and no
+ *   service worker was registered to fall back to, or the notification was closed before it appeared.
+ */
+type NotificationDeliveryPath = 'page' | 'service-worker' | 'unavailable';
+/**
+ * A button rendered on a notification. Service-worker path only - `show()` routes a notification with
+ * actions there automatically, and a notification pinned to `path: 'page'` drops them.
+ */
+type NotificationActionConfig = {
+    /** Identifies this button in the service worker's `notificationclick` handler (`event.action`). */
+    action: string;
+    /** The button's label. */
+    title: string;
+    /** Icon URL for the button. Rendered on Android, ignored on desktop. */
+    icon?: string;
+};
+/** What {@link ShowNotificationConfig.onClick} is called with. */
+type NotificationClickContext = {
+    /** The notification's tag - the generated one when the config did not set one. */
+    tag: string;
+    /** Whatever was passed as {@link ShowNotificationConfig.data}. */
+    data: unknown;
+    /** The action button that was clicked. Service-worker path only, and absent for the body itself. */
+    action?: string;
+    /** The underlying DOM event. Page path only. */
+    event?: Event;
+};
+/**
+ * The message a service worker posts to relay a notification click back to the page. Matches what
+ * {@link NOTIFICATION_CLICK_MESSAGE_TYPE} documents.
+ */
+type NotificationClickMessage = {
+    type: typeof NOTIFICATION_CLICK_MESSAGE_TYPE;
+    tag: string;
+    data?: unknown;
+    action?: string;
+};
+/**
+ * The `message` type a service worker must post for `onClick` to fire on the service-worker path,
+ * where the click event is dispatched to the worker and never reaches the page.
+ *
+ * Nothing in the SDK can install this handler - a service worker's code is the app's. Add it to yours
+ * to make `onClick` work on Android Chrome and installed iOS web apps:
+ *
+ * ```js
+ * self.addEventListener('notificationclick', (event) => {
+ *   event.notification.close();
+ *
+ *   event.waitUntil(
+ *     self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then((clients) => {
+ *       for (const client of clients) {
+ *         client.postMessage({
+ *           type: 'et:notification-click',
+ *           tag: event.notification.tag,
+ *           data: event.notification.data,
+ *           action: event.action || undefined,
+ *         });
+ *       }
+ *     }),
+ *   );
+ * });
+ * ```
+ */
+declare const NOTIFICATION_CLICK_MESSAGE_TYPE = "et:notification-click";
+type ShowNotificationConfig = {
+    /** The notification's headline. The only required field. */
+    title: string;
+    /** Body text below the title. */
+    body?: string;
+    /** URL of the image shown as the notification's icon. */
+    icon?: string;
+    /** URL of a small monochrome badge, shown in the Android status bar when the icon does not fit. */
+    badge?: string;
+    /**
+     * URL of a large image shown inside the notification. Service-worker path only, and only honored by
+     * Chromium.
+     */
+    image?: string;
+    /**
+     * Identity of the notification: showing another one with the same tag **replaces** it instead of
+     * stacking, and it is what `close()` matches on the service-worker path.
+     *
+     * Leave it unset for a stand-alone notification - a unique tag is generated, which is what makes
+     * `close()` and click relaying work at all. Set it to coalesce repeated notifications about the same
+     * thing (one per chat, one per upload); `close()` on such a ref closes every notification sharing
+     * the tag.
+     */
+    tag?: string;
+    /** Arbitrary payload, handed back to `onClick` and to the service worker's `notificationclick`. */
+    data?: unknown;
+    /** Language of the title and body, as a BCP 47 tag. */
+    lang?: string;
+    /** Text direction of the title and body. */
+    dir?: NotificationDirection;
+    /** Show without sound or vibration. */
+    silent?: boolean;
+    /**
+     * Keep the notification on screen until the user dismisses it, rather than auto-hiding it. Desktop
+     * Chromium only; ignored elsewhere.
+     */
+    requireInteraction?: boolean;
+    /**
+     * Alert the user again when this notification replaces one with the same tag - by default a
+     * replacement is silent. Requires `tag`; service-worker path only.
+     */
+    renotify?: boolean;
+    /**
+     * Vibration pattern in milliseconds, alternating vibrate and pause. Service-worker path only, and
+     * Android only.
+     */
+    vibrate?: number[];
+    /**
+     * The time the notification is *about*, as an epoch timestamp - not when it is shown. Used for
+     * ordering in the notification tray. Service-worker path only.
+     */
+    timestamp?: number;
+    /** Buttons on the notification. Forces the service-worker path, since the page path cannot render them. */
+    actions?: NotificationActionConfig[];
+    /**
+     * Which delivery path to use.
+     *
+     * - `auto` (default) - the page path first, falling back to the service worker when the constructor
+     *   throws, which is how Android Chrome reports that it only does persistent notifications. A
+     *   notification with `actions` goes straight to the service worker.
+     * - `page` - constructor only. Fails to `'unavailable'` where the constructor is illegal, and drops
+     *   `actions`, `image`, `renotify`, `vibrate` and `timestamp`.
+     * - `service-worker` - persistent only. Fails to `'unavailable'` when no service worker is
+     *   registered.
+     * @default 'auto'
+     */
+    path?: 'auto' | 'page' | 'service-worker';
+    /**
+     * Close the notification this many milliseconds after it is shown. Off by default, which leaves the
+     * lifetime to the platform - desktop Chromium hides a notification after about 20 seconds and keeps
+     * it in the tray, Android keeps it until dismissed.
+     */
+    autoClose?: number;
+    /**
+     * Called when the user clicks the notification (or one of its `actions`).
+     *
+     * On the page path this is wired directly to the notification's `click` event. On the
+     * service-worker path the event goes to the worker instead, so this only fires if that worker
+     * relays it - see {@link NOTIFICATION_CLICK_MESSAGE_TYPE} for the handler to add.
+     *
+     * A click does not focus the tab. Call `window.focus()` yourself if that is what you want.
+     */
+    onClick?: (context: NotificationClickContext) => void;
+    /** Called when the notification is closed, by the user or by `close()`. Page path only. */
+    onClose?: () => void;
+    /** Called once the notification is on screen. Page path only. */
+    onShow?: () => void;
+    /** Called when the browser failed to display the notification. Page path only. */
+    onError?: () => void;
+};
+/** Handle on a notification handed to {@link Notifications.show}. */
+type NotificationRef = {
+    /** The notification's tag - generated when the config did not provide one. */
+    readonly tag: string;
+    /**
+     * Emits once the browser has taken the notification, with the path that carried it - or
+     * `'unavailable'` if nothing was shown - and completes. Never errors.
+     *
+     * The notification is shown whether or not anyone subscribes, and the result is replayed, so a late
+     * subscriber still gets it.
+     */
+    readonly shown$: Observable<NotificationDeliveryPath>;
+    /**
+     * Dismiss the notification. Safe to call before `shown$` emits (the notification is then never
+     * displayed) and safe to call twice.
+     */
+    readonly close: () => void;
+};
+/** The notification API, injected with `injectNotifications()`. */
+type Notifications = {
+    /**
+     * Whether this browser exposes a Notification API at all - `false` on the server and in engines
+     * without it. Not a promise that a notification will show: permission still has to be granted, and
+     * a browser that only supports persistent notifications still needs a service worker.
+     */
+    readonly isSupported: boolean;
+    /**
+     * The current permission, kept in sync while the app runs: through the Permissions API where it has
+     * a `notifications` descriptor (Chromium, Firefox), and by re-reading it whenever the tab comes back
+     * to the foreground everywhere else - which is how a permission revoked in browser settings is
+     * picked up on WebKit.
+     */
+    readonly permission: Signal<NotificationPermissionState>;
+    /**
+     * Show the browser's permission prompt, emitting the outcome once and completing. Cold - nothing is
+     * asked until it is subscribed to.
+     *
+     * Subscribe from a user gesture: Safari requires one, and Chromium blocks the prompt entirely on
+     * sites that ask on page load. Emits the current state without prompting when permission was already
+     * granted or denied - the prompt can only be shown once, after which only the user can change it in
+     * site settings.
+     */
+    readonly request: () => Observable<NotificationPermissionState>;
+    /**
+     * Show a notification, if permission has been granted - this never prompts on its own, so run
+     * `request()` first.
+     *
+     * Returns synchronously, and the notification is shown without anyone subscribing to anything; the
+     * ref's `shown$` reports which path carried it.
+     */
+    readonly show: (config: ShowNotificationConfig) => NotificationRef;
+    /**
+     * Close every notification this app has open - the ones shown through `show()` plus any persistent
+     * ones still in the tray from an earlier page load.
+     */
+    readonly closeAll: () => void;
+};
+
+declare const provideNotifications: () => _angular_core.Provider[];
+declare const injectNotifications: _ethlete_core.InjectFn<Notifications>;
+
+type OverlayRuntimeRole = 'dialog' | 'alertdialog';
+type OverlayRuntimeAutoFocusTarget = 'container' | 'first-heading' | 'first-tabbable';
+type OverlayRuntimeCloseSource = 'api' | 'escape' | 'outside-pointer' | 'drag' | 'reference-detached';
+type OverlayRuntimeCenteredPosition = {
+    kind: 'center';
+};
+type OverlayRuntimeGlobalPositionAlignment = 'start' | 'center' | 'end' | 'stretch';
+type OverlayRuntimeGlobalPosition = {
+    kind: 'global';
+    /** Horizontal placement of the pane inside the viewport. Defaults to `center`. */
+    horizontal?: OverlayRuntimeGlobalPositionAlignment;
+    /** Vertical placement of the pane inside the viewport. Defaults to `center`. */
+    vertical?: OverlayRuntimeGlobalPositionAlignment;
+    /** Padding applied to the host element. Defaults to `0`. */
+    padding?: string;
+};
+type OverlayRuntimeShiftOptions = {
+    /**
+     * Also shift along the placement's cross axis (e.g. horizontally for a `right-*` placement)
+     * when no placement fits the viewport. The pane may then overlap its reference element -
+     * desirable for nested menus, usually not for tooltips. Defaults to `false`.
+     */
+    crossAxis?: boolean;
+};
+type OverlayRuntimeAnchoredPosition = {
+    kind: 'anchored';
+    referenceElement: HTMLElement | VirtualElement;
+    placement?: Placement;
+    fallbackPlacements?: Placement[];
+    offset?: OffsetOptions | null;
+    arrowPadding?: Padding | null;
+    viewportPadding?: Padding | null;
+    autoResize?: boolean;
+    /**
+     * Keeps the pane on its placement's own side while that side offers at least this much space (px
+     * along the placement's main axis), instead of flipping as soon as the pane's content would
+     * overflow. Below the minimum the pane moves to the opposite side, and when neither side reaches
+     * it the roomier one wins. Requires `autoResize` - the pane has to shrink into what it gets.
+     *
+     * Prefer this over `fallbackPlacements` for a pane whose content is scrollable (a listbox, a
+     * menu): a shorter list under the field beats a full-height one above it, and the decision reads
+     * only the space around the reference, never the pane's own size. `flip` compares that size
+     * against the space it has while `autoResize` derives it from the placement `flip` picked, so a
+     * pane whose height changes while open - a filtered list, an animated resize - flips back and
+     * forth mid-animation. Replaces `flip`, so `fallbackPlacements` no longer applies, and forces
+     * `shift`'s cross axis off - a pane that shrinks into its side must not slide over the reference
+     * element instead.
+     */
+    minAvailableSpace?: number;
+    shift?: boolean | OverlayRuntimeShiftOptions;
+    autoHide?: boolean;
+    autoCloseIfReferenceHidden?: boolean;
+    mirrorWidth?: boolean;
+    /**
+     * Clipping element(s) the pane must stay within when flipping/shifting, instead of the default
+     * viewport (`clippingAncestors`). Use it to keep an anchored pane inside a specific region - e.g.
+     * a rich-text editor's content area, so its selection toolbar flips below rather than covering the
+     * static toolbar above.
+     */
+    boundary?: Element | Element[];
+};
+type OverlayRuntimePositionStrategy = OverlayRuntimeCenteredPosition | OverlayRuntimeAnchoredPosition | OverlayRuntimeGlobalPosition;
+type OverlayRuntimeElements = {
+    rootElement: HTMLElement;
+    hostElement: HTMLElement;
+    backdropElement: HTMLElement | null;
+    paneElement: HTMLElement;
+};
+type OverlayRuntimeCloseEvent<TResult = unknown> = {
+    result: TResult | undefined;
+    source: OverlayRuntimeCloseSource;
+};
+/**
+ * A synchronous veto for a pending close. Return `false` to cancel the close (the overlay stays
+ * open); return `true` to let it proceed. Registered via `overlayRef.registerCloseGuard`. An async
+ * decision (e.g. a confirm dialog) lives in the guard's owner, which re-issues the close through
+ * `overlayRef.forceClose` once resolved. `reference-detached` closes bypass all guards.
+ */
+type OverlayRuntimeCloseGuard<TResult = unknown> = (event: OverlayRuntimeCloseEvent<TResult>) => boolean;
+type OverlayRuntimeComponentBase = {
+    animatedLifecycle?: Signal<AnimatedLifecycleDirective | undefined>;
+};
+type OverlayRuntimeAnimationDelegateEnterContext = {
+    lifecycle: AnimatedLifecycleDirective;
+    elements: OverlayRuntimeElements;
+};
+type OverlayRuntimeAnimationDelegateLeaveContext = OverlayRuntimeAnimationDelegateEnterContext & {
+    closeEvent: OverlayRuntimeCloseEvent;
+};
+/**
+ * Overrides the runtime's default enter/leave animation handling.
+ * A delegate must eventually drive the lifecycle state to `entered` (enter) or `left` (leave),
+ * otherwise the overlay will never finish opening or closing.
+ */
+type OverlayRuntimeAnimationDelegate = {
+    enter?: (context: OverlayRuntimeAnimationDelegateEnterContext) => void;
+    leave?: (context: OverlayRuntimeAnimationDelegateLeaveContext) => void;
+};
+type OverlayRuntimeMountConfig<TComponent extends object> = {
     id: string;
-    elementRef: ElementRef<HTMLElement>;
+    component: Type<TComponent>;
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+    providers?: StaticProvider[];
+    role?: OverlayRuntimeRole;
+    positionStrategy?: OverlayRuntimePositionStrategy;
+    hasBackdrop?: boolean;
+    modal?: boolean;
+    autoFocus?: OverlayRuntimeAutoFocusTarget | string | false;
+    restoreFocus?: boolean;
+    closeOnEscape?: boolean;
+    closeOnOutsidePointer?: boolean;
+    ariaDescribedBy?: string | null;
+    ariaLabelledBy?: string | null;
+    ariaLabel?: string | null;
+    hostClass?: string[];
+    backdropClass?: string[];
+    paneClass?: string[];
+    /**
+     * Bindings applied to the mounted component, using Angular's native binding API
+     * (`inputBinding`, `outputBinding`, `twoWayBinding`).
+     */
+    bindings?: Binding[];
+    animationDelegate?: OverlayRuntimeAnimationDelegate;
 };
-type PropHandlers = ReturnType<typeof createPropHandlers>;
 
-type Props = Readonly<{
-    attached: Signal<boolean>;
-    attachedElements: PropsAttachedElements;
-}>;
-type PropsAttachedElements = {
-    first: Signal<HTMLElement | null>;
-    firstId: Signal<string | null>;
-    get(id: string): HTMLElement | null;
+type OverlayRuntimeState = 'mounting' | 'mounted' | 'closing' | 'closed';
+declare const createOverlayRuntimeRef: <TComponent extends object, TResult = unknown>(id: string, config: Omit<OverlayRuntimeMountConfig<TComponent>, "component">, elements: OverlayRuntimeElements, requestClose: (result: TResult | undefined, source: OverlayRuntimeCloseSource) => void) => {
+    id: string;
+    config: Omit<OverlayRuntimeMountConfig<TComponent>, "component">;
+    elements: OverlayRuntimeElements;
+    state: _angular_core.Signal<OverlayRuntimeState>;
+    componentInstance: _angular_core.Signal<TComponent | null>;
+    beforeOpenedSubject: Subject<void>;
+    close(result?: TResult, source?: OverlayRuntimeCloseSource): void;
+    /** Close bypassing every registered close guard - used by a guard's owner to commit a
+     *  close it previously vetoed (e.g. after an async confirm resolved). */
+    forceClose(result?: TResult, source?: OverlayRuntimeCloseSource): void;
+    /** Register a synchronous veto for pending closes. Returns an unregister function. */
+    registerCloseGuard(guard: OverlayRuntimeCloseGuard<TResult>): () => void;
+    beforeOpened(): Observable<void>;
+    afterOpened(): Observable<void>;
+    beforeClosed(): Observable<OverlayRuntimeCloseEvent<TResult>>;
+    afterClosed(): Observable<OverlayRuntimeCloseEvent<TResult>>;
+    attachComponentRef(componentRef: ComponentRef<TComponent>): void;
+    /** @internal */
+    attachPositionUpdater(updater: (strategy: OverlayRuntimePositionStrategy) => void): void;
+    updatePositionStrategy(strategy: OverlayRuntimePositionStrategy): void;
+    markOpened(): void;
+    beginClose(closeEvent: OverlayRuntimeCloseEvent<TResult>): boolean;
+    finishClose(closeEvent: OverlayRuntimeCloseEvent<TResult>): void;
+};
+type OverlayRuntimeRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRuntimeRef<TComponent, TResult>>;
+
+declare const FOCUSABLE_SELECTOR: string;
+declare const isHTMLElement: (value: unknown) => value is HTMLElement;
+declare const isFocusable: (element: HTMLElement, document: Document) => boolean;
+declare const getFocusableElements: (container: HTMLElement, document: Document) => HTMLElement[];
+declare const getHeadingElement: (container: HTMLElement) => HTMLElement | null;
+declare const focusElement: (element: HTMLElement | null) => void;
+declare const applyInitialFocus: (paneElement: HTMLElement, autoFocus: OverlayRuntimeAutoFocusTarget | string | false, document: Document) => void;
+declare const setupFocusTrap: (paneElement: HTMLElement, overlayRef: OverlayRuntimeRef<object, unknown>, enabled: boolean, isTopMost: (ref: OverlayRuntimeRef<object, unknown>) => boolean, document: Document) => () => void;
+
+declare const setBaseElementStyles: (config: OverlayRuntimeMountConfig<object>, hostElement: HTMLElement, paneElement: HTMLElement, renderer: AngularRenderer) => void;
+declare const setBackdropStyles: (backdropElement: HTMLElement, renderer: AngularRenderer) => void;
+declare const applyCenteredPosition: (hostElement: HTMLElement, paneElement: HTMLElement, renderer: AngularRenderer, _config: OverlayRuntimeCenteredPosition) => void;
+declare const applyGlobalPosition: (hostElement: HTMLElement, paneElement: HTMLElement, renderer: AngularRenderer, config: OverlayRuntimeGlobalPosition) => void;
+/**
+ * Clears every inline style any position strategy kind may have set and
+ * restores the base element styles, so a different strategy can be applied afterwards.
+ */
+declare const resetPositioningStyles: (config: OverlayRuntimeMountConfig<object>, hostElement: HTMLElement, paneElement: HTMLElement, renderer: AngularRenderer) => void;
+/**
+ * Positions an anchored overlay pane and returns the cleanup for its auto-update loop.
+ */
+type AnchoredPositionSetup = (strategy: OverlayRuntimeAnchoredPosition, paneElement: HTMLElement, overlayRef: OverlayRuntimeRef<object, unknown>, renderer: AngularRenderer) => () => void;
+/**
+ * Installs the anchored positioning implementation. Called by `anchoredOverlayPosition()`, which is
+ * the only thing that pulls `@floating-ui/dom` into the bundle - apps that never anchor an overlay
+ * do not ship it.
+ *
+ * @internal
+ */
+declare const registerAnchoredPositionSetup: (setup: AnchoredPositionSetup) => void;
+declare const setupPositioning: (config: OverlayRuntimeMountConfig<object>, hostElement: HTMLElement, paneElement: HTMLElement, overlayRef: OverlayRuntimeRef<object, unknown>, renderer: AngularRenderer) => () => void;
+
+/**
+ * The floating-ui middleware only a subset of anchored overlays needs. Installed by
+ * `enableAnchoredOverlayPositionExtras()`.
+ *
+ * @internal
+ */
+type AnchoredPositionMiddlewareExtras = {
+    size: typeof _floating_ui_dom.size;
+    arrow: typeof _floating_ui_dom.arrow;
+    hide: typeof _floating_ui_dom.hide;
 };
-type PropsAttachedElementsInternal = PropsAttachedElements & {
-    has: (id: string) => boolean;
-    push: (id: string, element: HTMLElement) => void;
-    remove: (id: string) => void;
+/**
+ * Installs the `size` / `arrow` / `hide` middleware. Called by
+ * `enableAnchoredOverlayPositionExtras()`.
+ *
+ * @internal
+ */
+declare const registerAnchoredPositionMiddlewareExtras: (extras: AnchoredPositionMiddlewareExtras) => void;
+declare const createAnchoredPositionCleanup: (strategy: OverlayRuntimeAnchoredPosition, paneElement: HTMLElement, overlayRef: OverlayRuntimeRef<object, unknown>, renderer: AngularRenderer) => () => void;
+/**
+ * Builds an anchored position strategy and installs the anchored positioning implementation.
+ *
+ * Anchored positioning is the only part of the overlay runtime that needs `@floating-ui/dom`, and it
+ * is reachable only through this function - an app that positions its overlays centered or globally
+ * never bundles it. Always build anchored strategies with this helper instead of a plain
+ * `{ kind: 'anchored', ... }` literal.
+ *
+ * Overlays that set `autoResize`, `autoHide`, `autoCloseIfReferenceHidden` or render an arrow
+ * additionally need `enableAnchoredOverlayPositionExtras()`.
+ */
+declare const anchoredOverlayPosition: (config: Omit<OverlayRuntimeAnchoredPosition, "kind">) => OverlayRuntimeAnchoredPosition;
+
+/**
+ * Installs the floating-ui middleware anchored overlays need for `autoResize`, `autoHide`,
+ * `autoCloseIfReferenceHidden` and arrows. Call it once wherever such an overlay is built - an
+ * anchored overlay that uses none of those features does not bundle this middleware.
+ */
+declare const enableAnchoredOverlayPositionExtras: () => void;
+
+type OverlayRuntime = {
+    mount: <TComponent extends object, TResult = unknown>(config: OverlayRuntimeMountConfig<TComponent>) => OverlayRuntimeRef<TComponent, TResult>;
+    openEntries: ReturnType<typeof computed<OverlayRuntimeRef<object, unknown>[]>>;
 };
-type PropsInternal = {
-    single: boolean;
-    name: string;
-    bindId: boolean;
-    attached: Signal<boolean>;
-    attachedElements: PropsAttachedElementsInternal;
-    classBindings: Record<string, Signal<unknown>> | null;
-    attributeBindings: Record<string, Signal<unknown>> | null;
-    styleBindings: Record<string, Signal<unknown>> | null;
-    staticClassBindings: string[] | null;
-    staticAttributeBindings: Record<string, unknown> | null;
-    staticStyleBindings: Record<string, unknown> | null;
-    attachEventListeners: ((context: {
-        on: HTMLElement['addEventListener'];
-        element: HTMLElement;
-    }) => void) | null;
+declare const provideOverlayRuntime: () => _angular_core.Provider[];
+declare const injectOverlayRuntime: _ethlete_core.InjectFn<OverlayRuntime>;
+
+declare const createComponentId: (prefix: string) => string;
+/**
+ * A unique id string. Uses `crypto.randomUUID()` when available, but falls back gracefully when it is
+ * not - crucially in **insecure contexts** (a plain-HTTP page served from a LAN IP, not `localhost`),
+ * where `crypto.randomUUID` is `undefined`. Calling it there throws, so anything using it during e.g.
+ * an overlay/menu open would break on such hosts. Prefer this over `crypto.randomUUID()` directly.
+ */
+declare const randomId: () => string;
+
+declare const createDestroy: () => rxjs.Observable<boolean>;
+
+declare const injectHostElement: <T = HTMLElement>() => T;
+declare const injectTemplateRef: <C = unknown>() => TemplateRef<C>;
+type ProviderDefinitionOptions = {
+    /**
+     * Optional name for the provider, useful for debugging.
+     * If not provided, the name will be a generated string.
+     */
+    name?: string;
+    /**
+     * Optional existing InjectionToken to also provide the created provider under.
+     */
+    extraInjectionToken?: InjectionToken<unknown>;
 };
-type CreatePropsOptions = {
-    name: string;
-    bindId?: boolean;
-    single?: boolean;
-    classes?: Record<string, Signal<unknown>>;
-    attributes?: Record<string, Signal<unknown>>;
-    styles?: Record<string, Signal<unknown>>;
-    staticClasses?: string[];
-    staticAttributes?: Record<string, unknown>;
-    staticStyles?: Record<string, unknown>;
-    listeners?: (context: {
-        on: HTMLElement['addEventListener'];
-        element: HTMLElement;
-    }) => void;
+/** The `inject`-shaped half of a provider definition: optional when asked, non-nullable otherwise. */
+type InjectFn<T> = {
+    (): T;
+    (options: InjectOptions & {
+        optional?: false;
+    }): T;
+    (options: InjectOptions): T | null;
+};
+/**
+ * What {@link defineProvider} & co. return: the token plus the two functions a domain re-exports as its
+ * `provideX` / `injectX` pair. Read the halves out with {@link toProvideFn}, {@link toInjectFn} and
+ * {@link toToken} - never by destructuring, see {@link defineProvider}.
+ */
+type ProviderDefinition<T> = {
+    readonly provide: () => Provider[];
+    readonly inject: InjectFn<T>;
+    readonly token: InjectionToken<T>;
+};
+/** {@link ProviderDefinition} for a value provider, whose `provide` takes a partial override. */
+type StaticProviderDefinition<T> = {
+    readonly provide: (valueOverride?: Partial<T>) => Provider[];
+    readonly inject: InjectFn<T>;
+    readonly token: InjectionToken<T>;
+};
+/**
+ * Defines a provider that a subtree opts into - `provideX()` in some component's `providers`, then
+ * `injectX()` below it. Nothing is created until the subtree provides it.
+ *
+ * Assign the result to one `const`, name the halves with {@link toProvideFn} / {@link toInjectFn} /
+ * {@link toToken}, and put a `__PURE__` annotation comment on each of those declarations. Never destructure
+ * the definition: that declaration cannot be tree-shaken, so it ships the factory's whole closure to
+ * every consumer. Enforced by `ethlete/no-impure-top-level-provider`.
+ */
+declare const defineProvider: <T>(factory: () => T, options?: ProviderDefinitionOptions) => ProviderDefinition<T>;
+/**
+ * Like {@link defineProvider}, but the factory also runs in the root injector, so `injectX()` works
+ * without anyone calling `provideX()`. `provideX()` still exists, to give a subtree its own instance.
+ */
+declare const defineRootProvider: <T>(factory: () => T, options?: ProviderDefinitionOptions) => ProviderDefinition<T>;
+/**
+ * Like {@link defineProvider} for a plain value rather than a factory: `provideX(override)` merges the
+ * partial override over `defaultValue`, which is how every config object in the library is shaped.
+ */
+declare const defineStaticProvider: <T>(defaultValue?: T, options?: ProviderDefinitionOptions) => StaticProviderDefinition<T>;
+/**
+ * {@link defineStaticProvider} whose default is also available in the root injector, so `injectX()`
+ * resolves to `defaultValue` in an app that never provides it.
+ */
+declare const defineStaticRootProvider: <T>(defaultValue?: T, options?: ProviderDefinitionOptions) => StaticProviderDefinition<T>;
+/** The `provideX` half of a provider definition. A call, so a `__PURE__` annotation makes it droppable. */
+declare const toProvideFn: <TDefinition extends {
+    readonly provide: unknown;
+}>(definition: TDefinition) => TDefinition["provide"];
+/** The `injectX` half of a provider definition. */
+declare const toInjectFn: <TDefinition extends {
+    readonly inject: unknown;
+}>(definition: TDefinition) => TDefinition["inject"];
+/** The token behind a provider definition. */
+declare const toToken: <TDefinition extends {
+    readonly token: unknown;
+}>(definition: TDefinition) => TDefinition["token"];
+
+declare const cloneFormGroup: <T extends FormGroup<any>>(formGroup: T) => T;
+declare const getFormGroupValue: <T extends FormGroup>(formGroup: T) => Record<string, unknown>;
+
+declare const createRxHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, options?: EventListenerOptions) => rxjs.Observable<HTMLElementEventMap[K]>;
+declare const applyHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, options?: EventListenerOptions) => rxjs.Subscription;
+declare const applyHostListeners: (listeners: Partial<{ [K in keyof HTMLElementEventMap]: (event: HTMLElementEventMap[K]) => void; }>, options?: EventListenerOptions) => void;
+
+declare class TypedQueryList<T> extends QueryList<T> {
+    get changes(): Observable<TypedQueryList<T>>;
+}
+declare function switchQueryListChanges(): <T extends TypedQueryList<unknown> | null | undefined>(source: Observable<T>) => Observable<T>;
+
+/**
+ * Sets the value of an input signal.
+ * See issue: https://github.com/angular/angular/issues/54782
+ */
+declare const setInputSignal: <T>(input: InputSignal<T> | InputSignalWithTransform<T, unknown>, value: T) => void;
+
+type NgClassType = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+
+declare const AT_LEAST_ONE_REQUIRED = "atLeastOneRequired";
+type ValidateAtLeastOneRequiredConfig = {
+    /**
+     * Keys of form controls to validate in the supplied form group
+     */
+    keys: string[];
+    /**
+     * If true, the value `false` will result in a validation error
+     * @default false
+     */
+    checkFalse?: boolean;
 };
-declare const createProps: (props: CreatePropsOptions) => Props;
-type HostProps = {
-    props: Props;
-    handlers: PropHandlers;
+declare const ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
+declare const IS_ARRAY_NOT_EMPTY = "isArrayNotEmpty";
+declare const IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
+declare const IS_EMAIL = "isEmail";
+declare const IsEmail: (control: AbstractControl) => ValidationErrors | null;
+declare const MUST_MATCH = "mustMatch";
+declare const MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
+    mustMatch: boolean;
+} | null;
+declare const Validators: {
+    readonly MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
+        mustMatch: boolean;
+    } | null;
+    readonly IsEmail: (control: AbstractControl) => ValidationErrors | null;
+    readonly IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
+    readonly ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
 };
-declare const createHostProps: (props: CreatePropsOptions) => HostProps;
 
-declare const createSetup: <T extends Record<string, unknown>>(config: {
-    setupFn: (params: T) => void;
-    this: ThisType<unknown>;
-}) => (params: T) => void;
+declare const copyToClipboard: (text: string) => Observable<boolean>;
+declare const readFromClipboard: () => Observable<string | null>;
 
-declare const createDependencyStash: <T extends Record<string, WritableSignal<unknown>>>(stash: T) => T & {
-    provideSignal: <K extends keyof T>(data: {
-        signal: Signal<ReturnType<T[K]>>;
-        for: K;
-    }) => void;
-    provideValue: <K extends keyof T>(data: {
-        value: ReturnType<T[K]>;
-        for: K;
-    }) => void;
-};
+declare const clone: <T>(original: T) => T;
+declare const equal: (foo: any, bar: any) => boolean;
 
-declare const createElementDictionary: () => {
-    ids: _angular_core.Signal<string[]>;
-    elements: _angular_core.Signal<HTMLElement[]>;
-    has: (id: string) => boolean;
-    get: (id: string) => HTMLElement | null;
-    push: (id: string, element: HTMLElement) => void;
-    remove: (id: string) => void;
-    isEmpty: _angular_core.Signal<boolean>;
-    firstElement: _angular_core.Signal<HTMLElement | null>;
-    firstId: _angular_core.Signal<string | null>;
-};
+declare const hasCookie: (name: string) => boolean;
+declare const getCookie: (name: string) => string | null | undefined;
+declare const setCookie: (name: string, data: string, expiresInDays?: number | null, domain?: string | null, path?: string, sameSite?: "strict" | "none" | "lax") => void;
+declare const deleteCookie: (name: string, path?: string, domain?: string | null) => void;
+declare const getDomain: () => string | null;
 
-type BindPropsOptions = {
-    props: Props | PropsInternal;
-    handlers: PropHandlers;
-};
-declare const bindProps: (config: BindPropsOptions) => void;
-type UnbindPropsOptions = {
-    props: Props | PropsInternal;
-    handlers: PropHandlers;
+type Translatable = {
+    i18n: string;
+    text: string;
 };
-declare const unbindProps: (config: UnbindPropsOptions) => void;
 
-declare class PropsDirective {
-    destroyRef: DestroyRef;
-    props: _angular_core.InputSignalWithTransform<PropsInternal, Readonly<{
-        attached: _angular_core.Signal<boolean>;
-        attachedElements: _ethlete_core.PropsAttachedElements;
-    }>>;
-    propHandlers: {
-        classes: {
-            remove: (tokens: string) => void;
-            removeMany: (tokens: string[]) => void;
-            has: (tokens: string) => boolean;
-            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-        };
-        attributes: {
-            remove: (tokens: string) => void;
-            removeMany: (tokens: string[]) => void;
-            has: (tokens: string) => boolean;
-            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-        };
-        styles: {
-            remove: (tokens: string) => void;
-            removeMany: (tokens: string[]) => void;
-            has: (tokens: string) => boolean;
-            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
-            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
-        };
-        id: string;
-        elementRef: _angular_core.ElementRef<HTMLElement>;
-    };
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PropsDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PropsDirective, "[etProps]", never, { "props": { "alias": "etProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class KeyPressManager {
+    readonly key: number;
+    private readonly _isKeyPressed$;
+    private readonly _keyPressCount$;
+    private readonly _stopTimeout$;
+    constructor(key: number);
+    isPressed(event: KeyboardEvent): boolean;
+    clear(): void;
 }
 
-type AnyTemplateType = string | TemplateRef<unknown> | ComponentType<unknown> | TemplateRefWithContext | ComponentTypeWithInputs;
-type TemplateRefWithContext<T = Record<string, unknown> | undefined, J = unknown> = {
-    template: TemplateRef<J>;
-    context?: T;
-    injector?: Injector;
-};
-type ComponentTypeWithInputs<T = Record<string, unknown> | undefined, J = unknown> = {
-    component: ComponentType<J>;
-    inputs?: T;
-    injector?: Injector;
+declare const DISABLE_LOGGER_PARAM = "et-logger-quiet";
+type CreateLoggerConfig = {
+    scope: string;
+    feature: string;
 };
-type StringTemplate = {
-    type: 'string';
-    value: string;
+declare const createLogger: (config: CreateLoggerConfig) => {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
 };
-type NgTemplateTemplate = {
-    type: 'template';
-    value: TemplateRef<unknown>;
-    context?: Record<string, unknown>;
-    injector: Injector | null;
+
+/**
+ * Converts a markdown string to HTML.
+ * Covers headings, bold, italic, strikethrough, inline code, fenced code blocks,
+ * links, images, block quotes, unordered/ordered (and nested) lists, tables, horizontal rules, and paragraphs.
+ */
+declare const markdownToHtml: (markdown: string) => string;
+/**
+ * Converts an HTML string to markdown.
+ * Covers headings, bold, italic, strikethrough, inline code, fenced code blocks,
+ * links, images, block quotes, unordered/ordered lists, tables, horizontal rules, and paragraphs.
+ */
+declare const htmlToMarkdown: (html: string) => string;
+
+declare const clamp: (value: number, min?: number, max?: number) => number;
+declare const round: (value: number, precision?: number) => number;
+
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+declare const isArray: (value: unknown) => value is unknown[];
+declare const getObjectProperty: (obj: Record<string, unknown>, prop: string) => unknown;
+
+declare const RUNTIME_ERROR_NO_DATA = "__ET_NO_DATA__";
+declare class RuntimeError<T extends number> extends Error {
+    code: T;
+    data: unknown;
+    constructor(code: T, message: null | false | string, data?: unknown);
+}
+declare function formatRuntimeError<T extends number>(code: T, message: null | false | string): string;
+
+type CreateSessionMemoryConfig<TValue> = {
+    key: string;
+    parse: (storedValue: string) => TValue | null;
+    serialize: (value: TValue) => string;
 };
-type ComponentTemplate = {
-    type: 'component';
-    value: ComponentType<unknown>;
-    inputs?: Record<string, unknown>;
-    injector: Injector | null;
+declare const createAutoSessionMemoryKey: ({ element, prefix }: {
+    element: HTMLElement;
+    prefix: string;
+}) => string;
+declare const canUseSessionMemory: () => boolean;
+declare const createSessionMemory: <TValue>({ key, parse, serialize }: CreateSessionMemoryConfig<TValue>) => {
+    read: () => TValue | null;
+    write: (value: TValue) => boolean;
+    remove: () => boolean;
 };
-declare const templateComputed: (templateSignal: Signal<AnyTemplateType | null>) => Signal<StringTemplate | NgTemplateTemplate | ComponentTemplate | null>;
 
-declare const injectAngularRootElement: {
-    (): _angular_core.WritableSignal<HTMLElement | null>;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): _angular_core.WritableSignal<HTMLElement | null>;
-    (options: _angular_core.InjectOptions): _angular_core.WritableSignal<HTMLElement | null> | null;
+type SwipeTracker = {
+    update(event: TouchEvent | MouseEvent): SwipeUpdateEvent;
+    end(): SwipeEndEvent;
+    cancel(): void;
 };
+type SwipeEndEvent = {
+    /**
+     * Speed at the moment of release, measured over the trailing {@link SWIPE_VELOCITY_WINDOW_MS} of
+     * the gesture - not the whole-gesture average. A slow drag that ends in a flick reports the
+     * flick, and a flick that ends parked reports ~0.
+     */
+    positivePixelPerSecondX: number;
+    positivePixelPerSecondY: number;
+    pixelPerSecondX: number;
+    pixelPerSecondY: number;
+    movementX: number;
+    movementY: number;
+    positiveMovementX: number;
+    positiveMovementY: number;
+    originClientX: number;
+    originClientY: number;
+};
+type SwipeUpdateEvent = {
+    originClientX: number;
+    originClientY: number;
+    timestamp: number;
+    movementX: number;
+    movementY: number;
+    positiveMovementX: number;
+    positiveMovementY: number;
+    isScrolling: boolean;
+    isSwiping: boolean;
+};
+/** Trailing window over which {@link SwipeTracker.end} measures the release velocity. */
+declare const SWIPE_VELOCITY_WINDOW_MS = 100;
+declare const createSwipeTracker: (startEvent: TouchEvent | MouseEvent) => SwipeTracker;
 
-declare const provideBoundaryElement: () => _angular_core.Provider[];
-declare const injectBoundaryElement: {
-    (): {
-        value: _angular_core.Signal<HTMLElement>;
-        override: _angular_core.WritableSignal<HTMLElement | null>;
-    };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        value: _angular_core.Signal<HTMLElement>;
-        override: _angular_core.WritableSignal<HTMLElement | null>;
-    };
-    (options: _angular_core.InjectOptions): {
-        value: _angular_core.Signal<HTMLElement>;
-        override: _angular_core.WritableSignal<HTMLElement | null>;
-    } | null;
+declare class NormalizeGameResultTypePipe implements PipeTransform {
+    transform: (type: string | null) => NormalizedGameResultType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeGameResultTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeGameResultTypePipe, "etNormalizeGameResultType", true>;
+}
+type NormalizedGameResultType = Translatable & {
+    shortCode: string;
 };
-declare const BOUNDARY_ELEMENT_TOKEN: _angular_core.InjectionToken<{
-    value: _angular_core.Signal<HTMLElement>;
-    override: _angular_core.WritableSignal<HTMLElement | null>;
-}>;
+declare const normalizeGameResultType: (type: string | null) => NormalizedGameResultType | null;
 
-type Vec2 = [number, number];
-type ViewportConfig = {
-    breakpoints: {
-        xs: Vec2;
-        sm: Vec2;
-        md: Vec2;
-        lg: Vec2;
-        xl: Vec2;
-        '2xl': Vec2;
-    };
-};
-type Breakpoint = keyof ViewportConfig['breakpoints'];
-/**
- * Default viewport config based on Tailwind CSS.
- * @see https://tailwindcss.com/docs/screens
- */
-declare const DEFAULT_VIEWPORT_CONFIG: ViewportConfig;
-declare const provideViewportConfig: (valueOverride?: Partial<ViewportConfig> | undefined) => _angular_core.Provider[];
-declare const injectViewportConfig: {
-    (): ViewportConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): ViewportConfig;
-    (options: _angular_core.InjectOptions): ViewportConfig | null;
-};
-type BuildMediaQueryOptions = {
-    min?: number | Breakpoint;
-    max?: number | Breakpoint;
+declare class NormalizeMatchParticipantsPipe implements PipeTransform {
+    transform: (match: MatchListView | null) => NormalizedMatchParticipants | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchParticipantsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchParticipantsPipe, "etNormalizeMatchParticipants", true>;
+}
+type NormalizedMatchParticipants = {
+    home: NormalizedMatchParticipant | null;
+    away: NormalizedMatchParticipant | null;
 };
-declare const provideBreakpointObserver: () => _angular_core.Provider[];
-declare const injectBreakpointObserver: {
-    (): {
-        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
-        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
-        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
-        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
-        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
-        isMediaQueryMatched: (mediaQuery: string) => boolean;
+type NormalizedParticipantType = 'team' | 'player' | 'unknown';
+type NormalizedMatchParticipant = ({
+    type: 'tbd';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion | null;
+} & Translatable) | {
+    type: 'participant';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion;
+} | ({
+    type: 'none';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion | null;
+} & Translatable);
+declare const normalizeMatchParticipants: (match: MatchListView | null) => NormalizedMatchParticipants | null;
+declare const normalizeMatchParticipant: (match: MatchListView | null, side: "home" | "away") => NormalizedMatchParticipant | null;
+
+declare class NormalizeMatchScorePipe implements PipeTransform {
+    transform: (match: MatchListView | null | undefined) => NormalizedMatchScore | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchScorePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchScorePipe, "etNormalizeMatchScore", true>;
+}
+declare const enum MatchStateType {
+    PREPARING_ROUND = "preparingRound",
+    PRE_MATCH = "preMatch",
+    LIVE = "live",
+    POST_MATCH = "postMatch",
+    AUTO_WIN = "autoWin"
+}
+type NormalizedMatchScore = {
+    home: {
+        score: string | number | null;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
-        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
-        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
-        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
-        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
-        isMediaQueryMatched: (mediaQuery: string) => boolean;
+    away: {
+        score: string | number | null;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions): {
-        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
-        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
-        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
-        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
-        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
-        isMediaQueryMatched: (mediaQuery: string) => boolean;
-    } | null;
+    subLine: string | null;
+    isNumeric: boolean;
 };
-
-declare const provideFocusVisibleTracker: () => _angular_core.Provider[];
-declare const injectFocusVisibleTracker: {
-    (): {
-        isFocusVisible: _angular_core.Signal<boolean>;
+declare const normalizeMatchScore: (match: MatchListView | null | undefined) => NormalizedMatchScore | null;
+declare const isKnockoutMatch: (match: MatchListView | null | undefined) => boolean;
+declare const isGroupMatch: (match: MatchListView | null | undefined) => boolean;
+declare const getKnockoutMatchScore: (score: MatchRankingView | null | undefined) => "match-score.knockout.won" | "match-score.knockout.lost" | "match-score.knockout.tie" | null;
+declare const getMatchScoreSubLine: (match: MatchListView | null | undefined) => "match-score.groups.sub-line" | null;
+declare const getGroupMatchScore: (match: MatchListView | null | undefined) => {
+    home: {
+        score: number;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        isFocusVisible: _angular_core.Signal<boolean>;
+    away: {
+        score: number;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions): {
-        isFocusVisible: _angular_core.Signal<boolean>;
-    } | null;
-};
-declare const FOCUS_VISIBLE_TRACKER_TOKEN: _angular_core.InjectionToken<{
-    isFocusVisible: _angular_core.Signal<boolean>;
-}>;
-
-declare const provideLocale: () => _angular_core.Provider[];
-declare const injectLocale: {
-    (): {
-        currentLocale: _angular_core.WritableSignal<string>;
+} | null;
+declare const getGroupMatchPoints: (match: MatchListView | null | undefined) => {
+    home: {
+        score: number;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        currentLocale: _angular_core.WritableSignal<string>;
+    away: {
+        score: number;
+        isWinner: boolean;
     };
-    (options: _angular_core.InjectOptions): {
-        currentLocale: _angular_core.WritableSignal<string>;
-    } | null;
-};
+} | null;
 
-declare const provideRenderer: () => _angular_core.Provider[];
-declare const injectRenderer: {
-    (): {
-        addClass: (element: HTMLElement, ...classes: string[]) => void;
-        removeClass: (element: HTMLElement, ...classes: string[]) => void;
-        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
-        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
-        removeStyle: (element: HTMLElement, style: keyof CSSStyleDeclaration | string, flags?: RendererStyleFlags2) => void;
-        removeStyles: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration | string)[]) => void;
-        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
-        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
-        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
-        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
-        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
-        createText: (value: string) => Text;
-        createComment: (value: string) => Comment;
-        appendChild: (parent: HTMLElement, newChild: Node) => void;
-        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
-        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
-        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
-        parentNode: (node: Node) => Node | null;
-        nextSibling: (node: Node) => Node | null;
-        setValue: (node: Node, value: string) => void;
-        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
-        destroyNode: (node: Node) => void;
-        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
-        empty: (element: HTMLElement) => void;
-        setTextContent: (element: HTMLElement, text: string) => void;
-        setInnerHTML: (element: HTMLElement, html: string) => void;
-        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
-        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
-        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
-        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
-        renderer: _angular_core.Renderer2;
-    };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        addClass: (element: HTMLElement, ...classes: string[]) => void;
-        removeClass: (element: HTMLElement, ...classes: string[]) => void;
-        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
-        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
-        removeStyle: (element: HTMLElement, style: keyof CSSStyleDeclaration | string, flags?: RendererStyleFlags2) => void;
-        removeStyles: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration | string)[]) => void;
-        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
-        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
-        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
-        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
-        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
-        createText: (value: string) => Text;
-        createComment: (value: string) => Comment;
-        appendChild: (parent: HTMLElement, newChild: Node) => void;
-        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
-        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
-        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
-        parentNode: (node: Node) => Node | null;
-        nextSibling: (node: Node) => Node | null;
-        setValue: (node: Node, value: string) => void;
-        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
-        destroyNode: (node: Node) => void;
-        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
-        empty: (element: HTMLElement) => void;
-        setTextContent: (element: HTMLElement, text: string) => void;
-        setInnerHTML: (element: HTMLElement, html: string) => void;
-        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
-        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
-        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
-        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
-        renderer: _angular_core.Renderer2;
-    };
-    (options: _angular_core.InjectOptions): {
-        addClass: (element: HTMLElement, ...classes: string[]) => void;
-        removeClass: (element: HTMLElement, ...classes: string[]) => void;
-        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
-        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
-        removeStyle: (element: HTMLElement, style: keyof CSSStyleDeclaration | string, flags?: RendererStyleFlags2) => void;
-        removeStyles: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration | string)[]) => void;
-        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
-        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
-        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
-        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
-        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
-        createText: (value: string) => Text;
-        createComment: (value: string) => Comment;
-        appendChild: (parent: HTMLElement, newChild: Node) => void;
-        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
-        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
-        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
-        parentNode: (node: Node) => Node | null;
-        nextSibling: (node: Node) => Node | null;
-        setValue: (node: Node, value: string) => void;
-        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
-        destroyNode: (node: Node) => void;
-        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
-        empty: (element: HTMLElement) => void;
-        setTextContent: (element: HTMLElement, text: string) => void;
-        setInnerHTML: (element: HTMLElement, html: string) => void;
-        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
-        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
-        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
-        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
-        renderer: _angular_core.Renderer2;
-    } | null;
-};
-type AngularRenderer = NonNullable<ReturnType<typeof injectRenderer>>;
+declare class NormalizeMatchStatePipe implements PipeTransform {
+    transform: (match: MatchListView | null | undefined) => MatchStateType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchStatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchStatePipe, "etNormalizeMatchState", true>;
+}
+declare const normalizeMatchState: (match: MatchListView | null | undefined) => MatchStateType | null;
 
-declare const previousSignalValue: <T>(signal: Signal<T>) => Signal<T | undefined>;
-type SyncSignalOptions = {
-    /**
-     * If true, the target signal will not be updated with the source signal's value in a sync operation.
-     * This should be set to true for signals that need to be initialized first before syncing (eg. required inputs)
-     * @default false
-     */
-    skipSyncRead?: boolean;
-    /**
-     * If true, the first time the effect will be triggered will be skipped.
-     * @default false
-     */
-    skipFirstRun?: boolean;
-};
-declare const syncSignal: <T>(from: Signal<T>, to: WritableSignal<T>, options?: SyncSignalOptions) => _angular_core.EffectRef;
-type MaybeSignal<T> = T | Signal<T>;
-declare const maybeSignalValue: <T>(value: MaybeSignal<T>) => T;
-/**
- * A computed that will only be reactive until the source signal contains a truthy value.
- * All subsequent changes inside the computation will be ignored.
- */
-declare const computedTillTruthy: <T>(source: Signal<T>) => Signal<T | null>;
-/**
- * A computed that will only be reactive until the source signal contains a falsy value.
- * All subsequent changes inside the computation will be ignored.
- */
-declare const computedTillFalsy: <T>(source: Signal<T>) => Signal<T | null>;
-/**
- * A writeable signal that will be set to the provided value once all inputs are set.
- * During that time, the signal will be set to `null`.
- */
-declare const deferredSignal: <T extends () => unknown>(valueFn: T) => WritableSignal<ReturnType<T> | null>;
-declare const memoizeSignal: <T>(factory: () => Signal<T>) => () => Signal<T>;
+declare class NormalizeMatchTypePipe implements PipeTransform {
+    transform: (matchType: StageType | null | undefined) => Translatable | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchTypePipe, "etNormalizeMatchType", true>;
+}
+declare const normalizeMatchType: (matchType: StageType | null | undefined) => Translatable | null;
 
-type SignalAnimatedNumberOptions = {
-    /**
-     * The initial value to start animating from.
-     * If not provided, the animation will start from 0
-     */
-    initialValue?: number;
-    /**
-     * Duration of the animation in milliseconds.
-     * @default 1000
-     */
-    duration?: number;
-    /**
-     * Easing function that takes a progress value (0 to 1) and returns an eased value (0 to 1).
-     * Options:
-     * - `easeLinear()`
-     * - `easeIn()`
-     * - `easeOut()`
-     * - `easeInOut()`
-     * - `easeElastic()`
-     * - `easeOutBack()`
-     * - `easeOutBackStrong()`
-     * @default easeOut()
-     */
-    easing?: (t: number) => number;
-    /**
-     * Function to round the animated value.
-     * @default (v: number) => Math.round(v)
-     */
-    round?: (value: number) => number;
-    /**
-     * Callback invoked when the animation starts.
-     */
-    onAnimationStart?: () => void;
-    /**
-     * Callback invoked when the animation ends.
-     */
-    onAnimationEnd?: () => void;
-};
-type AnimatedNumberSignal = Signal<number> & {
-    /**
-     * Starts the animation from the current value to the target value.
-     * @returns The animated signal for chaining
-     */
-    play: () => AnimatedNumberSignal;
-    /**
-     * Resets the animation to the initial value and stops any ongoing animation.
-     * @returns The animated signal for chaining
-     */
-    reset: () => AnimatedNumberSignal;
-    /**
-     * Stops the current animation at its current position.
-     * @returns The animated signal for chaining
-     */
-    stop: () => AnimatedNumberSignal;
-};
+declare class HtmlToMarkdownPipe implements PipeTransform {
+    transform: (html: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HtmlToMarkdownPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HtmlToMarkdownPipe, "htmlToMarkdown", true>;
+}
+
+declare class InferMimeTypePipe implements PipeTransform {
+    transform: (srcset: string) => string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InferMimeTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InferMimeTypePipe, "inferMimeType", true>;
+}
 /**
- * Creates a signal that animates the transition of a numeric signal's value over time.
+ * Infers the mime type of a given url or srcset.
+ * If a srcset is provided, it will infer the mime type of the first url in the srcset.
+ * If the srcset contains a query parameter `?fm=`, it will use the value of that parameter, since it is often used to specify the file format in image api's like contentful.
  */
-declare const signalAnimatedNumber: (source: MaybeSignal<number>, options?: SignalAnimatedNumberOptions) => AnimatedNumberSignal;
-declare const easeLinear: (t: number) => number;
-declare const easeIn: (t: number) => number;
-declare const easeOut: (t: number) => number;
-declare const easeInOut: (t: number) => number;
-/** Elastic easing function (overshoots) */
-declare const easeElastic: (t: number) => number;
-/** Back easing function (overshoots slightly then settles) */
-declare const easeOutBack: (t: number) => number;
-/** Back easing function with more overshoot */
-declare const easeOutBackStrong: (t: number) => number;
+declare const inferMimeType: (srcset: string) => string | null;
 
-type ControlValueSignalOptions = {
-    debounceTime?: number;
-    /**
-     * @default false
-     */
-    debounceFirst?: boolean;
-};
-declare const controlValueSignal: <TControlInput extends Signal<AbstractControl | null> | AbstractControl, TControl extends TControlInput extends Signal<infer TSignalControl> ? TSignalControl : TControlInput>(control: TControlInput, options?: ControlValueSignalOptions) => Signal<ReturnType<NonNullable<TControl>["getRawValue"]> | null>;
+declare class InitialsPipe implements PipeTransform {
+    transform: (value: string | null | undefined, maxLength?: number) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InitialsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InitialsPipe, "initials", true>;
+}
 /**
- * The first item in the pair is the previous value and the second item is the current value.
+ * Extracts the initials from a name (or any whitespace separated string).
+ *
+ * Words are split on whitespace, and the first character of each word is taken.
+ * At most `maxLength` initials are returned (defaults to 2), always uppercased.
+ *
+ * @example
+ * initials('John Doe') // 'JD'
+ * initials('john doe smith') // 'JD'
+ * initials('john doe smith', 3) // 'JDS'
+ * initials('Madonna') // 'M'
+ * initials('  ') // ''
+ * initials(null) // ''
  */
-declare const controlValueSignalWithPrevious: <T extends AbstractControl>(control: T, options?: ControlValueSignalOptions) => Signal<[ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null, ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null]>;
-
-type SignalElementBindingComplexType = HTMLElement | ElementRef<HTMLElement> | QueryList<ElementRef<HTMLElement> | HTMLElement> | Array<ElementRef<HTMLElement> | HTMLElement> | null | undefined;
-type SignalElementBindingType = HTMLElement | ElementRef<HTMLElement> | Observable<SignalElementBindingComplexType> | Signal<SignalElementBindingComplexType> | QueryList<ElementRef<HTMLElement> | HTMLElement> | ElementSignal;
-type ElementSignal = Signal<{
-    currentElements: HTMLElement[];
-    previousElements: HTMLElement[];
-}>;
-type ElementSignalValue = ReturnType<ElementSignal>;
-declare const isElementSignal: (el: unknown) => el is ElementSignal;
-declare const createDocumentElementSignal: () => ElementSignal;
-declare const createEmptyElementSignal: () => ElementSignal;
-declare const buildElementSignal: (el: SignalElementBindingType | null | undefined) => ElementSignal;
-declare const firstElementSignal: (el: ElementSignal) => Signal<{
-    currentElement: HTMLElement | null;
-    previousElement: HTMLElement | null;
-}>;
+declare const initials: (value: string | null | undefined, maxLength?: number) => string;
 
-declare const signalElementChildren: (el: SignalElementBindingType) => _angular_core.Signal<HTMLElement[]>;
+declare class MarkdownToHtmlPipe implements PipeTransform {
+    transform: (markdown: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownToHtmlPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<MarkdownToHtmlPipe, "markdownToHtml", true>;
+}
 
-type BuildSignalEffectsConfig<T extends Record<string, Signal<unknown>>> = {
-    /** The tokens to apply and their signal value  */
-    tokenMap: T;
-    /** This function will be invoked for elements that were removed from the signal effects */
-    cleanupFn: (el: HTMLElement, tokens: string[]) => void;
-    /** This function will be invoked for elements that were added to the signal effects or when their signal value changes */
-    updateFn: (el: HTMLElement, tokens: string[], conditionResult: unknown) => void;
-};
-declare const buildSignalEffects: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, config: BuildSignalEffectsConfig<T>) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalClasses: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, classMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalHostClasses: <T extends Record<string, Signal<unknown>>>(classMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalAttributes: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, attributeMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalHostAttributes: <T extends Record<string, Signal<unknown>>>(attributeMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalStyles: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, styleMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
-};
-declare const signalHostStyles: <T extends Record<string, Signal<unknown>>>(styleMap: T) => {
-    remove: (tokens: string) => void;
-    removeMany: (tokens: string[]) => void;
-    has: (tokens: string) => boolean;
-    push: (tokens: string, signal: Signal<unknown>) => void;
-    pushMany: (map: Record<string, Signal<unknown>>) => void;
+declare class SlugifyPipe implements PipeTransform {
+    transform: (value: string | null | undefined) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlugifyPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SlugifyPipe, "slugify", true>;
+}
+/**
+ * Converts a string into a URL-friendly slug.
+ *
+ * Diacritics are stripped, the string is lowercased, and any run of
+ * non-alphanumeric characters becomes a single hyphen. Leading/trailing
+ * hyphens are trimmed.
+ *
+ * @example
+ * slugify('Hello World') // 'hello-world'
+ * slugify('  Crème brûlée!  ') // 'creme-brulee'
+ * slugify('FC Bayern München') // 'fc-bayern-munchen'
+ * slugify('foo_bar / baz') // 'foo-bar-baz'
+ * slugify(null) // ''
+ */
+declare const slugify: (value: string | null | undefined) => string;
+
+declare class ToArrayPipe implements PipeTransform {
+    transform: (value: number) => number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToArrayPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToArrayPipe, "toArray", true>;
+}
+declare const toArray: (value: number) => number[];
+declare const toArrayTrackByFn: TrackByFunction<number>;
+
+declare const createPropHandlers: () => {
+    classes: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    attributes: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    styles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    id: string;
+    elementRef: ElementRef<HTMLElement>;
 };
+type PropHandlers = ReturnType<typeof createPropHandlers>;
 
-type LogicalSize = {
-    inlineSize: number;
-    blockSize: number;
+type Props = Readonly<{
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElements;
+}>;
+type PropsAttachedElements = {
+    first: Signal<HTMLElement | null>;
+    firstId: Signal<string | null>;
+    get(id: string): HTMLElement | null;
 };
-type ElementRect = {
-    bottom: number;
-    height: number;
-    left: number;
-    right: number;
-    top: number;
-    width: number;
-    x: number;
-    y: number;
+type PropsAttachedElementsInternal = PropsAttachedElements & {
+    has: (id: string) => boolean;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
 };
-type ElementSize = {
-    width: number;
-    height: number;
+type PropsInternal = {
+    single: boolean;
+    name: string;
+    bindId: boolean;
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElementsInternal;
+    classBindings: Record<string, Signal<unknown>> | null;
+    attributeBindings: Record<string, Signal<unknown>> | null;
+    styleBindings: Record<string, Signal<unknown>> | null;
+    staticClassBindings: string[] | null;
+    staticAttributeBindings: Record<string, unknown> | null;
+    staticStyleBindings: Record<string, unknown> | null;
+    attachEventListeners: ((context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void) | null;
 };
-declare const boundingClientRectToElementRect: (rect: DOMRectReadOnly) => ElementRect;
-declare const createElementDimensions: (el: HTMLElement | null, rect?: DOMRect) => NullableElementDimensions;
-type ElementDimensions = {
-    rect: () => ElementRect;
-    client: ElementSize;
-    scroll: ElementSize;
-    offset: ElementSize;
+type CreatePropsOptions = {
+    name: string;
+    bindId?: boolean;
+    single?: boolean;
+    classes?: Record<string, Signal<unknown>>;
+    attributes?: Record<string, Signal<unknown>>;
+    styles?: Record<string, Signal<unknown>>;
+    staticClasses?: string[];
+    staticAttributes?: Record<string, unknown>;
+    staticStyles?: Record<string, unknown>;
+    listeners?: (context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void;
 };
-type NullableElementDimensions = {
-    [K in keyof ElementDimensions]: ElementDimensions[K] | null;
+declare const createProps: (props: CreatePropsOptions) => Props;
+type HostProps = {
+    props: Props;
+    handlers: PropHandlers;
 };
-declare const signalElementDimensions: (el: SignalElementBindingType) => _angular_core.Signal<NullableElementDimensions>;
-declare const signalHostElementDimensions: () => _angular_core.Signal<NullableElementDimensions>;
+declare const createHostProps: (props: CreatePropsOptions) => HostProps;
 
-type SignalElementIntersectionOptions = Omit<IntersectionObserverInit, 'root'> & {
-    root?: SignalElementBindingType;
-    enabled?: Signal<boolean>;
-};
-type IntersectionObserverEntryWithDetails = IntersectionObserverEntry & {
-    isAbove: boolean;
-    isBelow: boolean;
-    isLeft: boolean;
-    isRight: boolean;
-    isVisible: boolean;
-};
-declare const signalElementIntersection: (el: SignalElementBindingType, options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
-declare const signalHostElementIntersection: (options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
+declare const createSetup: <T extends Record<string, unknown>>(config: {
+    setupFn: (params: T) => void;
+    this: ThisType<unknown>;
+}) => (params: T) => void;
 
-declare const signalElementMutations: (el: SignalElementBindingType, options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
-declare const signalHostElementMutations: (options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
+declare const createDependencyStash: <T extends Record<string, WritableSignal<unknown>>>(stash: T) => T & {
+    provideSignal: <K extends keyof T>(data: {
+        signal: Signal<ReturnType<T[K]>>;
+        for: K;
+    }) => void;
+    provideValue: <K extends keyof T>(data: {
+        value: ReturnType<T[K]>;
+        for: K;
+    }) => void;
+};
 
-type ElementLastScrollDirectionType = 'up' | 'down' | 'left' | 'right';
-type ElementLastScrollDirection = {
-    type: ElementLastScrollDirectionType;
-    time: number;
+declare const createElementDictionary: () => {
+    ids: _angular_core.Signal<string[]>;
+    elements: _angular_core.Signal<HTMLElement[]>;
+    has: (id: string) => boolean;
+    get: (id: string) => HTMLElement | null;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+    isEmpty: _angular_core.Signal<boolean>;
+    firstElement: _angular_core.Signal<HTMLElement | null>;
+    firstId: _angular_core.Signal<string | null>;
 };
-declare const signalElementLastScrollDirection: (el: SignalElementBindingType) => _angular_core.Signal<ElementLastScrollDirection | null>;
-declare const signalHostElementLastScrollDirection: () => _angular_core.Signal<ElementLastScrollDirection | null>;
 
-type SignalElementScrollStateOptions = {
-    /** The initial scroll position to scroll to. Once a truthy value get's emitted, all further values will be ignored. */
-    initialScrollPosition?: Signal<ScrollToOptions | null>;
+type BindPropsOptions = {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
 };
-type ElementScrollState = {
-    canScroll: boolean;
-    canScrollHorizontally: boolean;
-    canScrollVertically: boolean;
-    elementDimensions: NullableElementDimensions;
+declare const bindProps: (config: BindPropsOptions) => void;
+type UnbindPropsOptions = {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
 };
-declare const areScrollStatesEqual: (a: ElementScrollState, b: ElementScrollState) => boolean;
-declare const signalElementScrollState: (el: SignalElementBindingType, options?: SignalElementScrollStateOptions) => Signal<ElementScrollState>;
-declare const signalHostElementScrollState: () => Signal<ElementScrollState>;
-
-/** Inject a signal containing a boolean value indicating if the viewport is xs */
-declare const injectIsXs: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing a boolean value indicating if the viewport is sm */
-declare const injectIsSm: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing a boolean value indicating if the viewport is md */
-declare const injectIsMd: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing a boolean value indicating if the viewport is lg */
-declare const injectIsLg: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing a boolean value indicating if the viewport is xl */
-declare const injectIsXl: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing a boolean value indicating if the viewport is 2xl */
-declare const injectIs2Xl: () => _angular_core.Signal<boolean>;
-/**
- * Inject a boolean value indicating if the viewport is matching the provided options.
- * This value is not reactive. If you want to react to changes, use the {@link injectObserveBreakpoint} function instead.
- */
-declare const injectBreakpointIsMatched: (options: BuildMediaQueryOptions) => boolean;
-/**
- * Inject a boolean value indicating if the media query is matched.
- * This value is not reactive. If you want to react to changes, use the {@link injectObserveMediaQuery} function instead.
- */
-declare const injectMediaQueryIsMatched: (mediaQuery: string) => boolean;
-/**
- * Inject a signal containing a boolean value indicating if the viewport is matching the provided options.
- */
-declare const injectObserveBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
-/**
- * Inject a signal containing a boolean value indicating if the media query is matched.
- */
-declare const injectObserveMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
-/** Inject a signal containing the current breakpoint. */
-declare const injectCurrentBreakpoint: () => _angular_core.Signal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
-/** Inject a signal that indicates if the user is using a portrait display */
-declare const injectIsPortrait: () => _angular_core.Signal<boolean>;
-/** Inject a signal that indicates if the user is using a landscape display */
-declare const injectIsLandscape: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing the current display orientation */
-declare const injectDisplayOrientation: () => _angular_core.Signal<"portrait" | "landscape">;
-/** Inject a signal that indicates if the device has a touch input */
-declare const injectHasTouchInput: () => _angular_core.Signal<boolean>;
-/** Inject a signal that indicates if the device has a fine input (mouse or stylus)  */
-declare const injectHasPrecisionInput: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing the current device input type */
-declare const injectDeviceInputType: () => _angular_core.Signal<"touch" | "mouse">;
-/** Inject a signal containing a boolean value indicating if the user can hover (eg. using a mouse) */
-declare const injectCanHover: () => _angular_core.Signal<boolean>;
-/** Inject a signal containing the viewport dimensions */
-declare const injectViewportDimensions: () => _angular_core.Signal<_ethlete_core.NullableElementDimensions>;
-/** Inject a signal containing the scrollbar dimensions. Dimensions will be 0 if scrollbars overlap the page contents (like on mobile). */
-declare const injectScrollbarDimensions: () => _angular_core.Signal<{
-    width: number;
-    height: number;
-} | null>;
+declare const unbindProps: (config: UnbindPropsOptions) => void;
 
-/**
- * Applies scrollbar size CSS variables to the documentElement (html tag) in pixels.
- * - `--et-sw`: scrollbar width
- * - `--et-sh`: scrollbar height
- */
-declare const writeScrollbarSizeToCssVariables: () => void;
-/**
- * Applies viewport size CSS variables to the documentElement (html tag) in pixels.
- * - `--et-vw`: viewport width excluding scrollbar width
- * - `--et-vh`: viewport height excluding scrollbar height
- */
-declare const writeViewportSizeToCssVariables: () => void;
+declare class PropsDirective {
+    private destroyRef;
+    props: _angular_core.InputSignalWithTransform<PropsInternal, Readonly<{
+        attached: _angular_core.Signal<boolean>;
+        attachedElements: _ethlete_core.PropsAttachedElements;
+    }>>;
+    propHandlers: {
+        classes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        attributes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        styles: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        id: string;
+        elementRef: _angular_core.ElementRef<HTMLElement>;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PropsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PropsDirective, "[etProps]", never, { "props": { "alias": "etProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
-type CursorDragScrollDirection = 'horizontal' | 'vertical' | 'both';
-type CursorDragScrollOptions = {
-    /** If true, cursor drag scrolling will be enabled. */
-    enabled?: Signal<boolean>;
-    /** The allowed scroll direction. */
-    allowedDirection?: MaybeSignal<CursorDragScrollDirection>;
+type ComponentType<T> = new (...args: any[]) => T;
+type AnyTemplateType = string | TemplateRef<unknown> | ComponentType<unknown> | TemplateRefWithContext | ComponentTypeWithInputs;
+type TemplateRefWithContext<T = Record<string, unknown> | undefined, J = unknown> = {
+    template: TemplateRef<J>;
+    context?: T;
+    injector?: Injector;
 };
-/** A function to apply cursor drag scroll behavior to an element. */
-declare const useCursorDragScroll: (el: SignalElementBindingType, options?: CursorDragScrollOptions) => {
-    isDragging: Signal<boolean>;
-    currentDragAmount: Signal<{
-        x: number;
-        y: number;
-    }>;
+type ComponentTypeWithInputs<T = Record<string, unknown> | undefined, J = unknown> = {
+    component: ComponentType<J>;
+    inputs?: T;
+    injector?: Injector;
+};
+type StringTemplate = {
+    type: 'string';
+    value: string;
+};
+type NgTemplateTemplate = {
+    type: 'template';
+    value: TemplateRef<unknown>;
+    context?: Record<string, unknown>;
+    injector: Injector | null;
+};
+type ComponentTemplate = {
+    type: 'component';
+    value: ComponentType<unknown>;
+    inputs?: Record<string, unknown>;
+    injector: Injector | null;
 };
+declare const templateComputed: (templateSignal: Signal<AnyTemplateType | null>) => Signal<StringTemplate | NgTemplateTemplate | ComponentTemplate | null>;
 
-type SetupScrollRestorationConfig = {
+type ResizeEdge = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+type ResizeMoveEvent = {
+    edge: ResizeEdge;
+    /** Cumulative delta from the pointerdown position. */
+    dx: number;
+    dy: number;
+    clientX: number;
+    clientY: number;
+};
+declare class ResizeHandlesComponent {
+    edges: _angular_core.InputSignal<ResizeEdge[]>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private gestureStart$;
+    private gesture$;
+    resizeStarted: _angular_core.OutputRef<ResizeEdge>;
+    resizeMoved: _angular_core.OutputRef<ResizeMoveEvent>;
+    resizeEnded: _angular_core.OutputRef<void>;
+    isResizing: _angular_core.Signal<boolean>;
+    activeEdge: _angular_core.Signal<ResizeEdge | null>;
+    readonly edgeCursors: Record<ResizeEdge, string>;
+    startResizeGesture(event: PointerEvent, edge: ResizeEdge): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizeHandlesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResizeHandlesComponent, "et-resize-handles", never, { "edges": { "alias": "edges"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "resizeStarted": "resizeStarted"; "resizeMoved": "resizeMoved"; "resizeEnded": "resizeEnded"; }, never, never, true, never>;
+}
+
+declare const elementCanScroll: (element?: HTMLElement | null, direction?: "x" | "y") => boolean;
+type IsElementVisibleOptions = {
     /**
-     * The scrollable container.
-     * @default document.documentElement
+     * The element to check if it is visible inside a container.
      */
-    scrollElement?: HTMLElement;
+    element?: HTMLElement | null;
     /**
-     * A list of query params that should trigger a scroll to top.
-     * @default []
-     * @example ['page'] // will scroll to top when the page query param changes
+     * The container to check if the element is visible inside.
+     * If null or undefined, uses the viewport as the container.
+     * @default null (viewport)
      */
-    queryParamTriggerList?: string[];
+    container?: HTMLElement | null;
     /**
-     * Config for fragment scrolling.
+     * The container's rect to check if the element is visible inside. Can be supplied to reduce the amount of DOM reads.
+     * Only used when container is provided and not null.
+     * @default container.getBoundingClientRect()
      */
-    fragment?: {
-        /**
-         * Enable fragment scrolling (scroll to element with id)
-         * @default false
-         */
-        enabled?: boolean;
-        /**
-         * Whether to use smooth scrolling or not.
-         * @default false
-         */
-        smooth?: boolean;
-    };
+    containerRect?: DOMRect | null;
+    /**
+     * The element's rect. Can be supplied to reduce the amount of DOM reads.
+     * @default element.getBoundingClientRect()
+     */
+    elementRect?: DOMRect | null;
 };
-declare const ET_DISABLE_SCROLL_TOP: unique symbol;
-declare const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE: unique symbol;
-declare const ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE: unique symbol;
-type RouterDisableScrollTopConfig = {
+type CurrentElementVisibility = {
     /**
-     * Whether to disable scroll to top ONLY when navigating back to this route.
-     * @default false
+     * Whether the element is visible in the inline direction.
      */
-    asReturnRoute?: boolean;
+    inline: boolean;
     /**
-     * Whether to disable scroll to top when a path param changes.
-     * @default false
+     * Whether the element is visible in the block direction.
      */
-    onPathParamChange?: boolean;
-};
-declare const routerDisableScrollTop: (config?: RouterDisableScrollTopConfig) => {
-    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
-    [ET_DISABLE_SCROLL_TOP]: boolean;
-} | {
-    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
-    [ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE]: boolean;
-};
-declare const setupScrollRestoration: (config?: SetupScrollRestorationConfig) => void;
-
-declare const signalIsRendered: () => _angular_core.Signal<boolean>;
-declare const createIsRenderedSignal: () => {
-    state: _angular_core.WritableSignal<boolean>;
-    bind: () => _angular_core.EffectRef;
-};
-declare const createCanAnimateSignal: () => {
-    state: _angular_core.Signal<boolean>;
-};
-
-type RouterState = {
-    data: Data;
-    pathParams: Params;
-    queryParams: Params;
-    title: string | null;
-    fragment: string | null;
-};
-declare const ET_PROPERTY_REMOVED: unique symbol;
-type InjectUtilConfig = {
-    /** The injector to use for the injection. Must be provided if the function is not called from within a injection context. */
-    injector?: Injector;
-};
-type InjectUtilTransformConfig<In, Out> = {
+    block: boolean;
     /**
-     * A transform function similar to the `transform` function in Angular input bindings.
-     * Can be used to transform the value before it is returned.
-     * E.g. transforming `"true"` to `true` for a boolean attribute.
+     * The percentage of the element that is visible in the inline direction.
      */
-    transform?: (value: In) => Out;
+    inlineIntersection: number;
+    /**
+     * The percentage of the element that is visible in the block direction.
+     */
+    blockIntersection: number;
+    /**
+     * Whether the element is intersecting the container.
+     */
+    isIntersecting: boolean;
+    /**
+     * The ratio of the element that is intersecting the container.
+     */
+    intersectionRatio: number;
+    /**
+     * The element that is being checked for visibility.
+     */
+    element: HTMLElement;
+    /**
+     * The container's rect used for the calculation.
+     */
+    containerRect: DOMRect;
+    /**
+     * The element's rect used for the calculation.
+     */
+    elementRect: DOMRect;
 };
-declare const transformOrReturn: <In, Out>(src: Signal<In>, config?: InjectUtilTransformConfig<In, Out>) => Signal<Out>;
-/** Inject the current router event */
-declare const injectRouterEvent: () => Signal<Event$1>;
-/**
- * Signal that indicates whether the router has been initialized.
- * The router is considered initialized once the first NavigationEnd event with an id different than -1 has been emitted.
- */
-declare const injectIsRouterInitialized: () => Signal<boolean>;
-/**
- * Inject the current url.
- * The url includes query params as well as the fragment. Use `injectRoute` instead if you are not intrusted in those.
- * @example "/my-page?query=1&param=true#fragment"
- */
-declare const injectUrl: () => Signal<string>;
-/**
- * Inject the current route
- * @example "/my-page"
- */
-declare const injectRoute: () => Signal<string>;
-/**
- * Inject the complete router state. This includes the current route data, path params, query params, title and fragment.
- */
-declare const injectRouterState: () => Signal<RouterState>;
-/** Inject a signal containing the current route fragment (the part after the # inside the url if present) */
-declare const injectFragment: <T = string | null>(config?: InjectUtilConfig & InjectUtilTransformConfig<string | null, T>) => Signal<T>;
-/** Inject all currently available query parameters as a signal */
-declare const injectQueryParams: () => Signal<Params>;
-/** Inject all currently available route data as a signal */
-declare const injectRouteData: () => Signal<Data>;
-/** Inject the current route title as a signal */
-declare const injectRouteTitle: <T = string | null>(config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
-/** Inject all currently available path parameters as a signal */
-declare const injectPathParams: () => Signal<Params>;
-type InjectQueryParamConfig<T> = InjectUtilTransformConfig<string | null, T> & {
+declare const isElementVisible: (options: IsElementVisibleOptions) => CurrentElementVisibility | null;
+declare const getElementScrollCoordinates: (options: ScrollToElementOptions) => ScrollToOptions;
+type ScrollToElementOptions = {
     /**
-     * If true, the initial value will be read from the browser's url.
-     * Note that this will not work with arrays or complex objects.
+     * The element to scroll to.
      */
-    requireSync?: boolean;
+    element?: HTMLElement | null;
+    /**
+     * The scroll container to scroll to the element in.
+     * Must be provided - cannot scroll the viewport programmatically with this function.
+     */
+    container?: HTMLElement | null;
+    /**
+     * The direction to scroll in.
+     * @default 'both'
+     */
+    direction?: 'inline' | 'block' | 'both';
+    /**
+     * The origin of the element to scroll to.
+     * @default 'nearest'
+     */
+    origin?: 'start' | 'end' | 'center' | 'nearest';
+    /**
+     * The scroll behavior.
+     * @default 'smooth'
+     */
+    behavior?: ScrollBehavior;
+    /**
+     * The scroll inline-margin
+     * @default 0
+     */
+    scrollInlineMargin?: number;
+    /**
+     * The scroll block-margin
+     * @default 0
+     */
+    scrollBlockMargin?: number;
 };
-/** Inject a specific query parameter as a signal */
-declare const injectQueryParam: <T = string | null>(key: string, config?: InjectQueryParamConfig<T>) => Signal<T>;
-/** Inject a specific route data item as a signal */
-declare const injectRouteDataItem: <T = unknown>(key: string, config?: InjectUtilTransformConfig<unknown, T>) => Signal<T>;
-/** Inject a specific path parameter as a signal */
-declare const injectPathParam: <T = string | null>(key: string, config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+declare const scrollToElement: (options: ScrollToElementOptions) => void;
+
+type ScrollSnapOrigin = 'auto' | 'start' | 'center' | 'end';
+type ScrollSnapTarget = {
+    /** The element to snap to. */
+    element: HTMLElement;
+    /** The resolved alignment to use when scrolling to the element. */
+    origin: 'start' | 'center' | 'end';
+} | null;
+declare const getScrollSnapTarget: (items: HTMLElement[], container: HTMLElement, direction: "horizontal" | "vertical", origin: ScrollSnapOrigin, margin?: number) => ScrollSnapTarget;
+type ScrollContainerTarget = {
+    element: HTMLElement;
+    origin: 'start' | 'end';
+} | null;
+declare const getScrollContainerTarget: (entries: IntersectionObserverEntry[], direction: "start" | "end") => ScrollContainerTarget;
+type ScrollItemTarget = {
+    element: HTMLElement;
+    index: number;
+    origin: 'start' | 'end' | 'center';
+} | null;
+declare const getScrollItemTarget: (entries: IntersectionObserverEntry[], container: HTMLElement, direction: "start" | "end", scrollOrigin: "auto" | "center" | "start" | "end", axisDirection: "horizontal" | "vertical") => ScrollItemTarget;
+
 /**
- * Inject query params that changed during navigation. Unchanged query params will be ignored.
- * Removed query params will be represented by the symbol `ET_PROPERTY_REMOVED`.
+ * Something drawn on top of the site's favicon.
+ *
+ * - `dot` - a filled badge punched into the bottom-right corner, the "something happened here" marker.
+ * - `progress` - a ring around the icon, `value` in percent (`0`–`100`). The browser exposes no
+ *   taskbar/tab progress API, so a favicon ring (or a percentage in the title) is as close as the web
+ *   gets to one.
  */
-declare const injectQueryParamChanges: () => Signal<Record<string, unknown>>;
+type FaviconOverlay = {
+    kind: 'dot';
+    color?: string;
+} | {
+    kind: 'progress';
+    value: number;
+    color?: string;
+    trackColor?: string;
+};
 /**
- * Inject path params that changed during navigation. Unchanged path params will be ignored.
- * Removed path params will be represented by the symbol `ET_PROPERTY_REMOVED`.
+ * Owns the `<link rel="icon">` href so overlays can be drawn onto the site's favicon and taken back
+ * off again. The original href is captured on first use and restored once the last overlay is gone.
+ *
+ * Registrations are keyed, and a `progress` overlay wins over a `dot` - a ring that also carries a
+ * badge reads as neither.
  */
-declare const injectPathParamChanges: () => Signal<Record<string, unknown>>;
+declare const provideFaviconStore: () => _angular_core.Provider[];
+declare const injectFaviconStore: _ethlete_core.InjectFn<{
+    activeOverlay: _angular_core.Signal<FaviconOverlay | null>;
+    addOverlay: (id: symbol, overlay: FaviconOverlay) => void;
+    removeOverlay: (id: symbol) => void;
+}>;
+/**
+ * Draw an overlay on the site's favicon while the binding has a value - an unsaved-changes dot, an
+ * upload's progress ring. The favicon is restored when the binding goes empty or the injector is
+ * destroyed. No-op during SSR.
+ *
+ * ```ts
+ * applyFaviconOverlay(computed(() => (this.saving() ? { kind: 'progress', value: this.percent() } : null)));
+ * ```
+ */
+declare const applyFaviconOverlay: (binding: MaybeSignal<FaviconOverlay | null | undefined>) => void;
 
 type HeadBinding<T> = {
     id: symbol;
@@ -1626,7 +2450,7 @@ declare const applyHeadBinding: <T>(binding: MaybeSignal<T | null | undefined>,
 declare const createPropertyBinding: <TConfig>(configBuilder: (value: string) => TConfig, applyConfigFn: (config: MaybeSignal<TConfig | null | undefined>) => void) => (binding: MaybeSignal<string | null | undefined>) => void;
 declare const createArrayPropertyBinding: <TConfig>(configBuilder: (value: string, index: number) => TConfig, applyConfigFn: (config: MaybeSignal<TConfig | null | undefined>) => void) => (binding: MaybeSignal<string[] | null | undefined>) => void;
 declare const toStringBinding: (binding: MaybeSignal<string | number | null | undefined>) => MaybeSignal<string | null | undefined>;
-declare const createBulkPropertyBinding: <TConfig extends Record<string, unknown>>(propertyPrefix: string, applyConfigFn: (property: string, binding: MaybeSignal<string | null | undefined>) => void) => (config: TConfig) => void;
+declare const createBulkPropertyBinding: <TConfig extends Record<string, unknown>>(_propertyPrefix: string, applyConfigFn: (property: string, binding: MaybeSignal<string | null | undefined>) => void) => (config: TConfig) => void;
 
 type Context = {
     '@context': 'https://schema.org';
@@ -1792,33 +2616,13 @@ type LinkStoreConfig = {
 };
 declare const DEFAULT_MULTI_INSTANCE_RELS: Set<string>;
 declare const provideLinkStoreConfig: (valueOverride?: Partial<LinkStoreConfig> | undefined) => _angular_core.Provider[];
-declare const injectLinkStoreConfig: {
-    (): LinkStoreConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): LinkStoreConfig;
-    (options: _angular_core.InjectOptions): LinkStoreConfig | null;
-};
+declare const injectLinkStoreConfig: _ethlete_core.InjectFn<LinkStoreConfig>;
 declare const provideLinkStore: () => _angular_core.Provider[];
-declare const injectLinkStore: {
-    (): {
-        addLink: (id: symbol, linkConfig: LinkConfig) => void;
-        removeLink: (id: symbol, key?: string) => void;
-        getLinkKey: (linkConfig: LinkConfig) => string;
-    };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        addLink: (id: symbol, linkConfig: LinkConfig) => void;
-        removeLink: (id: symbol, key?: string) => void;
-        getLinkKey: (linkConfig: LinkConfig) => string;
-    };
-    (options: _angular_core.InjectOptions): {
-        addLink: (id: symbol, linkConfig: LinkConfig) => void;
-        removeLink: (id: symbol, key?: string) => void;
-        getLinkKey: (linkConfig: LinkConfig) => string;
-    } | null;
-};
+declare const injectLinkStore: _ethlete_core.InjectFn<{
+    addLink: (id: symbol, linkConfig: LinkConfig) => void;
+    removeLink: (id: symbol, key?: string) => void;
+    getLinkKey: (linkConfig: LinkConfig) => string;
+}>;
 declare const applyLinkBinding: (binding: MaybeSignal<LinkConfig | null | undefined>) => void;
 declare const applyCanonicalBinding: (binding: MaybeSignal<string | null | undefined>) => void;
 declare const applyAlternateBinding: (hreflang: string, binding: MaybeSignal<string | null | undefined>) => void;
@@ -1877,33 +2681,13 @@ type MetaConfig = {
 };
 declare const DEFAULT_MULTI_INSTANCE_TAGS: Set<string>;
 declare const provideMetaConfig: (valueOverride?: Partial<MetaConfig> | undefined) => _angular_core.Provider[];
-declare const injectMetaConfig: {
-    (): MetaConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): MetaConfig;
-    (options: _angular_core.InjectOptions): MetaConfig | null;
-};
+declare const injectMetaConfig: _ethlete_core.InjectFn<MetaConfig>;
 declare const provideMetaStore: () => _angular_core.Provider[];
-declare const injectMetaStore: {
-    (): {
-        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
-        removeTag: (id: symbol, selector?: string) => void;
-        getSelector: (config: MetaTagConfig) => string;
-    };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
-        removeTag: (id: symbol, selector?: string) => void;
-        getSelector: (config: MetaTagConfig) => string;
-    };
-    (options: _angular_core.InjectOptions): {
-        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
-        removeTag: (id: symbol, selector?: string) => void;
-        getSelector: (config: MetaTagConfig) => string;
-    } | null;
-};
+declare const injectMetaStore: _ethlete_core.InjectFn<{
+    addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
+    removeTag: (id: symbol, selector?: string) => void;
+    getSelector: (config: MetaTagConfig) => string;
+}>;
 declare const applyMetaBinding: (binding: MaybeSignal<MetaTagConfig | null | undefined>) => void;
 declare const applyDescriptionBinding: (binding: MaybeSignal<string | null | undefined>) => void;
 declare const applyKeywordsBinding: (binding: MaybeSignal<string[] | null | undefined>) => void;
@@ -1985,78 +2769,6 @@ type SocialMediaConfig = {
 };
 declare const applySocialMediaBindings: (config: SocialMediaConfig) => void;
 
-type MaybeObservable<T> = T | Observable<T>;
-type SeoConfig = {
-    title?: MaybeObservable<string>;
-    description?: MaybeObservable<string>;
-    keywords?: MaybeObservable<string[]>;
-    icon?: MaybeObservable<string>;
-    themeColor?: MaybeObservable<string>;
-    colorScheme?: MaybeObservable<'light' | 'dark'>;
-    robots?: MaybeObservable<string>;
-    canonical?: MaybeObservable<string>;
-    alternate?: MaybeObservable<AlternateLink>[];
-    og?: MaybeObservable<OpenGraph>;
-    twitter?: MaybeObservable<TwitterCard>;
-    facebook?: MaybeObservable<FacebookCard>;
-    [key: string]: MaybeObservable<unknown>;
-};
-type AlternateLink = {
-    href: string;
-    hreflang: string;
-};
-type OpenGraph = {
-    title?: MaybeObservable<string>;
-    description?: MaybeObservable<string>;
-    type?: MaybeObservable<string>;
-    url?: MaybeObservable<string>;
-    image?: MaybeObservable<string>;
-    siteName?: MaybeObservable<string>;
-    locale?: MaybeObservable<string>;
-    localeAlternate?: MaybeObservable<string[]>;
-};
-type TwitterCard = {
-    card?: MaybeObservable<string>;
-    site?: MaybeObservable<string>;
-    creator?: MaybeObservable<string>;
-    title?: MaybeObservable<string>;
-    description?: MaybeObservable<string>;
-    image?: MaybeObservable<string>;
-    imageAlt?: MaybeObservable<string>;
-};
-type FacebookCard = {
-    title?: MaybeObservable<string>;
-    description?: MaybeObservable<string>;
-    image?: MaybeObservable<string>;
-    imageAlt?: MaybeObservable<string>;
-    type?: MaybeObservable<string>;
-    url?: MaybeObservable<string>;
-    siteName?: MaybeObservable<string>;
-    locale?: MaybeObservable<string>;
-    localeAlternate?: MaybeObservable<string[]>;
-};
-
-declare const SEO_DIRECTIVE_TOKEN: InjectionToken<SeoDirective>;
-/** @deprecated use binding utils instead */
-declare class SeoDirective implements OnInit, OnDestroy {
-    private readonly _metaService;
-    private readonly _titleService;
-    private readonly _onDeactivate$;
-    private _isDeactivated;
-    readonly parent: SeoDirective | null;
-    get config(): SeoConfig;
-    private _config;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    updateConfig(config: SeoConfig): void;
-    _activate(): void;
-    _deactivate(): void;
-    private _update;
-    private _cleanUp;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeoDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SeoDirective, never, never, {}, {}, never, never, true, never>;
-}
-
 type StructuredDataConfig = {
     /**
      * Where to place the JSON-LD script tag.
@@ -2071,30 +2783,12 @@ type StructuredDataConfig = {
     placement: 'head' | 'body';
 };
 declare const provideStructuredDataConfig: (valueOverride?: Partial<StructuredDataConfig> | undefined) => _angular_core.Provider[];
-declare const injectStructuredDataConfig: {
-    (): StructuredDataConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): StructuredDataConfig;
-    (options: _angular_core.InjectOptions): StructuredDataConfig | null;
-};
+declare const injectStructuredDataConfig: _ethlete_core.InjectFn<StructuredDataConfig>;
 declare const provideStructuredDataStore: () => _angular_core.Provider[];
-declare const injectStructuredDataStore: {
-    (): {
-        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
-        removeStructuredData: (id: symbol) => void;
-    };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
-        removeStructuredData: (id: symbol) => void;
-    };
-    (options: _angular_core.InjectOptions): {
-        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
-        removeStructuredData: (id: symbol) => void;
-    } | null;
-};
+declare const injectStructuredDataStore: _ethlete_core.InjectFn<{
+    addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
+    removeStructuredData: (id: symbol) => void;
+}>;
 declare const applyStructuredDataBinding: (binding: MaybeSignal<WithContext<Thing> | Graph | null | undefined>) => void;
 
 declare class StructuredDataComponent {
@@ -2134,34 +2828,670 @@ type TitleConfig = {
     prefixPart?: TitlePart;
 };
 declare const provideTitleConfig: (valueOverride?: Partial<TitleConfig> | undefined) => _angular_core.Provider[];
-declare const injectTitleConfig: {
-    (): TitleConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): TitleConfig;
-    (options: _angular_core.InjectOptions): TitleConfig | null;
-};
+declare const injectTitleConfig: _ethlete_core.InjectFn<TitleConfig>;
 declare const provideTitleStore: () => _angular_core.Provider[];
-declare const injectTitleStore: {
-    (): {
-        title: _angular_core.Signal<string>;
-        addPart: (id: symbol, part: TitlePart) => void;
-        removePart: (id: symbol) => void;
+declare const injectTitleStore: _ethlete_core.InjectFn<{
+    title: _angular_core.Signal<string>;
+    addPart: (id: symbol, part: TitlePart) => void;
+    removePart: (id: symbol) => void;
+    addMarker: (id: symbol, marker: string) => void;
+    removeMarker: (id: symbol) => void;
+}>;
+declare const applyHeadTitleBinding: (binding: MaybeSignal<string | number | null | undefined>, options?: Omit<TitlePart, "text">) => void;
+/**
+ * Prefix the tab title with a short marker (`● Page | App`) while the binding has a value - the
+ * unsaved-changes dot, a pending-count badge, and the like. The marker is removed when the binding
+ * goes empty and on destroy. Unlike a title part, it is not joined by the divider.
+ */
+declare const applyHeadTitleMarker: (binding: MaybeSignal<string | null | undefined>) => void;
+
+/**
+ * Cascades hover/active-driven color DOWN to descendants explicitly marked with
+ * `ColorInteractiveDirective` - this element does not color itself. Use it when a wrapper should
+ * expand a nested control's hit/visual area (e.g. clicking a checkbox's label should light up the
+ * checkbox itself), never to give a wrapper its own interactive coloring - that's
+ * `ColorInteractiveDirective`.
+ *
+ * Does nothing unless at least one descendant carries `ColorInteractiveDirective` - check for
+ * that before adding this. It was mistakenly added to a component with no such descendant once
+ * already, where it did nothing but was confusing to read.
+ */
+declare class ColorInteractiveContainerDirective {
+    private styleManager;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInteractiveContainerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorInteractiveContainerDirective, "[etColorInteractiveContainer]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a descendant as NOT counting toward an ancestor's `ColorInteractiveDirective`
+ * `:hover`/`:active` reaction (via the `:has()` guard in color-interactive-styles.component.css).
+ * Use it for content that's incidentally inside an interactive ancestor but isn't part of what
+ * makes that ancestor interactive - e.g. a hint/error block sitting inside a form field's frame.
+ *
+ * This only suppresses the ancestor's OWN reaction to hovering/pressing the excluded element - it
+ * has no effect on custom-property inheritance into descendants past the excluded element. If
+ * what you actually need is "stop my own cosmetic styling from reacting to a parent's unrelated
+ * interaction," this is the wrong tool; that's the class of bug `ColorInteractiveHasFocusDirective`
+ * used to have (see its own comment).
+ */
+declare class ColorInteractiveExcludeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInteractiveExcludeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorInteractiveExcludeDirective, "[etColorInteractiveExclude]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tints `--et-theme-color-primary-*` etc. only when a descendant genuinely has `:focus-visible`
+ * (`:has(:focus-visible)`) - never on mouse `:hover`/`:active`. Use this for a wrapper (like a
+ * form field's frame) that should show the theme color while its control is focused, but must
+ * NOT react to incidental mouse interaction with unrelated nested widgets (a toolbar button, a
+ * rendered link) that happen to live inside the same wrapper.
+ *
+ * The color it resolves to is the theme's BASE accent, not the `-focus` variant: the `-focus`
+ * shade is the treatment for an element that is itself focused, whereas a container only mirroring
+ * a child's focus should read as the plain accent color.
+ *
+ * Deliberately does NOT also carry `ColorInteractiveDirective`'s `et-color-interactive` class:
+ * that class's plain `:hover`/`:active` rules locally override the same (inheriting)
+ * `--et-theme-color-primary-rgb`, so anything bubbling up from ANYWHERE in the subtree would
+ * leak the transient hover/press color into every descendant reading it for unrelated cosmetics -
+ * exactly the bug this directive's only consumer (form-field) shipped once, before the two
+ * behaviors were split apart. If you need the plain hover/active reaction too, add
+ * `ColorInteractiveDirective` explicitly and make sure you actually want both.
+ */
+declare class ColorInteractiveHasFocusDirective {
+    private styleManager;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInteractiveHasFocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorInteractiveHasFocusDirective, "[etColorInteractiveHasFocus]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Makes an element react to ITS OWN `:hover`/`:active`/`:focus-visible`/`[disabled]` by tinting
+ * `--et-theme-color-primary-*`/`-on-primary-*`/`-ink-*` with the current color theme. Use this on
+ * a single, self-contained interactive element - a button, a checkbox, a segmented button.
+ *
+ * Do NOT apply this to a wrapper that also contains OTHER, independently-interactive elements
+ * (e.g. a toolbar with its own buttons, or a form-field's control slot). These are ordinary
+ * inheriting CSS custom properties, so a descendant reading them for its own cosmetics (a caret
+ * color, a link color) gets swept along whenever ANYTHING inside the wrapper is hovered or
+ * clicked - not just when the wrapper itself is the thing being interacted with. That exact bug
+ * shipped once already; see ColorInteractiveContainerDirective/ColorInteractiveHasFocusDirective
+ * for the shapes that avoid it.
+ */
+declare class ColorInteractiveDirective {
+    private styleManager;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInteractiveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorInteractiveDirective, "[etColorInteractive]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SURFACE_TYPE: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+type SurfaceType = (typeof SURFACE_TYPE)[keyof typeof SURFACE_TYPE];
+type SurfaceThemeColor = `${number} ${number} ${number}`;
+type SurfaceInteractionColor = {
+    default: SurfaceThemeColor;
+    hover: SurfaceThemeColor;
+    focus: SurfaceThemeColor;
+    active: SurfaceThemeColor;
+    disabled: SurfaceThemeColor;
+};
+type SurfaceTheme = {
+    name: string;
+    type: SurfaceType;
+    elevation: number;
+    isDefault?: boolean;
+    interactionColor?: SurfaceInteractionColor;
+    background: SurfaceThemeColor;
+    color: SurfaceThemeColor;
+    colorMuted: SurfaceThemeColor;
+    colorSubtle: SurfaceThemeColor;
+    border: SurfaceThemeColor;
+};
+/**
+ * Augmentable registry for the literal set of surface theme names an app defines. Left
+ * empty by default, which keeps surface-theme-name-accepting APIs (like `etProvideSurface`)
+ * typed as plain `string`.
+ *
+ * Apps that want those APIs checked and autocompleted against their own surface theme
+ * names should augment this interface once, near where their surface themes are defined:
+ *
+ * ```ts
+ * declare module '@ethlete/core' {
+ *   interface EthleteSurfaceThemeNameRegistry {
+ *     name: 'card' | 'sheet' | 'popover';
+ *   }
+ * }
+ * ```
+ */
+interface EthleteSurfaceThemeNameRegistry {
+}
+type RegisteredSurfaceThemeName = EthleteSurfaceThemeNameRegistry extends {
+    name: infer N extends string;
+} ? N : string;
+declare const createCssSurfaceName: (name: string) => string;
+declare const resolveSurfaceByElevation: (themes: SurfaceTheme[], type: SurfaceType, elevation: number) => SurfaceTheme | null;
+declare const ɵProvideSurfaceThemes: (valueOverride?: (SurfaceTheme | undefined)[] | undefined) => _angular_core.Provider[];
+declare const injectSurfaceThemes: _ethlete_core.InjectFn<SurfaceTheme[]>;
+declare const ɵProvideSurfaceThemesPrefix: (valueOverride?: string | undefined) => _angular_core.Provider[];
+declare const injectSurfaceThemesPrefix: _ethlete_core.InjectFn<string>;
+declare const provideSurfaceThemesWithTailwind4: (themes: SurfaceTheme[], prefix?: string) => _angular_core.Provider[][];
+
+declare const SURFACE_PROVIDER: InjectionToken<ProvideSurfaceDirective>;
+declare class ProvideSurfaceDirective {
+    private themes;
+    private prefix;
+    private injector;
+    private currentProviderSync;
+    private forcedSurface;
+    surface: InputSignal<RegisteredSurfaceThemeName | null | undefined>;
+    effectiveSurface: _angular_core.Signal<string | null | undefined>;
+    resolvedTheme: _angular_core.Signal<SurfaceTheme | null>;
+    elevation: _angular_core.Signal<number>;
+    surfaceType: _angular_core.Signal<_ethlete_core.SurfaceType | null>;
+    surfaceName: _angular_core.Signal<string | undefined>;
+    protected surfaceClass: _angular_core.Signal<string>;
+    syncWithProvider(provider: ProvideSurfaceDirective): void;
+    stopSyncWithProvider(): void;
+    /** @internal */
+    forceSurface(surface: RegisteredSurfaceThemeName | null): void;
+    /** @internal */
+    clearForcedSurface(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProvideSurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ProvideSurfaceDirective, "[etProvideSurface]", never, { "surface": { "alias": "etProvideSurface"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AutoSurfaceDirective {
+    private ownSurfaceProvider;
+    private contextSurfaceProvider;
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private elementRef;
+    /**
+     * Explicit surface provider to resolve the surface relative to. Falls back to the
+     * surface provider from the surrounding (trigger) context when not set.
+     */
+    surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
+    private isOverlaySurface;
+    private domSettleTick;
+    resolvedSurface: _angular_core.Signal<string | null>;
+    /**
+     * Mark this auto-surface as its overlay's *own painted surface*. An overlay *panel*
+     * (menu, select/date/cascader panel, tooltip, toggletip, rich-text-editor popups) is
+     * the overlay's surface, so it must paint the overlay's registered elevation exactly -
+     * not stack a level above a parent surface. The elevation is read from the surface-context
+     * tracker (the pane it renders into), which is authoritative across the portal boundary;
+     * the panel's own declaration injector points back at the trigger location and cannot be
+     * trusted.
+     */
+    matchOverlaySurface(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoSurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoSurfaceDirective, "[etAutoSurface]", never, { "surfaceProvider": { "alias": "surfaceProvider"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type ThemeRGBColor = `${number} ${number} ${number}`;
+type ThemeHSLColor = `${number} ${number}% ${number}%`;
+type ThemeColor = ThemeRGBColor | ThemeHSLColor;
+type ThemeColorMap = {
+    default: ThemeColor;
+    hover: ThemeColor;
+    focus?: ThemeColor;
+    active: ThemeColor;
+    disabled: ThemeColor;
+};
+type OnThemeColorMap = {
+    default: ThemeColor;
+    hover?: ThemeColor;
+    focus?: ThemeColor;
+    active?: ThemeColor;
+    disabled?: ThemeColor;
+};
+type ThemeInkColorMap = {
+    default: ThemeColor;
+    hover?: ThemeColor;
+    focus?: ThemeColor;
+    active?: ThemeColor;
+    disabled?: ThemeColor;
+};
+type ThemeSwatch = {
+    color: ThemeColorMap;
+    onColor: OnThemeColorMap;
+    inkColor?: ThemeInkColorMap;
+};
+type ColorThemeType = 'success' | 'warning' | 'error';
+type ColorTheme = {
+    name: string;
+    type?: ColorThemeType;
+    isDefault?: boolean;
+    primary: ThemeSwatch;
+    secondary?: ThemeSwatch;
+    tertiary?: ThemeSwatch;
+};
+/**
+ * Augmentable registry for the literal set of color theme names an app defines. Left
+ * empty by default, which keeps theme-name-accepting APIs (like `etProvideColor`) typed
+ * as plain `string`.
+ *
+ * Apps that want those APIs checked and autocompleted against their own theme names
+ * should augment this interface once, near where their themes are defined:
+ *
+ * ```ts
+ * declare module '@ethlete/core' {
+ *   interface EthleteColorThemeNameRegistry {
+ *     name: 'pitch-green' | 'red' | 'light-grey';
+ *   }
+ * }
+ * ```
+ */
+interface EthleteColorThemeNameRegistry {
+}
+type RegisteredColorThemeName = EthleteColorThemeNameRegistry extends {
+    name: infer N extends string;
+} ? N : string;
+declare const createCssColorThemeName: (name: string) => string;
+declare const ɵProvideColorThemes: (valueOverride?: (ColorTheme | undefined)[] | undefined) => _angular_core.Provider[];
+declare const injectColorThemes: _ethlete_core.InjectFn<ColorTheme[]>;
+declare const ɵProvideColorThemesPrefix: (valueOverride?: string | undefined) => _angular_core.Provider[];
+declare const injectColorThemesPrefix: _ethlete_core.InjectFn<string>;
+declare const provideColorThemesWithTailwind4: (themes: ColorTheme[], prefix?: string) => _angular_core.Provider[][];
+declare const injectErrorTheme: () => ColorTheme;
+declare const injectWarningTheme: () => ColorTheme;
+declare const injectSuccessTheme: () => ColorTheme;
+declare const injectDefaultColorTheme: () => ColorTheme;
+
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createSwatchCss: (swatch: string, isAlt: boolean, data: ThemeSwatch) => string;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createRootThemeCss: (themes: ColorTheme[]) => void;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createThemeStyle: (theme: ColorTheme, isAlt: boolean) => void;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createTailwindCssVar: (name: string | undefined) => string | null;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare function createTailwindRgbVar(val: string): string;
+declare function createTailwindRgbVar(val: string | undefined): string | null;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createTailwindColorThemes: (themes: ColorTheme[], prefix?: string) => Record<string, {
+    DEFAULT: string;
+    hover: string;
+    focus: string;
+    active: string;
+    disabled: string;
+}>;
+/**
+ * @deprecated Use provideColorThemesWithTailwind4 instead after migrating to Tailwind CSS v4. Intent to remove in v6.
+ */
+declare const provideColorThemes: (themes: ColorTheme[]) => _angular_core.Provider[][];
+
+declare const COLOR_PROVIDER: InjectionToken<ProvideColorDirective>;
+/**
+ * The color provider attached to a bootstrapped root component (e.g. `ProvideColorDirective` in
+ * the app component's `hostDirectives`), if any. Detached DOM such as overlay panes can't reach
+ * it through element DI, so overlay containers fall back to this when resolving the provider to
+ * `syncWithProvider()` - resolve at sync time, not at injection time, since root components only
+ * register with `ApplicationRef` once bootstrap completes.
+ *
+ * @internal
+ */
+declare const resolveAppRootColorProvider: (appRef: ApplicationRef) => ProvideColorDirective | null;
+declare class ProvideColorDirective {
+    private themes;
+    private prefix;
+    private injector;
+    private parentProvider;
+    private currentProviderSync;
+    private forcedColor;
+    color: InputSignal<RegisteredColorThemeName | ColorTheme | null | undefined>;
+    effectiveColor: _angular_core.Signal<string | ColorTheme | null | undefined>;
+    /**
+     * The color that actually applies at this provider's location: its own effective color, or -
+     * when this provider is passive (no input, nothing forced) - the nearest ancestor provider's.
+     * Mirrors the CSS cascade, which falls through a provider's `-color--inherited` scope class;
+     * consumers that re-apply context across detached DOM (overlay panes) must use this instead
+     * of `effectiveColor` or a passive in-between provider (e.g. a form field's) erases the theme.
+     */
+    resolvedColor: _angular_core.Signal<string | ColorTheme | null | undefined>;
+    colorName: _angular_core.Signal<string | undefined>;
+    protected themeClass: _angular_core.Signal<string>;
+    syncWithProvider(provider: ProvideColorDirective): void;
+    stopSyncWithProvider(): void;
+    /** @internal */
+    forceColor(color: RegisteredColorThemeName | ColorTheme | null): void;
+    /** @internal */
+    clearForcedColor(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProvideColorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ProvideColorDirective, "[etProvideColor]", never, { "color": { "alias": "etProvideColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SurfaceContextEntry = {
+    id: string;
+    type: SurfaceType;
+    elevation: number;
+    element: HTMLElement;
+};
+type SurfaceContextSurface = {
+    type: SurfaceType;
+    elevation: number;
+};
+type SurfaceContextTracker = {
+    topType: Signal<SurfaceType | null>;
+    topElevation: Signal<number>;
+    register: (type: SurfaceType, elevation: number, element: HTMLElement) => () => void;
+    /**
+     * The surface of the innermost registered overlay whose pane actually contains `host` in the DOM,
+     * or `null` when `host` sits outside every open overlay. Reactive: reads the entries signal, so
+     * calling it inside a computed re-runs when overlays open/close.
+     */
+    surfaceForElement: (host: HTMLElement) => SurfaceContextSurface | null;
+};
+declare const provideSurfaceContextTracker: () => _angular_core.Provider[];
+declare const injectSurfaceContextTracker: _ethlete_core.InjectFn<SurfaceContextTracker>;
+
+/**
+ * Same shape as `ColorInteractiveDirective` - reacts to its own `:hover`/`:focus-visible`/
+ * `:active`/`[disabled]` - but drives `--et-surface-interaction-*`, a neutral/muted tint, instead
+ * of the ambient color theme. Use it for chrome-level interaction feedback that shouldn't borrow
+ * the page's brand color (a tab trigger's hover state, a toggle button that should look neutral
+ * until it's actually active - see `ButtonDirective`'s `mutedUntilPressed`).
+ *
+ * Has no container/exclude/has-focus variants: it has no descendant-cascading CSS at all, so
+ * applying it to a wrapper with independently-interactive children is safe by construction -
+ * unlike `ColorInteractiveDirective`, there's no bubbling-leak failure mode to worry about here.
+ */
+declare class SurfaceInteractiveDirective {
+    private styleManager;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SurfaceInteractiveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SurfaceInteractiveDirective, "[etSurfaceInteractive]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Why a guard was abandoned. `'logout'` is issued by `@ethlete/query`'s auth provider; anything else
+ * is app-defined.
+ */
+type UnsavedChangesAbandonReason = 'logout' | (string & {});
+/** The second argument every {@link UnsavedChangesConfirmFn} receives. */
+type UnsavedChangesConfirmContext = {
+    /**
+     * Aborts when the session this confirm belongs to ends underneath it - a logout, or an explicit
+     * `abandonAll()`. **Close your confirm dialog when it fires**, otherwise it is left on screen over
+     * a page the user has already been redirected away from. The guard itself stops waiting either way.
+     *
+     * ```ts
+     * confirm: (value, { signal }) => {
+     *   const ref = this.overlays.open(ConfirmDiscardComponent);
+     *   signal.addEventListener('abort', () => ref.close(false));
+     *   return ref.afterClosed();
+     * };
+     * ```
+     */
+    signal: AbortSignal;
+};
+/** @internal A live tracker, as seen by the coordinator. */
+type UnsavedChangesRegistration = {
+    abandon: (reason: UnsavedChangesAbandonReason) => void;
+};
+/**
+ * App-wide coordination for the unsaved-changes family. Two jobs:
+ *
+ * - **One confirm at a time.** A page form, an overlay form and a route guard can all want a decision
+ *   at once; stacking three "discard your changes?" dialogs is never the right answer. A check that
+ *   starts while another is pending adopts the pending decision instead of asking again.
+ * - **Abandoning guards when the session ends.** `abandonAll()` resolves the pending confirm, tells
+ *   its dialog to close (via {@link UnsavedChangesConfirmContext.signal}), and switches every live
+ *   guard off: further checks pass, and the tab locks release. Called automatically by
+ *   `@ethlete/query`'s auth provider on logout - the edits cannot be saved anymore, so guarding them
+ *   only strands dialogs over the login page and blocks the tab.
+ *
+ * Root-provided; every tracker registers itself. Inject it to abandon guards from app code (a session
+ * timeout of your own, a hard reset) or to read whether a confirm is currently on screen.
+ */
+declare const provideUnsavedChangesCoordinator: () => _angular_core.Provider[];
+declare const injectUnsavedChangesCoordinator: _ethlete_core.InjectFn<{
+    /** Whether a confirm is currently on screen. */
+    isCheckPending: _angular_core.Signal<boolean>;
+    abandonAll: (reason?: UnsavedChangesAbandonReason) => void;
+    runCheck: (runner: (context: UnsavedChangesConfirmContext) => Promise<boolean>) => Promise<boolean>;
+    register: (registration: UnsavedChangesRegistration) => () => boolean;
+}>;
+
+/**
+ * The value source an unsaved-changes tracker watches. In order of preference:
+ *
+ * - **`FieldTree<T>`** (signal forms - primary): read `field().value()`, restore `field().value.set(v)`.
+ * - **`Signal<FieldTree<T> | null>`**: a late/async-created signal form - resolves once the field exists.
+ * - **`AbstractControl`** (reactive forms - migration path): bridged via `controlValueSignal` + `setValue`.
+ * - **`WritableSignal<T>`** (escape hatch for non-form state): read/write directly.
+ */
+type UnsavedChangesSource<T> = FieldTree<T> | Signal<FieldTree<T> | null> | AbstractControl | WritableSignal<T>;
+/** A value source reduced to a read signal plus a writer, regardless of its original kind. */
+type NormalizedUnsavedChangesSource<T> = {
+    /** The current value. `null` while a late/async source has not produced a value yet. */
+    value: Signal<T | null>;
+    /** Writes a value back to the source (used by `restoreDefaultValue`). No-op if the source isn't ready. */
+    setValue: (value: T) => void;
+};
+/** Reduces any {@link UnsavedChangesSource} to a uniform read-signal + writer pair. */
+declare const normalizeUnsavedChangesSource: <T>(source: UnsavedChangesSource<T>) => NormalizedUnsavedChangesSource<T>;
+
+/** The default tab title marker - a filled dot, prefixed while there are unsaved changes. */
+declare const UNSAVED_CHANGES_TITLE_MARKER = "\u25CF";
+/**
+ * How an unsaved-changes tracker surfaces itself on the browser tab.
+ *
+ * Only the `beforeunload` lock is on by default - the title marker and the app badge write to
+ * app-global surfaces, so they are opt-in.
+ */
+type UnsavedChangesTabConfig = {
+    /**
+     * Make the browser ask for confirmation before the tab is closed, reloaded, or navigated away from
+     * while there are unsaved changes (`beforeunload`).
+     *
+     * The prompt is the browser's own - its wording cannot be customized, and browsers only show it
+     * after the user has interacted with the page at least once (sticky activation). The listener is
+     * attached **only while changes exist**, so a clean page stays eligible for the back/forward cache.
+     * @default true
+     */
+    lock?: boolean;
+    /**
+     * Prefix the tab title with a marker while there are unsaved changes. `true` uses
+     * {@link UNSAVED_CHANGES_TITLE_MARKER}, a string is used as-is.
+     *
+     * Goes through the core title store (`injectTitleStore`), so the app's title must be owned by it
+     * (`applyHeadTitleBinding` / the `etSeo` directive) - an app that writes `document.title` by some
+     * other means would fight the store over it.
+     * @default false
+     */
+    titleMarker?: boolean | string;
+    /**
+     * Blink the tab while there are unsaved changes: the title marker (and the favicon dot, if enabled)
+     * is toggled on and off - the closest thing the web has to an "attention needed" tab flash, since no
+     * browser exposes one. Implies `titleMarker` when that isn't set.
+     *
+     * By default it only blinks while the tab is **in the background** (`whenHidden`), which is the case
+     * worth flagging - a title blinking in the tab the user is already reading is just noise. `interval`
+     * is in ms and defaults to 1000; going faster is pointless because browsers clamp timers in hidden
+     * tabs to roughly one second.
+     * @default false
+     */
+    flash?: boolean | {
+        interval?: number;
+        whenHidden?: boolean;
     };
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): {
-        title: _angular_core.Signal<string>;
-        addPart: (id: symbol, part: TitlePart) => void;
-        removePart: (id: symbol) => void;
+    /**
+     * Draw a dot on the site's favicon while there are unsaved changes, via the
+     * [favicon store](/core/seo#favicon). Pass a color to override the theme accent.
+     * @default false
+     */
+    favicon?: boolean | {
+        color?: string;
     };
-    (options: _angular_core.InjectOptions): {
-        title: _angular_core.Signal<string>;
-        addPart: (id: symbol, part: TitlePart) => void;
-        removePart: (id: symbol) => void;
-    } | null;
+    /**
+     * Show an app badge while there are unsaved changes (Badging API). `true` shows a plain dot, a
+     * number shows that count.
+     *
+     * The badge is a per-app surface, not a per-tab one: it is only visible when the app is installed
+     * (PWA / desktop shortcut) and pinned, and it is a silent no-op everywhere else. Counts from
+     * several trackers add up; the badge is cleared once the last one is clean.
+     * @default false
+     */
+    badge?: boolean | number;
 };
-declare const applyHeadTitleBinding: (binding: MaybeSignal<string | number | null | undefined>, options?: Omit<TitlePart, "text">) => void;
+type CreateUnsavedChangesTabLockConfig = UnsavedChangesTabConfig & {
+    /** Whether there are unsaved changes right now - typically a tracker's `hasChanges`. */
+    hasChanges: Signal<boolean>;
+};
+type UnsavedChangesTabLockRef = {
+    /**
+     * Release the lock and remove the title marker / app badge. Also runs automatically when the
+     * injector that created the lock is destroyed.
+     */
+    destroy: () => void;
+};
+/**
+ * The browser-tab flavor of the unsaved-changes family: while `hasChanges` reads `true`, the tab
+ * cannot be closed or reloaded without the browser's confirm prompt, and - opt in - the tab title
+ * carries a marker (optionally blinking), the favicon carries a dot, and the installed app carries a
+ * badge.
+ *
+ * Every {@link createUnsavedChangesTracker} sets this up automatically (lock only); reach for it
+ * directly when you track "unsaved" state that isn't a form, or want to lock the tab from a signal
+ * you already have. Call from an injection context.
+ *
+ * ```ts
+ * createUnsavedChangesTabLock({
+ *   hasChanges: computed(() => this.uploads().some((u) => u.pending)),
+ *   titleMarker: true,
+ *   flash: true,
+ * });
+ * ```
+ */
+declare const createUnsavedChangesTabLock: (config: CreateUnsavedChangesTabLockConfig) => UnsavedChangesTabLockRef;
+
+/**
+ * Decides whether a value with unsaved changes may be discarded. Called with the current value when
+ * (and only when) changes exist. Return a truthy value / resolved Promise / emitted Observable value
+ * to allow the discard, falsy to keep the changes. Typically opens a confirm dialog.
+ *
+ * The second argument carries an {@link UnsavedChangesConfirmContext.signal} that aborts when the
+ * session ends underneath the confirm (a logout) - close your dialog when it fires.
+ */
+type UnsavedChangesConfirmFn<T> = (value: T, context: UnsavedChangesConfirmContext) => boolean | Promise<boolean> | Observable<boolean> | unknown;
+type CreateUnsavedChangesTrackerConfig<T> = {
+    /** The form / value to watch. See {@link UnsavedChangesSource}. */
+    source: UnsavedChangesSource<T>;
+    /**
+     * The baseline the current value is compared against.
+     * If omitted, the first non-null value the source produces is captured automatically (so
+     * async-filled forms work without wiring). A function is evaluated once, eagerly.
+     */
+    defaultValue?: T | (() => T);
+    /**
+     * Required, per call site. Runs only when there are changes to discard.
+     * @see UnsavedChangesConfirmFn
+     */
+    confirm: UnsavedChangesConfirmFn<T>;
+    /**
+     * Custom equality between the current value and the default. Deep-equal by default.
+     *
+     * Note: this is snapshot-vs-default comparison, deliberately **not** signal-forms' `dirty()`
+     * (which means "was edited", so typing then deleting stays dirty - here it's clean again).
+     */
+    compareFn?: (current: T, defaultValue: T) => boolean;
+    /**
+     * How the tracker guards the browser tab itself. The `beforeunload` lock - the browser's confirm
+     * prompt before the tab is closed or reloaded - is **on by default**, since a guard that only
+     * covers in-app navigation still loses the edits to <kbd>Ctrl</kbd>+<kbd>W</kbd>.
+     *
+     * Pass an object to also opt into a tab title marker or an app badge, or `false` to leave the tab
+     * alone entirely. See {@link UnsavedChangesTabConfig}.
+     * @default { lock: true }
+     */
+    tab?: UnsavedChangesTabConfig | false;
+};
+type UnsavedChangesTrackerRef<T> = {
+    /** Whether the current value differs from the default. */
+    hasChanges: Signal<boolean>;
+    /**
+     * Whether this guard was switched off because the session ended underneath it (a logout, or an
+     * explicit `injectUnsavedChangesCoordinator().abandonAll()`). An abandoned tracker still reports
+     * `hasChanges`, but `runCheck()` passes without confirming and the tab lock is released - the edits
+     * cannot be saved anymore, so blocking on them only strands the user.
+     */
+    isAbandoned: Signal<boolean>;
+    /** The current baseline. `null` until a value (or explicit default) exists. */
+    defaultValue: Signal<T | null>;
+    /**
+     * Resolves `true` if there are no changes or the user confirmed the discard, `false` otherwise.
+     * Normalizes the `confirm` return (value / Promise / Observable) to a `Promise<boolean>`.
+     *
+     * Only one confirm runs app-wide: a check that starts while another tracker's confirm is on screen
+     * adopts that decision instead of opening a second dialog.
+     */
+    runCheck: () => Promise<boolean>;
+    /** Re-baseline to the current value - e.g. after a save that keeps the form open. */
+    refreshDefaultValue: () => void;
+    /** Write the default back onto the source (revert edits). No-op if there is no default yet. */
+    restoreDefaultValue: () => void;
+    /**
+     * The tab guard (`beforeunload` lock, title marker, app badge) driven by `hasChanges` - `null` when
+     * the tracker was created with `tab: false`. Call `tab.destroy()` to release it before the
+     * injector is destroyed, e.g. right before a deliberate `location.reload()`.
+     */
+    tab: UnsavedChangesTabLockRef | null;
+};
+/**
+ * The framework-agnostic core of the unsaved-changes family: snapshots a default value, tracks
+ * whether the watched form/value differs from it, and runs an async confirm before a discard.
+ * Call from an injection context (a field initializer or constructor).
+ *
+ * While there are changes the browser tab is locked too (`beforeunload`), so closing or reloading the
+ * tab needs a confirmation - see the `tab` config for the title-marker / app-badge extras and for
+ * opting out.
+ *
+ * Every tracker registers with the app-wide {@link injectUnsavedChangesCoordinator}, which keeps a
+ * single confirm on screen at a time and switches all guards off when the session ends (logout).
+ *
+ * Overlay and router flavors (`createOverlayUnsavedChangesGuard`, `createUnsavedChangesGuard`) build
+ * on this - use them when you want the guard wired to a close/navigation event automatically.
+ */
+declare const createUnsavedChangesTracker: <T>(config: CreateUnsavedChangesTrackerConfig<T>) => UnsavedChangesTrackerRef<T>;
+
+type CreateUnsavedChangesGuardConfig<T> = CreateUnsavedChangesTrackerConfig<T>;
+type UnsavedChangesGuardRef<T> = UnsavedChangesTrackerRef<T> & {
+    /**
+     * A `CanDeactivateFn`-compatible check: resolves `true` when the route may be left (no changes, or
+     * the user confirmed the discard), `false` to stay. Wire it into a route's `canDeactivate`.
+     *
+     * ```ts
+     * export const editGuard: CanDeactivateFn<EditComponent> = (component) => component.guard.canDeactivate();
+     * ```
+     */
+    canDeactivate: () => Promise<boolean>;
+};
+/**
+ * The router / manual flavor of the unsaved-changes family: a {@link createUnsavedChangesTracker}
+ * plus a `canDeactivate` bridge for Angular route guards. It touches no overlay APIs, so it also
+ * serves as a standalone "does this form have unsaved changes, and may I discard them?" helper.
+ * Call from an injection context.
+ */
+declare const createUnsavedChangesGuard: <T>(config: CreateUnsavedChangesGuardConfig<T>) => UnsavedChangesGuardRef<T>;
 
-export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, BOUNDARY_ELEMENT_TOKEN, ClickOutsideDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUS_VISIBLE_TRACKER_TOKEN, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, IsArrayNotEmpty, IsEmail, jsonLd_d as JsonLD, KeyPressManager, MUST_MATCH, MatchStateType, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideThemeDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, RuntimeError, SEO_DIRECTIVE_TOKEN, SeoDirective, StructuredDataComponent, THEME_PROVIDER, ToArrayPipe, TypedQueryList, ValidateAtLeastOneRequired, Validators, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyDescriptionBinding, applyHeadBinding, applyHeadTitleBinding, applyHostListener, applyHostListeners, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boundingClientRectToElementRect, buildElementSignal, buildSignalEffects, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, createArrayPropertyBinding, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssThemeName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createPropHandlers, createPropertyBinding, createProps, createProvider, createRootProvider, createRootThemeCss, createRxHostListener, createSetup, createStaticProvider, createStaticRootProvider, createSwatchCss, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, deferredSignal, deleteCookie, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, equal, firstElementSignal, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, hasCookie, inferMimeType, injectAngularRootElement, injectBoundaryElement, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectPathParam, injectPathParamChanges, injectPathParams, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectTemplateRef, injectThemesPrefix, injectTitleConfig, injectTitleStore, injectUrl, injectViewportConfig, injectViewportDimensions, isArray, isElementSignal, isElementVisible, isGroupMatch, isKnockoutMatch, isObject, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, previousSignalValue, provideBoundaryElement, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideTitleConfig, provideTitleStore, provideViewportConfig, round, routerDisableScrollTop, scrollToElement, setCookie, setInputSignal, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toStringBinding, transformOrReturn, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideThemesPrefix };
-export type { AlternateLanguagesConfig, AlternateLink, AngularRenderer, AnimatedLifecycleState, AnimatedNumberSignal, AnimatedOverlayComponentBase, AnimatedOverlayMountConfig, AnimatedOverlayState, AnimationEndEvent, AnyTemplateType, ArticleConfig, BindPropsOptions, Breakpoint, BuildMediaQueryOptions, BuildSignalEffectsConfig, ComponentTemplate, ComponentTypeWithInputs, ControlValueSignalOptions, CreateLoggerConfig, CreatePropsOptions, CreateProviderOptions, CurrentElementVisibility, CursorDragScrollDirection, CursorDragScrollOptions, ElementDimensions, ElementLastScrollDirection, ElementLastScrollDirectionType, ElementRect, ElementScrollState, ElementSignal, ElementSignalValue, ElementSize, FacebookCard, FlipAnimationConfig, HeadBinding, HostProps, InjectQueryParamConfig, InjectUtilConfig, InjectUtilTransformConfig, IntersectionObserverEntryWithDetails, IsElementVisibleOptions, LinkConfig, LinkStoreConfig, LogicalSize, MaybeObservable, MaybeSignal, MetaConfig, MetaTagConfig, NgClassType, NgTemplateTemplate, NormalizedGameResultType, NormalizedMatchParticipant, NormalizedMatchParticipants, NormalizedMatchScore, NullableElementDimensions, OnThemeColorMap, OpenGraph, OpenGraphConfig, PropHandlers, Props, PropsAttachedElements, PropsAttachedElementsInternal, PropsInternal, ProviderResult, ResourceHintsConfig, RobotsConfig, RootProviderResult, RouterDisableScrollTopConfig, RouterState, ScrollToElementOptions, SeoConfig, SetupScrollRestorationConfig, SignalAnimatedNumberOptions, SignalElementBindingComplexType, SignalElementBindingType, SignalElementIntersectionOptions, SignalElementScrollStateOptions, SocialMediaConfig, StaticProviderResult, StringTemplate, StructuredDataConfig, SyncSignalOptions, TemplateRefWithContext, Theme, ThemeColor, ThemeColorMap, ThemeHSLColor, ThemeRGBColor, ThemeSwatch, TitleConfig, TitlePart, Translatable, TwitterCard, TwitterCardConfig, UnbindPropsOptions, ValidateAtLeastOneRequiredConfig, Vec2, ViewportConfig };
+export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, ANIMATION_DEBUG_STORAGE_KEY, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AutoSurfaceDirective, BOUNDARY_ELEMENT_TOKEN, BREAKPOINT_INSTANCE_TOKEN, BREAKPOINT_ORDER, COLOR_PROVIDER, ClickOutsideDirective, ColorInteractiveContainerDirective, ColorInteractiveDirective, ColorInteractiveExcludeDirective, ColorInteractiveHasFocusDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, DragHandleDirective, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUSABLE_SELECTOR, FOCUS_VISIBLE_TRACKER_TOKEN, HtmlToMarkdownPipe, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, InitialsPipe, IsArrayNotEmpty, IsEmail, jsonLd_d as JsonLD, KeyPressManager, MUST_MATCH, MarkdownToHtmlPipe, MatchStateType, MustMatch, NOTIFICATION_CLICK_MESSAGE_TYPE, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideColorDirective, ProvideSurfaceDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeHandlesComponent, RuntimeError, SURFACE_PROVIDER, SURFACE_TYPE, SWIPE_VELOCITY_WINDOW_MS, ScrollObserverDirective, ScrollObserverEndDirective, ScrollObserverStartDirective, SlugifyPipe, StructuredDataComponent, SurfaceInteractiveDirective, ToArrayPipe, TypedQueryList, UNSAVED_CHANGES_TITLE_MARKER, ValidateAtLeastOneRequired, Validators, anchoredOverlayPosition, animationDebugLog, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyCenteredPosition, applyDescriptionBinding, applyFaviconOverlay, applyGlobalPosition, applyHeadBinding, applyHeadTitleBinding, applyHeadTitleMarker, applyHostListener, applyHostListeners, applyInitialFocus, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boolBreakpointTransform, booleanBreakpointAttribute, boundingClientRectToElementRect, breakpointTransformBase, buildElementSignal, buildSignalEffects, canUseSessionMemory, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, copyToClipboard, createAnchoredPositionCleanup, createArrayPropertyBinding, createAutoSessionMemoryKey, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssColorThemeName, createCssSurfaceName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createOverlayRuntimeRef, createPropHandlers, createPropertyBinding, createProps, createRootThemeCss, createRoute, createRouterState, createRxHostListener, createSessionMemory, createSetup, createSwatchCss, createSwipeTracker, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, createUnsavedChangesGuard, createUnsavedChangesTabLock, createUnsavedChangesTracker, createUserConsentProvider, deferredSignal, defineLabels, defineProvider, defineRootProvider, defineStaticProvider, defineStaticRootProvider, deleteCookie, dragGestureFrom, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, enableAnchoredOverlayPositionExtras, equal, firstElementSignal, focusElement, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFocusableElements, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getHeadingElement, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, getScrollContainerTarget, getScrollItemTarget, getScrollSnapTarget, hasCookie, holdScrollRestoration, htmlToMarkdown, inferMimeType, initials, injectAngularRootElement, injectAnimatedBlockSize, injectBoundaryElement, injectBreakpointInput, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectColorThemesPrefix, injectCurrentBreakpoint, injectDefaultColorTheme, injectDeviceInputType, injectDisplayOrientation, injectErrorTheme, injectFaviconStore, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsDocumentVisible, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectNotifications, injectObserveBreakpoint, injectObserveMediaQuery, injectOverlayRuntime, injectPathParam, injectPathParamChanges, injectPathParams, injectPrefersReducedMotion, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterNavigationState, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectStyleManager, injectSuccessTheme, injectSurfaceContextTracker, injectSurfaceThemes, injectSurfaceThemesPrefix, injectTemplateRef, injectTitleConfig, injectTitleStore, injectUnsavedChangesCoordinator, injectUrl, injectViewportConfig, injectViewportDimensions, injectViewportSize, injectWarningTheme, isAnimationDebugEnabled, isArray, isElementSignal, isElementVisible, isFocusable, isGroupMatch, isHTMLElement, isKnockoutMatch, isObject, markdownToHtml, matchesReducedMotion, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, normalizeUnsavedChangesSource, numberBreakpointAttribute, numberBreakpointTransform, previousSignalValue, provideBoundaryElement, provideBreakpointInstance, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFaviconStore, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideNotifications, provideOverlayRuntime, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideStyleManager, provideSurfaceContextTracker, provideSurfaceThemesWithTailwind4, provideTitleConfig, provideTitleStore, provideUnsavedChangesCoordinator, provideViewportConfig, randomId, readFromClipboard, registerAnchoredPositionMiddlewareExtras, registerAnchoredPositionSetup, resetPositioningStyles, resolveAppRootColorProvider, resolveSurfaceByElevation, round, routerDisableScrollTop, scrollToElement, setBackdropStyles, setBaseElementStyles, setCookie, setInputSignal, setupFocusTrap, setupPositioning, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, slugify, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toInjectFn, toProvideFn, toStringBinding, toToken, transformOrReturn, typedBreakpointTransform, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideColorThemesPrefix, ɵProvideSurfaceThemes, ɵProvideSurfaceThemesPrefix };
+export type { AlternateLanguagesConfig, AnchoredPositionMiddlewareExtras, AnchoredPositionSetup, AngularRenderer, AnimatedBlockSizeConfig, AnimatedLifecycleState, AnimatedNumberSignal, AnimatedSizeAxis, AnimationEndEvent, AnyTemplateType, ArticleConfig, BindPropsOptions, BoolBreakpointSignal, Breakpoint, BreakpointInput, BreakpointMap, BuildMediaQueryOptions, BuildSignalEffectsConfig, ColorTheme, ColorThemeType, ComponentTemplate, ComponentType, ComponentTypeWithInputs, ConsentHandler, ControlValueSignalOptions, CreateLoggerConfig, CreatePropsOptions, CreateSessionMemoryConfig, CreateUnsavedChangesGuardConfig, CreateUnsavedChangesTabLockConfig, CreateUnsavedChangesTrackerConfig, CreateUserConsentProviderOptions, CurrentElementVisibility, CursorDragScrollDirection, CursorDragScrollOptions, DragGestureEvent, DragMoveEvent, DragStartEvent, ElementDimensions, ElementLastScrollDirection, ElementLastScrollDirectionType, ElementRect, ElementScrollState, ElementSignal, ElementSignalValue, ElementSize, EthleteColorThemeNameRegistry, EthleteSurfaceThemeNameRegistry, FaviconOverlay, FlipAnimationConfig, HeadBinding, HostProps, InjectFn, InjectQueryParamConfig, InjectUtilConfig, InjectUtilTransformConfig, IntersectionObserverEntryWithDetails, IsElementVisibleOptions, LabelsDefinition, LabelsSource, LinkConfig, LinkStoreConfig, LogicalSize, MaybeSignal, MetaConfig, MetaTagConfig, NgClassType, NgTemplateTemplate, NormalizedGameResultType, NormalizedMatchParticipant, NormalizedMatchParticipants, NormalizedMatchScore, NormalizedUnsavedChangesSource, NotificationActionConfig, NotificationClickContext, NotificationClickMessage, NotificationDeliveryPath, NotificationPermissionState, NotificationRef, Notifications, NullableElementDimensions, NumberBreakpointSignal, OnThemeColorMap, OpenGraphConfig, OverlayRuntimeAnchoredPosition, OverlayRuntimeAnimationDelegate, OverlayRuntimeAnimationDelegateEnterContext, OverlayRuntimeAnimationDelegateLeaveContext, OverlayRuntimeAutoFocusTarget, OverlayRuntimeCenteredPosition, OverlayRuntimeCloseEvent, OverlayRuntimeCloseGuard, OverlayRuntimeCloseSource, OverlayRuntimeComponentBase, OverlayRuntimeElements, OverlayRuntimeGlobalPosition, OverlayRuntimeGlobalPositionAlignment, OverlayRuntimeMountConfig, OverlayRuntimePositionStrategy, OverlayRuntimeRef, OverlayRuntimeRole, OverlayRuntimeShiftOptions, OverlayRuntimeState, PropHandlers, Props, PropsAttachedElements, PropsAttachedElementsInternal, PropsInternal, ProviderDefinition, ProviderDefinitionOptions, RegisteredColorThemeName, RegisteredSurfaceThemeName, ResizeEdge, ResizeMoveEvent, ResourceHintsConfig, RobotsConfig, RouterDisableScrollTopConfig, RouterState, ScrollContainerTarget, ScrollItemTarget, ScrollRestorationRestoreConfig, ScrollRestorationScrollElement, ScrollSnapOrigin, ScrollSnapTarget, ScrollToElementOptions, SetupScrollRestorationConfig, ShowNotificationConfig, SignalAnimatedNumberOptions, SignalElementBindingComplexType, SignalElementBindingType, SignalElementChildrenOptions, SignalElementIntersectionOptions, SignalElementScrollStateOptions, SocialMediaConfig, StaticProviderDefinition, StringTemplate, StructuredDataConfig, StyleManager, SurfaceContextEntry, SurfaceContextSurface, SurfaceContextTracker, SurfaceInteractionColor, SurfaceTheme, SurfaceThemeColor, SurfaceType, SwipeEndEvent, SwipeTracker, SwipeUpdateEvent, SyncSignalOptions, TemplateRefWithContext, ThemeColor, ThemeColorMap, ThemeHSLColor, ThemeInkColorMap, ThemeRGBColor, ThemeSwatch, TitleConfig, TitlePart, Translatable, TwitterCardConfig, TypedBreakpointSignal, UnbindPropsOptions, UnsavedChangesAbandonReason, UnsavedChangesConfirmContext, UnsavedChangesConfirmFn, UnsavedChangesGuardRef, UnsavedChangesRegistration, UnsavedChangesSource, UnsavedChangesTabConfig, UnsavedChangesTabLockRef, UnsavedChangesTrackerRef, ValidateAtLeastOneRequiredConfig, Vec2, ViewportConfig };