@ethlete/core 4.27.1 → 4.29.0

package/index.d.ts

@@ -1,36 +1,1973 @@
-export * from './lib/components/structured-data';
-export * from './lib/constants';
-export * from './lib/decorators/memo';
-export * from './lib/directives/animatable';
-export * from './lib/directives/animated-if';
-export * from './lib/directives/animated-lifecycle';
-export * from './lib/directives/animated-overlay';
-export * from './lib/directives/click-outside';
-export * from './lib/directives/cursor-drag-scroll';
-export * from './lib/directives/debug';
-export * from './lib/directives/delayable';
-export * from './lib/directives/is-active-element';
-export * from './lib/directives/is-element';
-export * from './lib/directives/let';
-export * from './lib/directives/observe-content';
-export * from './lib/directives/observe-resize';
-export * from './lib/directives/observe-scroll-state';
-export * from './lib/directives/observe-visibility';
-export * from './lib/directives/repeat';
-export * from './lib/directives/root-boundary';
-export * from './lib/directives/scroll-observer-first-element';
-export * from './lib/directives/scroll-observer-ignore-target';
-export * from './lib/directives/scroll-observer-last-element';
-export * from './lib/directives/seo';
-export * from './lib/pipes/infer-mime-type';
-export * from './lib/pipes/normalize-game-result-type';
-export * from './lib/pipes/normalize-match-participants';
-export * from './lib/pipes/normalize-match-score';
-export * from './lib/pipes/normalize-match-state';
-export * from './lib/pipes/normalize-match-type';
-export * from './lib/pipes/to-array';
-export * from './lib/props';
-export * from './lib/services';
-export * from './lib/types';
-export * from './lib/utils';
-export * from './lib/validators';
+import { SafeHtml } from '@angular/platform-browser';
+import * as _ethlete_types from '@ethlete/types';
+import { JsonLD, ParticipantViewUnion, MatchListView, MatchRankingView, StageType } from '@ethlete/types';
+import * as i0 from '@angular/core';
+import { Type, QueryList, InjectionToken, OnInit, AfterViewInit, ElementRef, ComponentRef, StaticProvider, OnDestroy, EventEmitter, AfterContentInit, Signal, TemplateRef, ViewContainerRef, PipeTransform, TrackByFunction, WritableSignal, DestroyRef, Injector, EffectRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as i1 from '@angular/common';
+import { OverlayRef, ScrollStrategy } from '@angular/cdk/overlay';
+import { ComponentPortal, ComponentType } from '@angular/cdk/portal';
+import { ProvideThemeDirective } from '@ethlete/theming';
+import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
+import * as _ethlete_core from '@ethlete/core';
+import * as _angular_router from '@angular/router';
+import { Data, Params } from '@angular/router';
+import * as _angular_forms from '@angular/forms';
+import { FormGroup, AbstractControl, FormControl, ValidatorFn, ValidationErrors } from '@angular/forms';
+
+declare class StructuredDataComponent {
+    private readonly _sanitizer;
+    set data(currentValue: JsonLD.WithContext<JsonLD.Thing> | JsonLD.Graph | null | undefined);
+    jsonLD?: SafeHtml;
+    getSafeHTML(value: JsonLD.WithContext<JsonLD.Thing> | JsonLD.Graph | null | undefined): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StructuredDataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StructuredDataComponent, "et-structured-data", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type NgClassType = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+type HostDirective = Type<unknown> | {
+    directive: Type<unknown>;
+    inputs?: string[];
+    outputs?: string[];
+};
+declare class TypedQueryList<T> extends QueryList<T> {
+    get changes(): Observable<TypedQueryList<T>>;
+}
+
+interface Translatable {
+    i18n: string;
+    text: string;
+}
+
+type Primitive = string | number | boolean | null | undefined | symbol | bigint;
+type Reference = Record<string, unknown> | Array<unknown>;
+
+type Vec2 = [number, number];
+interface ViewportConfig {
+    breakpoints: {
+        xs: Vec2;
+        sm: Vec2;
+        md: Vec2;
+        lg: Vec2;
+        xl: Vec2;
+        '2xl': Vec2;
+    };
+}
+type Breakpoint = keyof ViewportConfig['breakpoints'];
+
+declare const VIEWPORT_CONFIG: InjectionToken<ViewportConfig>;
+/**
+ * Default viewport config based on Tailwind CSS.
+ * @see https://tailwindcss.com/docs/screens
+ */
+declare const DEFAULT_VIEWPORT_CONFIG: ViewportConfig;
+
+interface MemoResolver {
+    (...args: any[]): any;
+}
+interface MapLike<K = unknown, V = unknown> {
+    set(key: K, v: V): MapLike<K, V>;
+    get(key: K): V;
+    has(key: K): boolean;
+}
+interface MemoConfig {
+    resolver?: MemoResolver;
+    cache?: MapLike;
+}
+declare const Memo: (config?: MemoConfig) => (_: unknown, __: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare const ANIMATABLE_TOKEN: InjectionToken<AnimatableDirective>;
+declare class AnimatableDirective implements OnInit {
+    private _didEmitStart;
+    private readonly _parent;
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _animationStart$;
+    private readonly _animationEnd$;
+    private readonly _animationCancelled$;
+    set animatedElement(value: string | HTMLElement | null | undefined);
+    private _animatedElement$;
+    readonly animationStart$: Observable<void>;
+    readonly animationEnd$: Observable<void>;
+    readonly animationCancelled$: Observable<void>;
+    private readonly _hostActiveAnimationCount$;
+    private readonly _totalActiveAnimationCount$;
+    readonly isAnimating$: Observable<boolean>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimatableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnimatableDirective, "[etAnimatable]", ["etAnimatable"], { "animatedElement": { "alias": "etAnimatable"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const ANIMATED_IF_TOKEN: InjectionToken<AnimatedIfDirective>;
+declare class AnimatedIfDirective {
+    private readonly _destroy$;
+    private readonly _ngIf;
+    private readonly _animatedLifecycle;
+    set shouldRender(value: unknown);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimatedIfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnimatedIfDirective, "[etAnimatedIf]", never, { "shouldRender": { "alias": "etAnimatedIf"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.NgIf; inputs: {}; outputs: {}; }]>;
+}
+
+declare const ANIMATED_LIFECYCLE_TOKEN: InjectionToken<AnimatedLifecycleDirective>;
+type AnimatedLifecycleState = 'entering' | 'entered' | 'leaving' | 'left' | 'init';
+declare class AnimatedLifecycleDirective implements AfterViewInit {
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _animatable;
+    private readonly _classList;
+    private _isConstructed;
+    private _state$;
+    readonly state$: rxjs.Observable<AnimatedLifecycleState>;
+    get state(): AnimatedLifecycleState;
+    stateSignal: i0.Signal<AnimatedLifecycleState>;
+    stateChange: i0.OutputRef<AnimatedLifecycleState>;
+    skipNextEnter: i0.ModelSignal<boolean>;
+    constructor();
+    ngAfterViewInit(): void;
+    enter(config?: {
+        onlyTransition?: boolean;
+    }): void;
+    leave(config?: {
+        onlyTransition?: boolean;
+    }): void;
+    _forceState(state: AnimatedLifecycleState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimatedLifecycleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnimatedLifecycleDirective, "[etAnimatedLifecycle]", ["etAnimatedLifecycle"], { "skipNextEnter": { "alias": "skipNextEnter"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "skipNextEnter": "skipNextEnterChange"; }, never, never, true, [{ directive: typeof AnimatableDirective; inputs: {}; outputs: {}; }]>;
+}
+
+interface AnimatedOverlayComponentBase {
+    _elementRef?: ElementRef<HTMLElement>;
+    _animatedLifecycle?: AnimatedLifecycleDirective;
+    _markForCheck?: () => void;
+    _setThemeFromProvider?: (provider: ProvideThemeDirective) => void;
+}
+declare class AnimatedOverlayDirective<T extends AnimatedOverlayComponentBase> {
+    private readonly _destroy$;
+    private readonly _overlayService;
+    private readonly _injector;
+    private readonly _viewContainerRef;
+    private readonly _zone;
+    private readonly _elementRef;
+    private readonly _resizeObserverService;
+    private readonly _rootBoundary;
+    private _portal;
+    private _overlayRef;
+    private _componentRef;
+    private _floatingElCleanupFn;
+    private _beforeOpened;
+    private _afterOpened;
+    private _beforeClosed;
+    private _afterClosed;
+    private readonly _isMounted$;
+    private readonly _isMounting$;
+    private readonly _isUnmounting$;
+    private readonly _isHidden$;
+    /**
+     * The placement of the animated overlay.
+     * @default undefined
+     */
+    placement?: Placement;
+    /**
+     * The allowed auto placements of the animated overlay.
+     * @see https://floating-ui.com/docs/flip#fallbackplacements
+     */
+    fallbackPlacements?: Placement[];
+    /**
+     * The offset of the animated overlay.
+     * @see https://floating-ui.com/docs/offset
+     */
+    offset: OffsetOptions | null;
+    /**
+     * The arrow padding.
+     * @see https://floating-ui.com/docs/arrow#padding
+     * @default 4
+     */
+    arrowPadding: Padding | null;
+    /**
+     * The viewport padding.
+     * @default 8
+     */
+    viewportPadding: Padding | null;
+    /**
+     * Whether the animated overlay should auto resize to fit the available space.
+     * Useful for things like selects where the list of options might be longer than the available space.
+     * @default false
+     */
+    autoResize: boolean;
+    /**
+     * Whether the animated overlay should shift when it is near the viewport boundary.
+     */
+    shift: boolean;
+    /**
+     * Whether the animated overlay should auto hide when the reference element is hidden.
+     * @default false
+     */
+    autoHide: boolean;
+    /**
+     * Whether the animated overlay should auto close if the reference element is hidden.
+     * @default false
+     */
+    autoCloseIfReferenceHidden: boolean;
+    /**
+     * The reference element for the animated overlay.
+     * @default this._elementRef.nativeElement
+     */
+    referenceElement: HTMLElement;
+    get isMounted(): boolean;
+    get isMounted$(): rxjs.Observable<boolean>;
+    get isMounting(): boolean;
+    get isMounting$(): rxjs.Observable<boolean>;
+    get isUnmounting(): boolean;
+    get isHidden$(): rxjs.Observable<boolean>;
+    get isHidden(): boolean;
+    get canMount(): boolean;
+    get canUnmount(): boolean;
+    get portal(): ComponentPortal<T> | null;
+    get overlayRef(): OverlayRef | null;
+    get componentRef(): ComponentRef<T> | null;
+    mount(config: {
+        component: ComponentType<T>;
+        providers?: StaticProvider[];
+        data?: Partial<T>;
+        mirrorWidth?: boolean;
+        themeProvider?: ProvideThemeDirective | null;
+    }): T | undefined;
+    unmount(): void;
+    beforeOpened(): Subject<void>;
+    afterOpened(): Subject<void>;
+    beforeClosed(): Subject<void>;
+    afterClosed(): Subject<void>;
+    _destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimatedOverlayDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnimatedOverlayDirective<any>, never, never, { "placement": { "alias": "placement"; "required": false; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "shift": { "alias": "shift"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; }; "referenceElement": { "alias": "referenceElement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_autoResize: unknown;
+    static ngAcceptInputType_shift: unknown;
+    static ngAcceptInputType_autoHide: unknown;
+    static ngAcceptInputType_autoCloseIfReferenceHidden: unknown;
+}
+
+declare class ClickOutsideDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _clickObserverService;
+    private _subscription;
+    etClickOutside: EventEmitter<MouseEvent>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[etClickOutside]", never, {}, { "etClickOutside": "etClickOutside"; }, never, never, true, never>;
+}
+
+declare const CURSOR_DRAG_SCROLLING_CLASS = "et-cursor-drag-scroll--scrolling";
+declare const CURSOR_DRAG_SCROLLING_PREPARED_CLASS = "et-cursor-drag-scroll--prepared";
+
+declare class CursorDragScrollDirective implements AfterViewInit {
+    private readonly _subscriptions;
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _contentObserverService;
+    private readonly _resizeObserverService;
+    private readonly _bufferUntilScroll;
+    private readonly _mouseUp$;
+    private _isScrolling;
+    private _canScroll;
+    private _currentScrollState;
+    get enabled(): boolean;
+    set enabled(value: unknown);
+    private _enabled;
+    allowedDirection: 'horizontal' | 'vertical' | 'both';
+    readonly cursorDragStart: EventEmitter<void>;
+    readonly cursorDragMove: EventEmitter<void>;
+    readonly cursorDragEnd: EventEmitter<void>;
+    ngAfterViewInit(): void;
+    private _enableCursorDragScroll;
+    private _disableCursorDragScroll;
+    private _onMouseDown;
+    private _mouseMoveHandler;
+    private _mouseUpHandler;
+    private _updateCanScrollState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CursorDragScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CursorDragScrollDirective, "[etCursorDragScroll]", ["etCursorDragScroll"], { "enabled": { "alias": "etCursorDragScroll"; "required": false; }; "allowedDirection": { "alias": "allowedDirection"; "required": false; }; }, { "cursorDragStart": "cursorDragStart"; "cursorDragMove": "cursorDragMove"; "cursorDragEnd": "cursorDragEnd"; }, never, never, true, never>;
+}
+
+declare const DEBUG_TOKEN: InjectionToken<DebugDirective>;
+declare class DebugDirective {
+    private readonly _destroy$;
+    private set sDebug(value);
+    private _debug;
+    readonly debug: i0.Signal<boolean>;
+    readonly debug$: rxjs.Observable<boolean>;
+    readonly startDebug$: rxjs.Observable<boolean>;
+    readonly stopDebug$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DebugDirective, "[etDebug]", ["etDebug"], { "sDebug": { "alias": "etDebug"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_sDebug: unknown;
+}
+
+declare const DELAYABLE_TOKEN: InjectionToken<DelayableDirective>;
+declare class DelayableDirective {
+    private readonly _isDelayed$;
+    get isDelayed$(): rxjs.Observable<boolean>;
+    get isDelayed(): boolean;
+    enableDelayed(): void;
+    disableDelayed(): void;
+    setDelayed(val: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DelayableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DelayableDirective, "[etDelayable]", ["etDelayable"], {}, {}, never, never, true, never>;
+}
+
+declare const IS_ACTIVE_ELEMENT: InjectionToken<IsActiveElementDirective>;
+declare class IsActiveElementDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    isActiveElement: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsActiveElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IsActiveElementDirective, "[etIsActiveElement]", never, { "isActiveElement": { "alias": "etIsActiveElement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isActiveElement: unknown;
+}
+
+declare const IS_ELEMENT: InjectionToken<IsElementDirective>;
+declare class IsElementDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    isElement: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IsElementDirective, "[etIsElement]", never, { "isElement": { "alias": "etIsElement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isElement: unknown;
+}
+
+declare class LetContext<T = unknown> {
+    $implicit: T;
+    etLet: T;
+}
+
+/** @deprecated Use the let keyword provided by Angular instead. */
+declare class LetDirective<T = unknown> {
+    private _viewContainer;
+    set etLet(value: T);
+    static ngTemplateGuard_ngLet: 'binding';
+    private _context;
+    private _templateRef;
+    private _viewRef;
+    static ngTemplateContextGuard<T>(dir: LetDirective<T>, ctx: any): ctx is LetContext<T>;
+    private _updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LetDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LetDirective<any>, "[etLet]", never, { "etLet": { "alias": "etLet"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ObserveContentDirective implements AfterContentInit, OnDestroy {
+    private _contentObserver;
+    private _elementRef;
+    private _ngZone;
+    readonly valueChange: EventEmitter<MutationRecord[]>;
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    private _disabled;
+    get debounce(): number | null;
+    set debounce(value: unknown);
+    private _debounce;
+    private _currentSubscription;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private _subscribe;
+    private _unsubscribe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ObserveContentDirective, "[etObserveContent]", ["etObserveContent"], { "disabled": { "alias": "etObserveContentDisabled"; "required": false; }; "debounce": { "alias": "etObserveContentDebounce"; "required": false; }; }, { "valueChange": "etObserveContent"; }, never, never, true, never>;
+}
+
+declare class ObserveResizeDirective implements AfterContentInit, OnDestroy {
+    private _resizeObserver;
+    private _elementRef;
+    private _ngZone;
+    readonly valueChange: EventEmitter<ResizeObserverEntry[]>;
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    private _disabled;
+    get debounce(): number | null;
+    set debounce(value: unknown);
+    private _debounce;
+    private _currentSubscription;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private _subscribe;
+    private _unsubscribe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ObserveResizeDirective, "[etObserveResize]", ["etObserveResize"], { "disabled": { "alias": "etObserveResizeDisabled"; "required": false; }; "debounce": { "alias": "etObserveResizeDebounce"; "required": false; }; }, { "valueChange": "etObserveResize"; }, never, never, true, never>;
+}
+
+interface ScrollObserverScrollState {
+    isAtStart: boolean;
+    isAtEnd: boolean;
+    canScroll: boolean;
+}
+type ObservedScrollableChild = 'first' | 'last';
+
+declare const SCROLL_OBSERVER_OBSERVING_FIRST_ELEMENT_CLASS = "et-scroll-observer-observing-first-element";
+declare const SCROLL_OBSERVER_OBSERVING_LAST_ELEMENT_CLASS = "et-scroll-observer-observing-last-element";
+declare class ObserveScrollStateDirective implements OnInit, OnDestroy {
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _contentObserverService;
+    private readonly _resizeObserverService;
+    private get _firstCurrentChild();
+    private get _lastCurrentChild();
+    rootMargin: number;
+    get observerThreshold(): number | number[];
+    set observerThreshold(value: unknown);
+    private _threshold;
+    private _intersectionObserver;
+    private get _observerElements();
+    valueChange: EventEmitter<ScrollObserverScrollState>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _checkChildren;
+    private _initiateIntersectionObserver;
+    private _observe;
+    private _unobserve;
+    private _clearIntersectionObserver;
+    private _getNonIgnoredChild;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveScrollStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ObserveScrollStateDirective, "[etObserveScrollState]", ["etObserveScrollState"], { "rootMargin": { "alias": "rootMargin"; "required": false; }; "observerThreshold": { "alias": "observerThreshold"; "required": false; }; }, { "valueChange": "etObserveScrollState"; }, never, never, true, never>;
+    static ngAcceptInputType_rootMargin: unknown;
+}
+
+declare const OBSERVE_SCROLL_STATE: InjectionToken<ObserveScrollStateDirective>;
+
+declare const OBSERVE_VISIBILITY_TOKEN: InjectionToken<ObserveVisibilityDirective>;
+interface ObserveVisibilityChange {
+    visible: boolean;
+    isAbove: boolean;
+    isBelow: boolean;
+    isLeft: boolean;
+    isRight: boolean;
+    entry: IntersectionObserverEntry;
+}
+declare const signalVisibilityChangeClasses: (cfg: {
+    name: string;
+    signal: Signal<ObserveVisibilityChange | null | undefined>;
+}) => {
+    [x: string]: Signal<boolean | undefined>;
+};
+declare class ObserveVisibilityDirective implements AfterViewInit {
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _intersectionObserverService;
+    protected readonly visibilityChange: i0.WritableSignal<ObserveVisibilityChange | null>;
+    readonly currentVisibility: Signal<ObserveVisibilityChange | null>;
+    readonly currentVisibility$: rxjs.Observable<ObserveVisibilityChange | null>;
+    readonly etObserveVisibility: EventEmitter<ObserveVisibilityChange>;
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserveVisibilityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ObserveVisibilityDirective, "[etObserveVisibility]", never, {}, { "etObserveVisibility": "etObserveVisibility"; }, never, never, true, never>;
+}
+
+declare class RepeatDirective {
+    private _mainTemplateRef;
+    private _viewContainerRef;
+    get repeatCount(): number;
+    set repeatCount(value: unknown);
+    private _repeatCount;
+    constructor(_mainTemplateRef: TemplateRef<unknown>, _viewContainerRef: ViewContainerRef);
+    private _render;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RepeatDirective, "[etRepeat]", never, { "repeatCount": { "alias": "etRepeat"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const ROOT_BOUNDARY_TOKEN: InjectionToken<RootBoundaryDirective>;
+declare class RootBoundaryDirective {
+    private readonly _elementRef;
+    get boundaryElement(): HTMLElement | null;
+    set boundaryElement(v: HTMLElement | null);
+    private _boundaryElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootBoundaryDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RootBoundaryDirective, "[etRootBoundary]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SCROLL_OBSERVER_FIRST_ELEMENT_CLASS = "et-scroll-observer-first-element";
+declare class ScrollObserverFirstElementDirective {
+    isFirstElement: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollObserverFirstElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollObserverFirstElementDirective, "[etScrollObserverFirstElement]", never, { "isFirstElement": { "alias": "etScrollObserverFirstElement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isFirstElement: unknown;
+}
+
+declare const SCROLL_OBSERVER_IGNORE_TARGET_CLASS = "et-scroll-observer-ignore-target";
+declare class ScrollObserverIgnoreTargetDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollObserverIgnoreTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollObserverIgnoreTargetDirective, "[etScrollObserverIgnoreTarget]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SCROLL_OBSERVER_LAST_ELEMENT_CLASS = "et-scroll-observer-last-element";
+declare class ScrollObserverLastElementDirective {
+    isLastElement: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollObserverLastElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollObserverLastElementDirective, "[etScrollObserverLastElement]", never, { "isLastElement": { "alias": "etScrollObserverLastElement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isLastElement: unknown;
+}
+
+type MaybeObservable<T> = T | Observable<T>;
+interface 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>;
+}
+interface AlternateLink {
+    href: string;
+    hreflang: string;
+}
+interface 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[]>;
+}
+interface TwitterCard {
+    card?: MaybeObservable<string>;
+    site?: MaybeObservable<string>;
+    creator?: MaybeObservable<string>;
+    title?: MaybeObservable<string>;
+    description?: MaybeObservable<string>;
+    image?: MaybeObservable<string>;
+    imageAlt?: MaybeObservable<string>;
+}
+interface 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 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: i0.ɵɵFactoryDeclaration<SeoDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SeoDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const SEO_DIRECTIVE_TOKEN: InjectionToken<SeoDirective>;
+
+declare const mergeSeoConfig: (config: SeoConfig, parentConfig: SeoConfig) => SeoConfig;
+
+declare class InferMimeTypePipe implements PipeTransform {
+    transform: (srcset: string) => "image/avif" | "image/bmp" | "image/gif" | "image/vdn.microsoft.icon" | "image/jpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "audio/aac" | "application/x-abiword" | "application/x-freearc" | "video/x-msvideo" | "application/vnd.amazon.ebook" | "application/octet-stream" | "application/x-bzip" | "application/x-bzip2" | "application/x-cdf" | "application/x-csh" | "text/css" | "text/csv" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-fontobject" | "application/epub+zip" | "application/gzip" | "text/html" | "text/calendar" | "application/java-archive" | "text/javascript" | "application/json" | "application/ld+json" | "audio/midi" | "audio/mpeg" | "video/mp4" | "video/mpeg" | "tapplication/vnd.apple.installer+xml" | "application/vnd.oasis.opendocument.presentation" | "application/vnd.oasis.opendocument.spreadsheet" | "application/vnd.oasis.opendocument.text" | "audio/ogg" | "video/ogg" | "application/ogg" | "audio/opus" | "font/otf" | "application/pdf" | "application/x-httpd-php" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.rar" | "application/rtf" | "application/x-sh" | "application/x-tar" | "video/mp2t" | "font/ttf" | "text/plain" | "application/vnd.visio" | "audio/wav" | "audio/webm" | "video/webm" | "font/woff" | "font/woff2" | "application/xhtml+xml" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/xml" | "application/vnd.mozilla.xul+xml" | "application/zip" | "video/3gpp" | "video/3gpp2" | "application/x-7z-compressed" | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InferMimeTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InferMimeTypePipe, "inferMimeType", true>;
+}
+
+/**
+ * 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 inferMimeType: (srcset: string) => "image/avif" | "image/bmp" | "image/gif" | "image/vdn.microsoft.icon" | "image/jpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "audio/aac" | "application/x-abiword" | "application/x-freearc" | "video/x-msvideo" | "application/vnd.amazon.ebook" | "application/octet-stream" | "application/x-bzip" | "application/x-bzip2" | "application/x-cdf" | "application/x-csh" | "text/css" | "text/csv" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-fontobject" | "application/epub+zip" | "application/gzip" | "text/html" | "text/calendar" | "application/java-archive" | "text/javascript" | "application/json" | "application/ld+json" | "audio/midi" | "audio/mpeg" | "video/mp4" | "video/mpeg" | "tapplication/vnd.apple.installer+xml" | "application/vnd.oasis.opendocument.presentation" | "application/vnd.oasis.opendocument.spreadsheet" | "application/vnd.oasis.opendocument.text" | "audio/ogg" | "video/ogg" | "application/ogg" | "audio/opus" | "font/otf" | "application/pdf" | "application/x-httpd-php" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.rar" | "application/rtf" | "application/x-sh" | "application/x-tar" | "video/mp2t" | "font/ttf" | "text/plain" | "application/vnd.visio" | "audio/wav" | "audio/webm" | "video/webm" | "font/woff" | "font/woff2" | "application/xhtml+xml" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/xml" | "application/vnd.mozilla.xul+xml" | "application/zip" | "video/3gpp" | "video/3gpp2" | "application/x-7z-compressed" | null;
+
+declare class NormalizeGameResultTypePipe implements PipeTransform {
+    transform: (type: string | null) => _ethlete_core.NormalizedGameResultType | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NormalizeGameResultTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NormalizeGameResultTypePipe, "etNormalizeGameResultType", true>;
+}
+
+interface NormalizedGameResultType extends Translatable {
+    shortCode: string;
+}
+
+declare const normalizeGameResultType: (type: string | null) => NormalizedGameResultType | null;
+
+declare class NormalizeMatchParticipantsPipe implements PipeTransform {
+    transform: (match: _ethlete_types.MatchListView | null) => _ethlete_core.NormalizedMatchParticipants | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NormalizeMatchParticipantsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NormalizeMatchParticipantsPipe, "etNormalizeMatchParticipants", true>;
+}
+
+interface NormalizedMatchParticipants {
+    home: NormalizedMatchParticipant | null;
+    away: NormalizedMatchParticipant | null;
+}
+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: _ethlete_types.MatchListView | null | undefined) => _ethlete_core.NormalizedMatchScore | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NormalizeMatchScorePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NormalizeMatchScorePipe, "etNormalizeMatchScore", true>;
+}
+
+interface NormalizedMatchScore {
+    home: {
+        score: string | number | null;
+        isWinner: boolean;
+    };
+    away: {
+        score: string | number | null;
+        isWinner: boolean;
+    };
+    subLine: string | null;
+    isNumeric: 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;
+    };
+    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 const enum MatchStateType {
+    PREPARING_ROUND = "preparingRound",
+    PRE_MATCH = "preMatch",
+    LIVE = "live",
+    POST_MATCH = "postMatch",
+    AUTO_WIN = "autoWin"
+}
+
+declare class NormalizeMatchStatePipe implements PipeTransform {
+    transform: (match: _ethlete_types.MatchListView | null | undefined) => _ethlete_core.MatchStateType | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NormalizeMatchStatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NormalizeMatchStatePipe, "etNormalizeMatchState", true>;
+}
+
+declare const normalizeMatchState: (match: MatchListView | null | undefined) => MatchStateType | null;
+
+declare class NormalizeMatchTypePipe implements PipeTransform {
+    transform: (matchType: _ethlete_types.StageType | null | undefined) => _ethlete_core.Translatable | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NormalizeMatchTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NormalizeMatchTypePipe, "etNormalizeMatchType", true>;
+}
+
+declare const normalizeMatchType: (matchType: StageType | null | undefined) => Translatable | null;
+
+declare class ToArrayPipe implements PipeTransform {
+    transform: (value: number) => number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToArrayPipe, never>;
+    static ɵpipe: i0.ɵɵ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: i0.Signal<unknown>) => void;
+        pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+    };
+    attributes: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: i0.Signal<unknown>) => void;
+        pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+    };
+    styles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: i0.Signal<unknown>) => void;
+        pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+    };
+    id: string;
+    elementRef: ElementRef<HTMLElement>;
+};
+type PropHandlers = ReturnType<typeof createPropHandlers>;
+
+type Props = Readonly<{
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElements;
+}>;
+interface PropsAttachedElements {
+    first: Signal<HTMLElement | null>;
+    firstId: Signal<string | null>;
+    get(id: string): HTMLElement | null;
+}
+interface PropsAttachedElementsInternal extends PropsAttachedElements {
+    has: (id: string) => boolean;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+}
+interface 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;
+}
+interface 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;
+}
+declare const createProps: (props: CreatePropsOptions) => Props;
+interface HostProps {
+    props: Props;
+    handlers: PropHandlers;
+}
+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 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 createElementDictionary: () => {
+    ids: i0.Signal<string[]>;
+    elements: i0.Signal<HTMLElement[]>;
+    has: (id: string) => boolean;
+    get: (id: string) => HTMLElement | null;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+    isEmpty: i0.Signal<boolean>;
+    firstElement: i0.Signal<HTMLElement | null>;
+    firstId: i0.Signal<string | null>;
+};
+
+interface BindPropsOptions {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+}
+declare const bindProps: (config: BindPropsOptions) => void;
+interface UnbindPropsOptions {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+}
+declare const unbindProps: (config: UnbindPropsOptions) => void;
+
+declare class PropsDirective {
+    destroyRef: DestroyRef;
+    props: i0.InputSignalWithTransform<PropsInternal, Readonly<{
+        attached: i0.Signal<boolean>;
+        attachedElements: PropsAttachedElements;
+    }>>;
+    propHandlers: {
+        classes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: i0.Signal<unknown>) => void;
+            pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+        };
+        attributes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: i0.Signal<unknown>) => void;
+            pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+        };
+        styles: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: i0.Signal<unknown>) => void;
+            pushMany: (map: Record<string, i0.Signal<unknown>>) => void;
+        };
+        id: string;
+        elementRef: i0.ElementRef<HTMLElement>;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropsDirective, "[etProps]", never, { "props": { "alias": "etProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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;
+};
+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>;
+
+declare class ClickObserverFactory {
+    create(): Observable<MouseEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickObserverFactory>;
+}
+declare class ClickObserverService implements OnDestroy {
+    private _clickObserverFactory;
+    private _observedElements;
+    ngOnDestroy(): void;
+    observe(element: Element): Observable<MouseEvent>;
+    observe(element: ElementRef<Element>): Observable<MouseEvent>;
+    private _observeElement;
+    private _unobserveElement;
+    private _cleanupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickObserverService>;
+}
+
+declare class MutationObserverFactory {
+    create(callback: MutationCallback): MutationObserver | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MutationObserverFactory>;
+}
+declare class ContentObserverService implements OnDestroy {
+    private _mutationObserverFactory;
+    private _observedElements;
+    ngOnDestroy(): void;
+    observe(element: Element): Observable<MutationRecord[]>;
+    observe(element: ElementRef<Element>): Observable<MutationRecord[]>;
+    private _observeElement;
+    private _unobserveElement;
+    private _cleanupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContentObserverService>;
+}
+
+declare class FocusVisibleService {
+    private readonly _document;
+    private _hadKeyboardEvent;
+    get isFocusVisible(): boolean;
+    constructor();
+    onKeyDown(e: KeyboardEvent): void;
+    onPointerDown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusVisibleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusVisibleService>;
+}
+
+declare class IntersectionObserverFactory {
+    create(callback: IntersectionObserverCallback): IntersectionObserver | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntersectionObserverFactory>;
+}
+declare class IntersectionObserverService implements OnDestroy {
+    private _intersectionObserverFactory;
+    private _observedElements;
+    ngOnDestroy(): void;
+    observe(element: Element): Observable<IntersectionObserverEntry[]>;
+    observe(element: ElementRef<Element>): Observable<IntersectionObserverEntry[]>;
+    private _observeElement;
+    private _unobserveElement;
+    private _cleanupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntersectionObserverService>;
+}
+
+declare class ResizeObserverFactory {
+    create(callback: ResizeObserverCallback): ResizeObserver | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverFactory>;
+}
+declare class ResizeObserverService implements OnDestroy {
+    private _mutationObserverFactory;
+    private _observedElements;
+    ngOnDestroy(): void;
+    observe(element: Element): Observable<ResizeObserverEntry[]>;
+    observe(element: ElementRef<Element>): Observable<ResizeObserverEntry[]>;
+    private _observeElement;
+    private _unobserveElement;
+    private _cleanupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}
+
+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;
+interface 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;
+};
+declare const ET_PROPERTY_REMOVED: unique symbol;
+interface ScrollEnhancementsConfig {
+    /**
+     * The scrollable container.
+     * @default document.documentElement
+     */
+    scrollElement?: HTMLElement;
+    /**
+     * 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;
+    };
+}
+interface RouterState {
+    data: Data;
+    pathParams: Params;
+    queryParams: Params;
+    title: string | null;
+    fragment: string | null;
+}
+declare class RouterStateService {
+    private _isScrollTopOnNavigationEnabled;
+    private readonly _router;
+    private readonly _route$;
+    private readonly _state$;
+    private readonly _afterInitialize$;
+    readonly afterInitialize$: Observable<boolean>;
+    get route$(): Observable<string>;
+    get route(): string;
+    get state$(): Observable<RouterState>;
+    get state(): RouterState;
+    get data$(): Observable<Data>;
+    get data(): Data;
+    get pathParams$(): Observable<Params>;
+    get pathParams(): Params;
+    get queryParams$(): Observable<Params>;
+    get queryParams(): Params;
+    get title$(): Observable<string | null>;
+    get title(): string | null;
+    get fragment$(): Observable<string | null>;
+    get fragment(): string | null;
+    get dataChanges$(): Observable<Partial<Data>>;
+    get queryParamChanges$(): Observable<Partial<Params>>;
+    get pathParamChanges$(): Observable<Partial<Params>>;
+    constructor();
+    enableScrollEnhancements(config?: ScrollEnhancementsConfig): void;
+    selectQueryParam<T = string | undefined>(key: string): Observable<T>;
+    selectPathParam<T = string | undefined>(key: string): Observable<T>;
+    selectData<T = unknown>(key: string): Observable<T>;
+    private _findChanges;
+    private _getInitialState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouterStateService>;
+}
+
+interface Size {
+    width: number;
+    height: number;
+}
+declare class ViewportService {
+    private readonly _resizeObserverService;
+    private readonly _viewportConfig;
+    private readonly _breakpointObserver;
+    private readonly _viewportMonitorStop$;
+    private _isViewportMonitorEnabled;
+    private _isXs$;
+    private _isSm$;
+    private _isMd$;
+    private _isLg$;
+    private _isXl$;
+    private _is2Xl$;
+    private _viewportSize$;
+    private _scrollbarSize$;
+    get isXs$(): Observable<boolean>;
+    get isXs(): boolean;
+    get isSm$(): Observable<boolean>;
+    get isSm(): boolean;
+    get isMd$(): Observable<boolean>;
+    get isMd(): boolean;
+    get isLg$(): Observable<boolean>;
+    get isLg(): boolean;
+    get isXl$(): Observable<boolean>;
+    get isXl(): boolean;
+    get is2Xl$(): Observable<boolean>;
+    get is2Xl(): boolean;
+    get viewportSize$(): Observable<Size | null>;
+    get viewportSize(): Size | null;
+    get scrollbarSize$(): Observable<Size | null>;
+    get scrollbarSize(): Size | null;
+    currentViewport$: Observable<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+    get currentViewport(): "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
+    constructor();
+    observe(options: {
+        min?: number | Breakpoint;
+        max?: number | Breakpoint;
+    }): Observable<boolean>;
+    isMatched(options: {
+        min?: number | Breakpoint;
+        max?: number | Breakpoint;
+    }): boolean;
+    /**
+     * Applies size CSS variables to the documentElement in pixels.
+     * - `--et-vw`: viewport width excluding scrollbar width
+     * - `--et-vh`: viewport height excluding scrollbar height
+     * - `--et-sw`: scrollbar width
+     * - `--et-sh`: scrollbar height
+     */
+    monitorViewport(): void;
+    unmonitorViewport(): void;
+    getBreakpointSize(type: Breakpoint, option: 'min' | 'max'): number;
+    private _observeDefaultBreakpoints;
+    private _buildMediaQuery;
+    private getCurrentViewport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportService>;
+}
+
+type BuildMediaQueryOptions = {
+    min?: number | Breakpoint;
+    max?: number | Breakpoint;
+};
+
+type SelectionModelTypes = string | number | Record<string, unknown> | unknown;
+type SelectionModelPropertyPath = string;
+type SelectionModelOptionValueFn<T extends SelectionModelTypes = any> = (option: T) => unknown;
+/**
+ * You can use a property path or a function to get the value of an option. The function should be as **lightweight as possible** as it will be called **a lot**.
+ *
+ * @example
+ * // Property path
+ * "id" // option.id
+ * "user.name" // option.user.name
+ *
+ * // Function
+ * (option) => option.id // option.id
+ * (option) => option.user.name // option.user.name
+ */
+type SelectionModelBinding<T extends SelectionModelTypes = any> = SelectionModelPropertyPath | SelectionModelOptionValueFn<T>;
+declare class SelectionModel<T extends SelectionModelTypes = unknown> {
+    private readonly _destroy$;
+    private _lastSelectionSetSubscription;
+    get selection$(): Observable<T[]>;
+    get selection(): T[];
+    private readonly _selection$;
+    get options$(): Observable<T[]>;
+    get options(): T[];
+    private readonly _options$;
+    readonly optionsSignal: i0.Signal<T[] | undefined>;
+    get valueBinding$(): Observable<SelectionModelBinding<T> | null>;
+    get valueBinding(): SelectionModelBinding<T> | null;
+    private readonly _valueBinding$;
+    get keyBinding$(): Observable<SelectionModelBinding<T> | null>;
+    get keyBinding(): SelectionModelBinding<T> | null;
+    private readonly _keyBinding$;
+    get labelBinding$(): Observable<SelectionModelBinding<T> | null>;
+    get labelBinding(): SelectionModelBinding<T> | null;
+    private readonly _labelBinding$;
+    get disabledBinding$(): Observable<SelectionModelBinding<T> | null>;
+    get disabledBinding(): SelectionModelBinding<T> | null;
+    private readonly _disabledBinding$;
+    get allowMultiple$(): Observable<boolean>;
+    get allowMultiple(): boolean;
+    private readonly _allowMultiple$;
+    get filter$(): Observable<string>;
+    get filter(): string;
+    private readonly _filter$;
+    readonly value$: Observable<unknown>;
+    readonly filteredOptions$: Observable<T[]>;
+    private readonly _optionsAndSelection$;
+    constructor();
+    setSelection(selection: T | T[]): this;
+    setSelectionFromValue(value: unknown): void;
+    setSelectionFromValue$(value: unknown): void;
+    setValueBinding(fnOrPropertyPath: SelectionModelBinding<T> | null): this;
+    setKeyBinding(fnOrPropertyPath: SelectionModelBinding<T> | null): this;
+    setLabelBinding(fnOrPropertyPath: SelectionModelBinding<T> | null): this;
+    setDisabledBinding(fnOrPropertyPath: SelectionModelBinding<T> | null): this;
+    setOptions(options: T[]): this;
+    setOptionsFromQueryList(queryList: TypedQueryList<T>): this;
+    setOptionsFromQueryList$(queryList$: Observable<TypedQueryList<T> | null | undefined>): this;
+    setAllowMultiple(allowMultiple: boolean): this;
+    setFilter(filter: string | null): void;
+    reset(): void;
+    trackByOptionKey: (option: T) => unknown;
+    getOptionByValue$(value: unknown): Observable<T | undefined>;
+    getOptionByLabel$(label: string): Observable<T | undefined>;
+    getOptionByKey$(key: string): Observable<T | undefined>;
+    isSelected$(option: T): Observable<boolean>;
+    isDisabled$(option: T): Observable<boolean>;
+    getLabel$(option: T): Observable<unknown>;
+    getValue$(option: T): Observable<unknown>;
+    getKey$(option: T): Observable<unknown>;
+    getOptionByValue(value: unknown): T | undefined;
+    getOptionByLabel(label: string): T | undefined;
+    getOptionByKey(key: string): T | undefined;
+    getOption(value: unknown, propertyPath?: SelectionModelBinding<T> | null, options?: T[]): T | undefined;
+    getOptionByIndex(index: number, options?: T[]): T | null;
+    getOptionByOffset(offset: number, index: number, config?: {
+        loop?: boolean;
+        clamp?: boolean;
+        skipDisabled?: boolean;
+        options?: T[];
+    }): T | null;
+    getFirstOption(options?: T[]): T | null;
+    getLastOption(options?: T[]): T | null;
+    getOptionIndex(option: T, options?: T[]): number | null;
+    getNonMultipleSelectedOption(): T | null;
+    getNonMultipleSelectedOptionIndex(): number | null;
+    getNonMultipleOptionByOffsetFromSelected(offset: number, config?: {
+        loop?: boolean;
+        clamp?: boolean;
+    }): T | null;
+    getLabel(option: T): unknown;
+    getValue(option: T): unknown;
+    getKey(option: T): unknown;
+    getDisabled(option: T): unknown;
+    execFnOrGetOptionProperty(option: T, fnOrPropertyPath: SelectionModelBinding<T> | null): unknown;
+    execFnOrGetOptionPropertyNullable(option: T, fnOrPropertyPath: SelectionModelBinding<T> | null): unknown;
+    getOptionProperty(option: T, propertyPath: string | null): unknown;
+    isSelected(option: T): boolean;
+    isDisabled(option: T): boolean;
+    getFilteredOptions(filter?: string, options?: T[]): T[];
+    addSelectedOption(option: T): void;
+    removeSelectedOption(option: T): void;
+    clearSelectedOptions(): void;
+    toggleSelectedOption(option: T): void;
+    toggleAllSelectedOptions(): void;
+}
+
+declare class ActiveSelectionModel<T = unknown> {
+    private readonly _destroy$;
+    get selectionModel$(): rxjs.Observable<SelectionModel<T> | null>;
+    get selectionModel(): SelectionModel<T> | null;
+    private readonly _selectionModel$;
+    get activeOption$(): rxjs.Observable<T | null>;
+    get activeOption(): T | null;
+    private readonly _activeOption$;
+    constructor();
+    setSelectionModel(selectionModel: SelectionModel<T> | null): this;
+    setActiveOption(option: T | null): this;
+    isOptionActive$(option: T): rxjs.Observable<boolean>;
+    evaluateKeyboardEvent(event: KeyboardEvent, config?: {
+        skipDisabled?: boolean;
+    }): NonNullable<T> | null;
+    private _resetActiveOptions;
+}
+
+declare function switchQueryListChanges(): <T extends TypedQueryList<unknown> | null | undefined>(source: Observable<T>) => Observable<T>;
+
+declare const nextFrame: (cb: () => void) => void;
+declare const fromNextFrame: () => Observable<void>;
+declare const forceReflow: (element?: HTMLElement) => number;
+interface FlipAnimationGroupConfig {
+    /**
+     * The elements to animate
+     */
+    elements: Array<HTMLElement | {
+        element: HTMLElement;
+        originElement?: HTMLElement;
+    }>;
+    /**
+     * The duration of the animation in milliseconds
+     * @default 250
+     */
+    duration?: number;
+    /**
+     * The easing function to use for the animation
+     * @default 'cubic-bezier(0.4, 0, 0.2, 1)'
+     */
+    easing?: string;
+}
+declare const createFlipAnimationGroup: (config: FlipAnimationGroupConfig) => {
+    updateInit: () => void;
+    play: () => void;
+    cancel: () => void;
+    onStart$: Observable<void[]>;
+    onFinish$: Observable<void[]>;
+    onCancel$: Observable<void[]>;
+};
+interface FlipAnimationConfig {
+    /**
+     * The element to animate
+     */
+    element: HTMLElement;
+    /**
+     * The element to use as the origin for the animation
+     * @default element
+     */
+    originElement?: HTMLElement;
+    /**
+     * The duration of the animation in milliseconds
+     * @default 250
+     */
+    duration?: number;
+    /**
+     * The easing function to use for the animation
+     * @default 'cubic-bezier(0.4, 0, 0.2, 1)'
+     */
+    easing?: string;
+}
+declare const createFlipAnimation: (config: FlipAnimationConfig) => {
+    updateInit: () => void;
+    play: () => void;
+    cancel: () => void;
+    onStart$: Observable<void>;
+    onFinish$: Observable<void>;
+    onCancel$: Observable<void>;
+};
+
+declare const clamp: (value: number, min?: number, max?: number) => number;
+
+/**
+ * Stolen from klona to avoid adding a dependency
+ * https://github.com/lukeed/klona
+ *
+ * MIT License
+ *
+ * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare const clone: <T>(original: T) => T;
+
+declare const createComponentId: (prefix: string) => string;
+
+declare const hasCookie: (name: string) => boolean;
+declare const getCookie: (name: string) => string | null | undefined;
+declare const setCookie: (name: string, data: string, expiresInDays?: number, 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;
+
+declare const createDestroy: () => rxjs.Observable<boolean>;
+
+/**
+ * Stolen from dequal to avoid adding a dependency
+ * https://github.com/lukeed/dequal
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+declare const equal: (foo: any, bar: any) => boolean;
+
+declare const cloneFormGroup: <T extends FormGroup<any>>(formGroup: T) => T;
+declare const getFormGroupValue: <T extends FormGroup>(formGroup: T) => Record<string, unknown>;
+
+declare const injectHostElement: <T = HTMLElement>() => T;
+declare const injectTemplateRef: <C = unknown>() => TemplateRef<C>;
+
+declare const getIntersectionInfo: (intersections: IntersectionObserverEntry[]) => {
+    partial: {
+        hasAny: boolean;
+        hasMultiple: boolean;
+        first: {
+            intersection: IntersectionObserverEntry;
+            index: number;
+        };
+        last: {
+            intersection: IntersectionObserverEntry;
+            index: number;
+        };
+        biggest: {
+            intersection: IntersectionObserverEntry;
+            index: number;
+        };
+    };
+    full: {
+        hasAny: boolean;
+        hasMultiple: boolean;
+        first: {
+            index: number;
+            intersection: IntersectionObserverEntry | undefined;
+        };
+        last: {
+            index: number;
+            intersection: IntersectionObserverEntry | undefined;
+        };
+    };
+    none: {
+        first: {
+            index: number;
+            intersection: IntersectionObserverEntry | undefined;
+        };
+        last: {
+            index: number;
+            intersection: IntersectionObserverEntry | undefined;
+        };
+    };
+} | null;
+
+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;
+};
+
+declare const createMediaQueryObservable: (query: string) => Observable<{
+    matches: boolean;
+    query: string;
+}>;
+
+declare const createMutationObservable: (config: {
+    elements: HTMLElement | HTMLElement[];
+    options?: MutationObserverInit & {
+        styleIgnoreList?: string[];
+    };
+}) => Observable<MutationRecord[]>;
+
+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;
+
+type AttributeValueBinding = {
+    render: boolean;
+    value: boolean | string | number;
+};
+type AttributeRenderBinding = boolean;
+type ReactiveAttributes = {
+    attribute: string | string[];
+    observable: Observable<AttributeValueBinding | AttributeRenderBinding>;
+    eager?: boolean;
+    elementRef?: ElementRef<HTMLElement>;
+};
+interface ReactiveBindingResult {
+    reset: () => void;
+    remove: (...attributes: string[]) => void;
+    push: (value: ReactiveAttributes) => void;
+}
+/**
+ * @deprecated Use one of the following instead:
+ * - `signalHostAttributes`
+ * - `signalHostClasses`
+ * - `signalHostStyles`
+ * - `signalAttributes`
+ * - `signalClasses`
+ * - `signalStyles`
+ *
+ * Will be removed in v5.
+ */
+declare const createReactiveBindings: (...values: ReactiveAttributes[]) => ReactiveBindingResult;
+
+declare const createResizeObservable: (config: {
+    elements: HTMLElement | HTMLElement[];
+    options?: ResizeObserverOptions;
+}) => Observable<ResizeObserverEntry[]>;
+
+declare const round: (value: number, precision?: number) => number;
+
+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 elementCanScroll: (element: HTMLElement, direction?: "x" | "y") => boolean;
+interface IsElementVisibleOptions {
+    /**
+     * The element to check if it is visible inside a container.
+     */
+    element?: HTMLElement | null;
+    /**
+     * The container to check if the element is visible inside.
+     * @default document.documentElement
+     */
+    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.
+     * @default container.getBoundingClientRect()
+     */
+    containerRect?: DOMRect | null;
+    /**
+     * The element's rect. Can be supplied to reduce the amount of DOM reads.
+     * @default container.getBoundingClientRect()
+     */
+    elementRect?: DOMRect | null;
+}
+interface 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.
+     */
+    isIntersecting: boolean;
+    /**
+     * The ratio of the element that is intersecting the container.
+     */
+    intersectionRatio: number;
+    /**
+     * The element that is being checked for visibility.
+     */
+    element: HTMLElement;
+}
+declare const isElementVisible: (options: IsElementVisibleOptions) => CurrentElementVisibility | null;
+declare const getElementScrollCoordinates: (options: ScrollToElementOptions) => ScrollToOptions;
+interface ScrollToElementOptions {
+    /**
+     * The element to scroll to.
+     */
+    element?: HTMLElement | null;
+    /**
+     * The scroll container to scroll to the element in.
+     * @default document.documentElement
+     */
+    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;
+}
+declare const scrollToElement: (options: ScrollToElementOptions) => void;
+
+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<{
+    /** @deprecated Always use currentElements  */
+    currentElement: HTMLElement | null;
+    /** @deprecated Always use previousElements  */
+    previousElement: HTMLElement | null;
+    currentElements: HTMLElement[];
+    previousElements: HTMLElement[];
+}>;
+interface 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 signalIsRendered: () => Signal<boolean>;
+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;
+};
+interface 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 signalElementMutations: (el: SignalElementBindingType, options?: MutationObserverInit) => Signal<MutationRecord | null>;
+declare const signalHostElementMutations: (options?: MutationObserverInit) => Signal<MutationRecord | 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 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>;
+type SignalElementIntersectionOptions = Omit<IntersectionObserverInit, 'root'> & {
+    root?: SignalElementBindingType;
+    enabled?: Signal<boolean>;
+};
+declare const signalElementIntersection: (el: SignalElementBindingType, options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntry[]>;
+declare const signalHostElementIntersection: (options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntry[]>;
+declare const signalElementChildren: (el: SignalElementBindingType) => Signal<HTMLElement[]>;
+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) => EffectRef;
+interface ControlValueSignalOptions {
+    debounceTime?: number;
+    /**
+     * @default false
+     */
+    debounceFirst?: boolean;
+}
+declare const controlValueSignal: <T extends Signal<AbstractControl | null> | AbstractControl, J extends T extends Signal<infer I> ? I : T>(control: T, options?: ControlValueSignalOptions) => Signal<ReturnType<NonNullable<J>["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<any[] | [ReturnType<NonNullable<T extends Signal<infer I> ? I : T>["getRawValue"]> | null, ReturnType<NonNullable<T extends Signal<infer I> ? I : T>["getRawValue"]> | null]>;
+/**
+ * @deprecated Use `controlValueSignal` instead with `debounceTime` option.
+ */
+interface DebouncedControlValueSignalOptions {
+    /**
+     * @default 300
+     */
+    debounceTime?: number;
+}
+/**
+ * @deprecated Use `controlValueSignal` instead with `debounceTime` set to `300` and `debounceFirst` set to `true`.
+ */
+declare const debouncedControlValueSignal: <T extends FormControl>(control: T, options?: DebouncedControlValueSignalOptions) => Signal<ReturnType<NonNullable<T extends Signal<infer I> ? I : T>["getRawValue"]> | null>;
+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 | null>;
+/**
+ * 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<_angular_router.Params>;
+/** Inject all currently available route data as a signal */
+declare const injectRouteData: () => Signal<_angular_router.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<_angular_router.Params>;
+/** Inject a specific query parameter as a signal */
+declare const injectQueryParam: <T = string | null>(key: string, config?: InjectUtilTransformConfig<string | null, 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>;
+/**
+ * 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 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>>;
+declare const createIsRenderedSignal: () => {
+    state: WritableSignal<boolean>;
+    bind: () => EffectRef;
+};
+declare const createCanAnimateSignal: () => {
+    state: Signal<boolean>;
+};
+type ElementLastScrollDirectionType = 'up' | 'down' | 'left' | 'right';
+type ElementLastScrollDirection = {
+    type: ElementLastScrollDirectionType;
+    time: number;
+};
+declare const signalElementLastScrollDirection: (el: SignalElementBindingType) => Signal<ElementLastScrollDirection | null>;
+declare const signalHostElementLastScrollDirection: () => Signal<ElementLastScrollDirection | null>;
+type CursorDragScrollDirection = 'horizontal' | 'vertical' | 'both';
+type MaybeSignal<T> = T | Signal<T>;
+declare const maybeSignalValue: <T>(value: MaybeSignal<T>) => T;
+type CursorDragScrollOptions = {
+    /** If true, cursor drag scrolling will be enabled. */
+    enabled?: Signal<boolean>;
+    /** The allowed scroll direction. */
+    allowedDirection?: MaybeSignal<CursorDragScrollDirection>;
+};
+/** 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;
+    }>;
+};
+/**
+ * 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>;
+/** Inject a signal containing a boolean value indicating if the viewport is xs */
+declare const injectIsXs: () => Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is sm */
+declare const injectIsSm: () => Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is md */
+declare const injectIsMd: () => Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is lg */
+declare const injectIsLg: () => Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is xl */
+declare const injectIsXl: () => Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is 2xl */
+declare const injectIs2Xl: () => 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: {
+    min?: number | Breakpoint;
+    max?: number | Breakpoint;
+}) => boolean;
+/**
+ * Inject a signal containing a boolean value indicating if the viewport is matching the provided options.
+ */
+declare const injectObserveBreakpoint: (options: {
+    min?: number | Breakpoint;
+    max?: number | Breakpoint;
+}) => Signal<boolean>;
+/** Inject a signal containing the current breakpoint. */
+declare const injectCurrentBreakpoint: () => Signal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+/** Inject a signal that indicates if the user is using a portrait display */
+declare const injectIsPortrait: () => Signal<boolean>;
+/** Inject a signal that indicates if the user is using a landscape display */
+declare const injectIsLandscape: () => Signal<boolean>;
+/** Inject a signal containing the current display orientation */
+declare const injectDisplayOrientation: () => Signal<"portrait" | "landscape">;
+/** Inject a signal that indicates if the device has a touch input */
+declare const injectHasTouchInput: () => Signal<boolean>;
+/** Inject a signal that indicates if the device has a fine input (mouse or stylus)  */
+declare const injectHasPrecisionInput: () => Signal<boolean>;
+/** Inject a signal containing the current device input type */
+declare const injectDeviceInputType: () => Signal<"touch" | "mouse">;
+/** Inject a signal containing a boolean value indicating if the user can hover (eg. using a mouse) */
+declare const injectCanHover: () => Signal<boolean>;
+
+/**
+ * @deprecated Will be removed in v5. Scroll blocking for overlays is build in by default.
+ */
+declare class SmartBlockScrollStrategy implements ScrollStrategy {
+    #private;
+    private _previousHTMLStyles;
+    private _previousScrollPosition;
+    private _isEnabled;
+    private _urlSubscription;
+    private _resizeSubscription;
+    private _didNavigate;
+    attach(): void;
+    enable(): void;
+    disable(): void;
+    private _canBeEnabled;
+}
+
+declare const isPrimitiveArray: (value: unknown) => value is Array<Primitive>;
+declare const isObjectArray: (value: unknown) => value is Array<Record<string, unknown>>;
+declare const isEmptyArray: (value: unknown) => value is [];
+
+declare const provideViewportConfig: (viewportConfig: ViewportConfig) => {
+    provide: typeof VIEWPORT_CONFIG;
+    useValue: typeof viewportConfig;
+};
+
+declare const AT_LEAST_ONE_REQUIRED = "atLeastOneRequired";
+interface 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 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: _angular_forms.AbstractControl) => {
+        mustMatch: boolean;
+    } | null;
+    readonly IsEmail: (control: _angular_forms.AbstractControl) => _angular_forms.ValidationErrors | null;
+    readonly IsArrayNotEmpty: (control: _angular_forms.AbstractControl) => _angular_forms.ValidationErrors | null;
+    readonly ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => _angular_forms.ValidatorFn;
+};
+
+export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, AT_LEAST_ONE_REQUIRED, ActiveSelectionModel, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, CURSOR_DRAG_SCROLLING_CLASS, CURSOR_DRAG_SCROLLING_PREPARED_CLASS, ClickObserverFactory, ClickObserverService, ClickOutsideDirective, ContentObserverService, CursorDragScrollDirective, DEBUG_TOKEN, DEFAULT_VIEWPORT_CONFIG, DELAYABLE_TOKEN, DISABLE_LOGGER_PARAM, DebugDirective, DelayableDirective, ET_PROPERTY_REMOVED, FocusVisibleService, IS_ACTIVE_ELEMENT, IS_ARRAY_NOT_EMPTY, IS_ELEMENT, IS_EMAIL, InferMimeTypePipe, IntersectionObserverFactory, IntersectionObserverService, IsActiveElementDirective, IsArrayNotEmpty, IsElementDirective, IsEmail, KeyPressManager, LetContext, LetDirective, MUST_MATCH, MatchStateType, Memo, MustMatch, MutationObserverFactory, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, OBSERVE_SCROLL_STATE, OBSERVE_VISIBILITY_TOKEN, ObserveContentDirective, ObserveResizeDirective, ObserveScrollStateDirective, ObserveVisibilityDirective, PropsDirective, ROOT_BOUNDARY_TOKEN, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeObserverFactory, ResizeObserverService, RootBoundaryDirective, RouterStateService, RuntimeError, SCROLL_OBSERVER_FIRST_ELEMENT_CLASS, SCROLL_OBSERVER_IGNORE_TARGET_CLASS, SCROLL_OBSERVER_LAST_ELEMENT_CLASS, SCROLL_OBSERVER_OBSERVING_FIRST_ELEMENT_CLASS, SCROLL_OBSERVER_OBSERVING_LAST_ELEMENT_CLASS, SEO_DIRECTIVE_TOKEN, ScrollObserverFirstElementDirective, ScrollObserverIgnoreTargetDirective, ScrollObserverLastElementDirective, SelectionModel, SeoDirective, SmartBlockScrollStrategy, StructuredDataComponent, ToArrayPipe, TypedQueryList, VIEWPORT_CONFIG, ValidateAtLeastOneRequired, Validators, ViewportService, areScrollStatesEqual, bindProps, boundingClientRectToElementRect, buildSignalEffects, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, createCanAnimateSignal, createComponentId, createDependencyStash, createDestroy, createElementDictionary, createElementDimensions, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createMediaQueryObservable, createMutationObservable, createPropHandlers, createProps, createReactiveBindings, createResizeObservable, createSetup, debouncedControlValueSignal, deferredSignal, deleteCookie, elementCanScroll, equal, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getIntersectionInfo, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, hasCookie, inferMimeType, injectBreakpointIsMatched, injectCanHover, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsSm, injectIsXl, injectIsXs, injectObserveBreakpoint, injectPathParam, injectPathParamChanges, injectPathParams, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterState, injectTemplateRef, injectUrl, isArray, isElementVisible, isEmptyArray, isGroupMatch, isKnockoutMatch, isObject, isObjectArray, isPrimitiveArray, maybeSignalValue, mergeSeoConfig, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, previousSignalValue, provideViewportConfig, round, routerDisableScrollTop, scrollToElement, setCookie, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, signalVisibilityChangeClasses, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, transformOrReturn, unbindProps, useCursorDragScroll };
+export type { AlternateLink, AnimatedLifecycleState, AnimatedOverlayComponentBase, AnyTemplateType, BindPropsOptions, Breakpoint, BuildMediaQueryOptions, BuildSignalEffectsConfig, ComponentTemplate, ComponentTypeWithInputs, ControlValueSignalOptions, CreateLoggerConfig, CreatePropsOptions, CurrentElementVisibility, CursorDragScrollDirection, CursorDragScrollOptions, DebouncedControlValueSignalOptions, ElementDimensions, ElementLastScrollDirection, ElementLastScrollDirectionType, ElementRect, ElementScrollState, ElementSize, FacebookCard, FlipAnimationConfig, HostDirective, HostProps, InjectUtilConfig, InjectUtilTransformConfig, IsElementVisibleOptions, LogicalSize, MapLike, MaybeObservable, MaybeSignal, MemoConfig, MemoResolver, NgClassType, NgTemplateTemplate, NormalizedGameResultType, NormalizedMatchParticipant, NormalizedMatchParticipants, NormalizedMatchScore, NullableElementDimensions, ObserveVisibilityChange, ObservedScrollableChild, OpenGraph, Primitive, PropHandlers, Props, PropsAttachedElements, PropsAttachedElementsInternal, PropsInternal, ReactiveAttributes, ReactiveBindingResult, Reference, RouterDisableScrollTopConfig, RouterState, ScrollEnhancementsConfig, ScrollObserverScrollState, ScrollToElementOptions, SelectionModelBinding, SelectionModelOptionValueFn, SelectionModelPropertyPath, SelectionModelTypes, SeoConfig, SignalElementIntersectionOptions, SignalElementScrollStateOptions, Size, StringTemplate, SyncSignalOptions, TemplateRefWithContext, Translatable, TwitterCard, UnbindPropsOptions, ValidateAtLeastOneRequiredConfig, Vec2, ViewportConfig };