@ethlete/core 4.30.0 → 5.0.0-next.0

package/types/ethlete-core.d.ts

@@ -0,0 +1,2161 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewInit, Signal, ComponentRef, StaticProvider, EmbeddedViewRef, Provider, InjectOptions, TemplateRef, QueryList, InputSignal, InputSignalWithTransform, PipeTransform, TrackByFunction, ElementRef, WritableSignal, DestroyRef, Injector, RendererStyleFlags2, OnInit, OnDestroy } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import * as _ethlete_core from '@ethlete/core';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal, ComponentType } from '@angular/cdk/portal';
+import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
+import { MatchListView, ParticipantViewUnion, MatchRankingView, StageType } from '@ethlete/types';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { FormGroup, AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { Data, Params, Event as Event$1 } from '@angular/router';
+
+declare const ANIMATABLE_TOKEN: InjectionToken<AnimatableDirective>;
+type AnimationEndEvent = {
+    cancelled: boolean;
+    transitionId?: string;
+};
+declare class AnimatableDirective {
+    private parent;
+    private elementRef;
+    private animationStartSubject$;
+    private animationEndSubject$;
+    private activeAnimationCount;
+    private hostActiveAnimationCount$;
+    private pendingTransitionIds;
+    private activeBatchTransitionId;
+    animationStart$: Observable<void>;
+    animationEnd$: Observable<AnimationEndEvent>;
+    totalActiveAnimationCount$: Observable<number>;
+    isAnimating$: Observable<boolean>;
+    constructor();
+    setTransitionId(id: string): void;
+    private updateActiveAnimationCount;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatableDirective, "[etAnimatable]", ["etAnimatable"], {}, {}, never, never, true, never>;
+}
+
+declare const ANIMATED_IF_TOKEN: InjectionToken<AnimatedIfDirective>;
+declare class AnimatedIfDirective {
+    private templateRef;
+    private viewContainerRef;
+    private animatedLifecycle;
+    private hasView;
+    ifValue: _angular_core.InputSignal<unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatedIfDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatedIfDirective, "[etAnimatedIf]", never, { "ifValue": { "alias": "etAnimatedIf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const ANIMATED_LIFECYCLE_TOKEN: InjectionToken<AnimatedLifecycleDirective>;
+type AnimatedLifecycleState = 'entering' | 'entered' | 'leaving' | 'left' | 'init';
+declare class AnimatedLifecycleDirective implements AfterViewInit {
+    private destroyRef;
+    private cancelCurrentAnimation$;
+    private elementRef;
+    private animatable;
+    private renderer;
+    private element;
+    private isConstructed;
+    private transitionIdCounter;
+    private forcedAtFrameId;
+    private currentFrameId;
+    state$: BehaviorSubject<AnimatedLifecycleState>;
+    stateChange: _angular_core.OutputRef<AnimatedLifecycleState>;
+    skipNextEnter: _angular_core.ModelSignal<boolean>;
+    constructor();
+    private trackFrameId;
+    ngAfterViewInit(): void;
+    enter(): void;
+    leave(): void;
+    forceEnteredState(): void;
+    forceLeftState(): void;
+    private handleNormalTransition;
+    private handleInterruptedTransition;
+    private addClass;
+    private removeClass;
+    private removeClasses;
+    private updateState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatedLifecycleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatedLifecycleDirective, "[etAnimatedLifecycle]", ["etAnimatedLifecycle"], { "skipNextEnter": { "alias": "skipNextEnter"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "skipNextEnter": "skipNextEnterChange"; }, never, never, true, [{ directive: typeof AnimatableDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type ThemeRGBColor = `${number} ${number} ${number}`;
+type ThemeHSLColor = `${number} ${number}% ${number}%`;
+type ThemeColor = ThemeRGBColor | ThemeHSLColor;
+type ThemeColorMap = {
+    default: ThemeColor;
+    hover: ThemeColor;
+    focus?: ThemeColor;
+    active: ThemeColor;
+    disabled: ThemeColor;
+};
+type OnThemeColorMap = {
+    default: ThemeColor;
+    hover?: ThemeColor;
+    focus?: ThemeColor;
+    active?: ThemeColor;
+    disabled?: ThemeColor;
+};
+type ThemeSwatch = {
+    color: ThemeColorMap;
+    onColor: OnThemeColorMap;
+};
+type Theme = {
+    name: string;
+    isDefault?: boolean;
+    isDefaultAlt?: boolean;
+    primary: ThemeSwatch;
+    secondary?: ThemeSwatch;
+    tertiary?: ThemeSwatch;
+};
+declare const createCssThemeName: (name: string) => string;
+declare const ɵProvideColorThemes: (valueOverride?: (string | undefined)[] | undefined) => _angular_core.Provider[];
+declare const injectColorThemes: {
+    (): string[];
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): string[];
+    (options: _angular_core.InjectOptions): string[] | null;
+};
+declare const ɵProvideThemesPrefix: (valueOverride?: string | undefined) => _angular_core.Provider[];
+declare const injectThemesPrefix: {
+    (): string;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): string;
+    (options: _angular_core.InjectOptions): string | null;
+};
+declare const provideColorThemesWithTailwind4: (themes: Theme[], prefix?: string) => _angular_core.Provider[][];
+
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createSwatchCss: (swatch: string, isAlt: boolean, data: ThemeSwatch) => string;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createRootThemeCss: (themes: Theme[]) => void;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createThemeStyle: (theme: Theme, isAlt: boolean) => void;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createTailwindCssVar: (name: string | undefined) => string | null;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createTailwindRgbVar: (val: string | undefined) => string | null;
+/**
+ * @deprecated Migrate to Tailwind v4. Intent to remove in v6.
+ */
+declare const createTailwindColorThemes: (themes: Theme[], prefix?: string) => Record<string, {
+    DEFAULT: string;
+    hover: string;
+    focus: string;
+    active: string;
+    disabled: string;
+}>;
+/**
+ * @deprecated Use provideColorThemesWithTailwind4 instead after migrating to Tailwind CSS v4. Intent to remove in v6.
+ */
+declare const provideColorThemes: (themes: Theme[]) => _angular_core.Provider[][];
+
+declare const THEME_PROVIDER: InjectionToken<ProvideThemeDirective>;
+declare class ProvideThemeDirective {
+    private themes;
+    private prefix;
+    private injector;
+    private currentProviderSync;
+    mainTheme: _angular_core.InputSignal<string | null | undefined>;
+    altTheme: _angular_core.InputSignal<string | null | undefined>;
+    mainThemeName: _angular_core.Signal<string | undefined>;
+    altThemeName: _angular_core.Signal<string | undefined>;
+    protected themeClass: _angular_core.Signal<string>;
+    syncWithProvider(provider: ProvideThemeDirective): void;
+    stopSyncWithProvider(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProvideThemeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ProvideThemeDirective, "[etProvideTheme]", never, { "mainTheme": { "alias": "etProvideTheme"; "required": false; "isSignal": true; }; "altTheme": { "alias": "etProvideAltTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AnimatedOverlayComponentBase = {
+    animatedLifecycle: Signal<AnimatedLifecycleDirective | undefined>;
+    setThemeFromProvider: (provider: ProvideThemeDirective) => void;
+};
+type AnimatedOverlayMountConfig<T> = {
+    component: ComponentType<T>;
+    providers?: StaticProvider[];
+    data?: Partial<T>;
+    themeProvider?: ProvideThemeDirective | null;
+};
+type AnimatedOverlayState = 'init' | 'mounting' | 'mounted' | 'unmounting' | 'unmounted';
+declare class AnimatedOverlayDirective<T extends AnimatedOverlayComponentBase> {
+    private overlayService;
+    private injector;
+    private viewContainerRef;
+    private zone;
+    private elementRef;
+    private rootBoundary;
+    private destroyRef;
+    private floatingElCleanupFn;
+    private unmountSubscription;
+    placement: _angular_core.InputSignal<Placement | undefined>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    arrowPadding: _angular_core.InputSignal<Padding | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    shift: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoHide: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoCloseIfReferenceHidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    referenceElement: _angular_core.InputSignal<HTMLElement>;
+    mirrorWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    portal: ComponentPortal<T> | null;
+    overlayRef: OverlayRef | null;
+    componentRef: ComponentRef<T> | null;
+    beforeOpened$: Subject<void>;
+    afterOpened$: Subject<void>;
+    beforeClosed$: Subject<void>;
+    afterClosed$: Subject<void>;
+    state: _angular_core.WritableSignal<AnimatedOverlayState>;
+    isMounted: Signal<boolean>;
+    isMounting: Signal<boolean>;
+    isUnmounted: Signal<boolean>;
+    isUnmounting: Signal<boolean>;
+    canMount: Signal<boolean>;
+    canUnmount: Signal<boolean>;
+    isHidden: _angular_core.WritableSignal<boolean>;
+    isMounted$: rxjs.Observable<boolean>;
+    isMounting$: rxjs.Observable<boolean>;
+    isUnmounted$: rxjs.Observable<boolean>;
+    isUnmounting$: rxjs.Observable<boolean>;
+    canMount$: rxjs.Observable<boolean>;
+    canUnmount$: rxjs.Observable<boolean>;
+    isHidden$: rxjs.Observable<boolean>;
+    referenceElementDimensions: Signal<_ethlete_core.NullableElementDimensions>;
+    constructor();
+    mount(config: AnimatedOverlayMountConfig<T>): T | undefined;
+    unmount(): void;
+    private applyComponentData;
+    private applyThemeProvider;
+    private updateOverlaySize;
+    private setupFloatingUI;
+    private getFloatingArrow;
+    private updateFloatingPosition;
+    private buildFloatingMiddleware;
+    private applyFloatingStyles;
+    private applyArrowStyles;
+    private handleReferenceHidden;
+    private waitForRenderAndAnimate;
+    private destroy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimatedOverlayDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimatedOverlayDirective<any>, "[etAnimatedOverlay]", ["etAnimatedOverlay"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; "isSignal": true; }; "referenceElement": { "alias": "referenceElement"; "required": false; "isSignal": true; }; "mirrorWidth": { "alias": "mirrorWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const nextFrame: (cb: () => void) => void;
+declare const fromNextFrame: () => Observable<void>;
+declare const forceReflow: (element?: HTMLElement) => number;
+
+type 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$: rxjs.Observable<void[]>;
+    onFinish$: rxjs.Observable<void[]>;
+    onCancel$: rxjs.Observable<void[]>;
+};
+type 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$: rxjs.Observable<void>;
+    onFinish$: rxjs.Observable<void>;
+    onCancel$: rxjs.Observable<void>;
+};
+
+declare class ClickOutsideDirective {
+    private elementRef;
+    private document;
+    didClickOutside: _angular_core.OutputEmitterRef<MouseEvent>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[etClickOutside]", never, {}, { "didClickOutside": "etClickOutside"; }, never, never, true, never>;
+}
+
+declare class RepeatDirective {
+    private mainTemplateRef;
+    private viewContainerRef;
+    repeatCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    views: _angular_core.WritableSignal<EmbeddedViewRef<unknown>[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RepeatDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RepeatDirective, "[etRepeat]", never, { "repeatCount": { "alias": "etRepeat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const createComponentId: (prefix: string) => string;
+
+declare const createDestroy: () => rxjs.Observable<boolean>;
+
+declare const injectHostElement: <T = HTMLElement>() => T;
+declare const injectTemplateRef: <C = unknown>() => TemplateRef<C>;
+type CreateProviderOptions = {
+    /**
+     * Optional name for the provider, useful for debugging.
+     * If not provided, the name will be a generated string.
+     */
+    name?: string;
+    /**
+     * Optional existing InjectionToken to also provide the created provider under.
+     */
+    extraInjectionToken?: InjectionToken<unknown>;
+};
+type ProviderResult<T> = readonly [
+    provide: () => Provider[],
+    inject: {
+        (): T;
+        (options: InjectOptions & {
+            optional?: false;
+        }): T;
+        (options: InjectOptions): T | null;
+    },
+    token: InjectionToken<T>
+];
+type StaticProviderResult<T> = readonly [
+    provide: (valueOverride?: Partial<T>) => Provider[],
+    inject: {
+        (): T;
+        (options: InjectOptions & {
+            optional?: false;
+        }): T;
+        (options: InjectOptions): T | null;
+    },
+    token: InjectionToken<T>
+];
+type RootProviderResult<T> = readonly [
+    inject: {
+        (): T;
+        (options: InjectOptions & {
+            optional?: false;
+        }): T;
+        (options: InjectOptions): T | null;
+    },
+    token: InjectionToken<T>
+];
+declare const createProvider: <T>(factory: () => T, options?: CreateProviderOptions) => ProviderResult<T>;
+declare const createRootProvider: <T>(factory: () => T, options?: CreateProviderOptions) => ProviderResult<T>;
+declare const createStaticProvider: <T>(defaultValue?: T, options?: CreateProviderOptions) => StaticProviderResult<T>;
+declare const createStaticRootProvider: <T>(defaultValue?: T, options?: CreateProviderOptions) => StaticProviderResult<T>;
+
+declare const cloneFormGroup: <T extends FormGroup<any>>(formGroup: T) => T;
+declare const getFormGroupValue: <T extends FormGroup>(formGroup: T) => Record<string, unknown>;
+
+declare const createRxHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, options?: EventListenerOptions) => rxjs.Observable<HTMLElementEventMap[K]>;
+declare const applyHostListener: <K extends keyof HTMLElementEventMap>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, options?: EventListenerOptions) => rxjs.Subscription;
+declare const applyHostListeners: (listeners: Partial<{ [K in keyof HTMLElementEventMap]: (event: HTMLElementEventMap[K]) => void; }>, options?: EventListenerOptions) => void;
+
+declare class TypedQueryList<T> extends QueryList<T> {
+    get changes(): Observable<TypedQueryList<T>>;
+}
+declare function switchQueryListChanges(): <T extends TypedQueryList<unknown> | null | undefined>(source: Observable<T>) => Observable<T>;
+
+/**
+ * Sets the value of an input signal.
+ * See issue: https://github.com/angular/angular/issues/54782
+ */
+declare const setInputSignal: <T>(input: InputSignal<T> | InputSignalWithTransform<T, unknown>, value: T) => void;
+
+type NgClassType = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+
+declare const AT_LEAST_ONE_REQUIRED = "atLeastOneRequired";
+type ValidateAtLeastOneRequiredConfig = {
+    /**
+     * Keys of form controls to validate in the supplied form group
+     */
+    keys: string[];
+    /**
+     * If true, the value `false` will result in a validation error
+     * @default false
+     */
+    checkFalse?: boolean;
+};
+declare const ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
+declare const IS_ARRAY_NOT_EMPTY = "isArrayNotEmpty";
+declare const IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
+declare const IS_EMAIL = "isEmail";
+declare const IsEmail: (control: AbstractControl) => ValidationErrors | null;
+declare const MUST_MATCH = "mustMatch";
+declare const MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
+    mustMatch: boolean;
+} | null;
+declare const Validators: {
+    readonly MustMatch: (controlName: string, matchingControlName: string) => (formGroup: AbstractControl) => {
+        mustMatch: boolean;
+    } | null;
+    readonly IsEmail: (control: AbstractControl) => ValidationErrors | null;
+    readonly IsArrayNotEmpty: (control: AbstractControl) => ValidationErrors | null;
+    readonly ValidateAtLeastOneRequired: (config: ValidateAtLeastOneRequiredConfig) => ValidatorFn;
+};
+
+declare const clone: <T>(original: T) => T;
+declare const equal: (foo: any, bar: any) => boolean;
+
+declare const hasCookie: (name: string) => boolean;
+declare const getCookie: (name: string) => string | null | undefined;
+declare const setCookie: (name: string, data: string, expiresInDays?: number | null, domain?: string | null, path?: string, sameSite?: "strict" | "none" | "lax") => void;
+declare const deleteCookie: (name: string, path?: string, domain?: string | null) => void;
+declare const getDomain: () => string | null;
+
+type Translatable = {
+    i18n: string;
+    text: string;
+};
+
+declare class KeyPressManager {
+    readonly key: number;
+    private readonly _isKeyPressed$;
+    private readonly _keyPressCount$;
+    private readonly _stopTimeout$;
+    constructor(key: number);
+    isPressed(event: KeyboardEvent): boolean;
+    clear(): void;
+}
+
+declare const DISABLE_LOGGER_PARAM = "et-logger-quiet";
+type CreateLoggerConfig = {
+    scope: string;
+    feature: string;
+};
+declare const createLogger: (config: CreateLoggerConfig) => {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+
+declare const clamp: (value: number, min?: number, max?: number) => number;
+declare const round: (value: number, precision?: number) => number;
+
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+declare const isArray: (value: unknown) => value is unknown[];
+declare const getObjectProperty: (obj: Record<string, unknown>, prop: string) => unknown;
+
+declare const RUNTIME_ERROR_NO_DATA = "__ET_NO_DATA__";
+declare class RuntimeError<T extends number> extends Error {
+    code: T;
+    devOnly: boolean;
+    data: unknown;
+    constructor(code: T, message: null | false | string, devOnly?: boolean, data?: unknown);
+}
+declare function formatRuntimeError<T extends number>(code: T, message: null | false | string, devOnly: boolean): string;
+
+/**
+ * Checks if an element or the viewport can scroll in a given direction.
+ * @param element The element to check. If null/undefined, checks if the viewport can scroll.
+ * @param direction The direction to check. If not provided, checks both directions.
+ * @returns true if the element or viewport can scroll in the given direction.
+ */
+declare const elementCanScroll: (element?: HTMLElement | null, direction?: "x" | "y") => boolean;
+type 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.
+     * If null or undefined, uses the viewport as the container.
+     * @default null (viewport)
+     */
+    container?: HTMLElement | null;
+    /**
+     * The container's rect to check if the element is visible inside. Can be supplied to reduce the amount of DOM reads.
+     * Only used when container is provided and not null.
+     * @default container.getBoundingClientRect()
+     */
+    containerRect?: DOMRect | null;
+    /**
+     * The element's rect. Can be supplied to reduce the amount of DOM reads.
+     * @default element.getBoundingClientRect()
+     */
+    elementRect?: DOMRect | null;
+};
+type CurrentElementVisibility = {
+    /**
+     * Whether the element is visible in the inline direction.
+     */
+    inline: boolean;
+    /**
+     * Whether the element is visible in the block direction.
+     */
+    block: boolean;
+    /**
+     * The percentage of the element that is visible in the inline direction.
+     */
+    inlineIntersection: number;
+    /**
+     * The percentage of the element that is visible in the block direction.
+     */
+    blockIntersection: number;
+    /**
+     * Whether the element is intersecting the container.
+     */
+    isIntersecting: boolean;
+    /**
+     * The ratio of the element that is intersecting the container.
+     */
+    intersectionRatio: number;
+    /**
+     * The element that is being checked for visibility.
+     */
+    element: HTMLElement;
+    /**
+     * The container's rect used for the calculation.
+     */
+    containerRect: DOMRect;
+    /**
+     * The element's rect used for the calculation.
+     */
+    elementRect: DOMRect;
+};
+declare const isElementVisible: (options: IsElementVisibleOptions) => CurrentElementVisibility | null;
+declare const getElementScrollCoordinates: (options: ScrollToElementOptions) => ScrollToOptions;
+type ScrollToElementOptions = {
+    /**
+     * The element to scroll to.
+     */
+    element?: HTMLElement | null;
+    /**
+     * The scroll container to scroll to the element in.
+     * Must be provided - cannot scroll the viewport programmatically with this function.
+     */
+    container?: HTMLElement | null;
+    /**
+     * The direction to scroll in.
+     * @default 'both'
+     */
+    direction?: 'inline' | 'block' | 'both';
+    /**
+     * The origin of the element to scroll to.
+     * @default 'nearest'
+     */
+    origin?: 'start' | 'end' | 'center' | 'nearest';
+    /**
+     * 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;
+
+declare class NormalizeGameResultTypePipe implements PipeTransform {
+    transform: (type: string | null) => NormalizedGameResultType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeGameResultTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeGameResultTypePipe, "etNormalizeGameResultType", true>;
+}
+type NormalizedGameResultType = Translatable & {
+    shortCode: string;
+};
+declare const normalizeGameResultType: (type: string | null) => NormalizedGameResultType | null;
+
+declare class NormalizeMatchParticipantsPipe implements PipeTransform {
+    transform: (match: MatchListView | null) => NormalizedMatchParticipants | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchParticipantsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchParticipantsPipe, "etNormalizeMatchParticipants", true>;
+}
+type NormalizedMatchParticipants = {
+    home: NormalizedMatchParticipant | null;
+    away: NormalizedMatchParticipant | null;
+};
+type NormalizedParticipantType = 'team' | 'player' | 'unknown';
+type NormalizedMatchParticipant = ({
+    type: 'tbd';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion | null;
+} & Translatable) | {
+    type: 'participant';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion;
+} | ({
+    type: 'none';
+    participantType: NormalizedParticipantType;
+    data: ParticipantViewUnion | null;
+} & Translatable);
+declare const normalizeMatchParticipants: (match: MatchListView | null) => NormalizedMatchParticipants | null;
+declare const normalizeMatchParticipant: (match: MatchListView | null, side: "home" | "away") => NormalizedMatchParticipant | null;
+
+declare class NormalizeMatchScorePipe implements PipeTransform {
+    transform: (match: MatchListView | null | undefined) => NormalizedMatchScore | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchScorePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchScorePipe, "etNormalizeMatchScore", true>;
+}
+declare const enum MatchStateType {
+    PREPARING_ROUND = "preparingRound",
+    PRE_MATCH = "preMatch",
+    LIVE = "live",
+    POST_MATCH = "postMatch",
+    AUTO_WIN = "autoWin"
+}
+type NormalizedMatchScore = {
+    home: {
+        score: string | number | null;
+        isWinner: boolean;
+    };
+    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 class NormalizeMatchStatePipe implements PipeTransform {
+    transform: (match: MatchListView | null | undefined) => MatchStateType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchStatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchStatePipe, "etNormalizeMatchState", true>;
+}
+declare const normalizeMatchState: (match: MatchListView | null | undefined) => MatchStateType | null;
+
+declare class NormalizeMatchTypePipe implements PipeTransform {
+    transform: (matchType: StageType | null | undefined) => Translatable | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NormalizeMatchTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NormalizeMatchTypePipe, "etNormalizeMatchType", true>;
+}
+declare const normalizeMatchType: (matchType: StageType | null | undefined) => Translatable | null;
+
+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: _angular_core.ɵɵFactoryDeclaration<InferMimeTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵ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 ToArrayPipe implements PipeTransform {
+    transform: (value: number) => number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToArrayPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToArrayPipe, "toArray", true>;
+}
+declare const toArray: (value: number) => number[];
+declare const toArrayTrackByFn: TrackByFunction<number>;
+
+declare const createPropHandlers: () => {
+    classes: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    attributes: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    styles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    id: string;
+    elementRef: ElementRef<HTMLElement>;
+};
+type PropHandlers = ReturnType<typeof createPropHandlers>;
+
+type Props = Readonly<{
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElements;
+}>;
+type PropsAttachedElements = {
+    first: Signal<HTMLElement | null>;
+    firstId: Signal<string | null>;
+    get(id: string): HTMLElement | null;
+};
+type PropsAttachedElementsInternal = PropsAttachedElements & {
+    has: (id: string) => boolean;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+};
+type PropsInternal = {
+    single: boolean;
+    name: string;
+    bindId: boolean;
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElementsInternal;
+    classBindings: Record<string, Signal<unknown>> | null;
+    attributeBindings: Record<string, Signal<unknown>> | null;
+    styleBindings: Record<string, Signal<unknown>> | null;
+    staticClassBindings: string[] | null;
+    staticAttributeBindings: Record<string, unknown> | null;
+    staticStyleBindings: Record<string, unknown> | null;
+    attachEventListeners: ((context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void) | null;
+};
+type CreatePropsOptions = {
+    name: string;
+    bindId?: boolean;
+    single?: boolean;
+    classes?: Record<string, Signal<unknown>>;
+    attributes?: Record<string, Signal<unknown>>;
+    styles?: Record<string, Signal<unknown>>;
+    staticClasses?: string[];
+    staticAttributes?: Record<string, unknown>;
+    staticStyles?: Record<string, unknown>;
+    listeners?: (context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void;
+};
+declare const createProps: (props: CreatePropsOptions) => Props;
+type 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: _angular_core.Signal<string[]>;
+    elements: _angular_core.Signal<HTMLElement[]>;
+    has: (id: string) => boolean;
+    get: (id: string) => HTMLElement | null;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+    isEmpty: _angular_core.Signal<boolean>;
+    firstElement: _angular_core.Signal<HTMLElement | null>;
+    firstId: _angular_core.Signal<string | null>;
+};
+
+type BindPropsOptions = {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+};
+declare const bindProps: (config: BindPropsOptions) => void;
+type UnbindPropsOptions = {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+};
+declare const unbindProps: (config: UnbindPropsOptions) => void;
+
+declare class PropsDirective {
+    destroyRef: DestroyRef;
+    props: _angular_core.InputSignalWithTransform<PropsInternal, Readonly<{
+        attached: _angular_core.Signal<boolean>;
+        attachedElements: _ethlete_core.PropsAttachedElements;
+    }>>;
+    propHandlers: {
+        classes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        attributes: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        styles: {
+            remove: (tokens: string) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (tokens: string) => boolean;
+            push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+            pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+        };
+        id: string;
+        elementRef: _angular_core.ElementRef<HTMLElement>;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PropsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PropsDirective, "[etProps]", never, { "props": { "alias": "etProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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 const injectAngularRootElement: {
+    (): _angular_core.WritableSignal<HTMLElement | null>;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): _angular_core.WritableSignal<HTMLElement | null>;
+    (options: _angular_core.InjectOptions): _angular_core.WritableSignal<HTMLElement | null> | null;
+};
+
+declare const provideBoundaryElement: () => _angular_core.Provider[];
+declare const injectBoundaryElement: {
+    (): {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    };
+    (options: _angular_core.InjectOptions): {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    } | null;
+};
+declare const BOUNDARY_ELEMENT_TOKEN: _angular_core.InjectionToken<{
+    value: _angular_core.Signal<HTMLElement>;
+    override: _angular_core.WritableSignal<HTMLElement | null>;
+}>;
+
+type Vec2 = [number, number];
+type ViewportConfig = {
+    breakpoints: {
+        xs: Vec2;
+        sm: Vec2;
+        md: Vec2;
+        lg: Vec2;
+        xl: Vec2;
+        '2xl': Vec2;
+    };
+};
+type Breakpoint = keyof ViewportConfig['breakpoints'];
+/**
+ * Default viewport config based on Tailwind CSS.
+ * @see https://tailwindcss.com/docs/screens
+ */
+declare const DEFAULT_VIEWPORT_CONFIG: ViewportConfig;
+declare const provideViewportConfig: (valueOverride?: Partial<ViewportConfig> | undefined) => _angular_core.Provider[];
+declare const injectViewportConfig: {
+    (): ViewportConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): ViewportConfig;
+    (options: _angular_core.InjectOptions): ViewportConfig | null;
+};
+type BuildMediaQueryOptions = {
+    min?: number | Breakpoint;
+    max?: number | Breakpoint;
+};
+declare const provideBreakpointObserver: () => _angular_core.Provider[];
+declare const injectBreakpointObserver: {
+    (): {
+        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
+        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
+        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
+        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
+        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
+        isMediaQueryMatched: (mediaQuery: string) => boolean;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
+        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
+        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
+        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
+        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
+        isMediaQueryMatched: (mediaQuery: string) => boolean;
+    };
+    (options: _angular_core.InjectOptions): {
+        observeBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
+        isBreakpointMatched: (options: BuildMediaQueryOptions) => boolean;
+        getBreakpointSize: (type: Breakpoint, option: "min" | "max") => number;
+        buildMediaQueryString: (options: BuildMediaQueryOptions) => string;
+        observeMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
+        isMediaQueryMatched: (mediaQuery: string) => boolean;
+    } | null;
+};
+
+declare const provideFocusVisibleTracker: () => _angular_core.Provider[];
+declare const injectFocusVisibleTracker: {
+    (): {
+        isFocusVisible: _angular_core.Signal<boolean>;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        isFocusVisible: _angular_core.Signal<boolean>;
+    };
+    (options: _angular_core.InjectOptions): {
+        isFocusVisible: _angular_core.Signal<boolean>;
+    } | null;
+};
+declare const FOCUS_VISIBLE_TRACKER_TOKEN: _angular_core.InjectionToken<{
+    isFocusVisible: _angular_core.Signal<boolean>;
+}>;
+
+declare const provideLocale: () => _angular_core.Provider[];
+declare const injectLocale: {
+    (): {
+        currentLocale: _angular_core.WritableSignal<string>;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        currentLocale: _angular_core.WritableSignal<string>;
+    };
+    (options: _angular_core.InjectOptions): {
+        currentLocale: _angular_core.WritableSignal<string>;
+    } | null;
+};
+
+declare const provideRenderer: () => _angular_core.Provider[];
+declare const injectRenderer: {
+    (): {
+        addClass: (element: HTMLElement, ...classes: string[]) => void;
+        removeClass: (element: HTMLElement, ...classes: string[]) => void;
+        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
+        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
+        removeStyle: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration)[]) => void;
+        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
+        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
+        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
+        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
+        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
+        createText: (value: string) => Text;
+        createComment: (value: string) => Comment;
+        appendChild: (parent: HTMLElement, newChild: Node) => void;
+        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
+        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
+        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
+        parentNode: (node: Node) => Node | null;
+        nextSibling: (node: Node) => Node | null;
+        setValue: (node: Node, value: string) => void;
+        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
+        destroyNode: (node: Node) => void;
+        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
+        empty: (element: HTMLElement) => void;
+        setTextContent: (element: HTMLElement, text: string) => void;
+        setInnerHTML: (element: HTMLElement, html: string) => void;
+        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
+        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
+        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
+        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
+        renderer: _angular_core.Renderer2;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        addClass: (element: HTMLElement, ...classes: string[]) => void;
+        removeClass: (element: HTMLElement, ...classes: string[]) => void;
+        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
+        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
+        removeStyle: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration)[]) => void;
+        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
+        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
+        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
+        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
+        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
+        createText: (value: string) => Text;
+        createComment: (value: string) => Comment;
+        appendChild: (parent: HTMLElement, newChild: Node) => void;
+        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
+        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
+        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
+        parentNode: (node: Node) => Node | null;
+        nextSibling: (node: Node) => Node | null;
+        setValue: (node: Node, value: string) => void;
+        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
+        destroyNode: (node: Node) => void;
+        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
+        empty: (element: HTMLElement) => void;
+        setTextContent: (element: HTMLElement, text: string) => void;
+        setInnerHTML: (element: HTMLElement, html: string) => void;
+        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
+        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
+        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
+        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
+        renderer: _angular_core.Renderer2;
+    };
+    (options: _angular_core.InjectOptions): {
+        addClass: (element: HTMLElement, ...classes: string[]) => void;
+        removeClass: (element: HTMLElement, ...classes: string[]) => void;
+        toggleClass: (element: HTMLElement, className: string, force?: boolean) => boolean;
+        setStyle: (element: HTMLElement, style: Partial<Record<keyof CSSStyleDeclaration, string | null>>, flags?: RendererStyleFlags2) => void;
+        removeStyle: (element: HTMLElement, ...styles: (keyof CSSStyleDeclaration)[]) => void;
+        setAttribute: (element: HTMLElement, name: string, value: string | null, namespace?: string | null) => void;
+        removeAttribute: (element: HTMLElement, ...names: string[]) => void;
+        setProperty: (element: HTMLElement, name: string, value: unknown) => void;
+        setProperties: (element: HTMLElement, properties: Record<string, unknown>) => void;
+        createElement: <K extends keyof HTMLElementTagNameMap>(tagName: K, namespace?: string | null) => HTMLElementTagNameMap[K];
+        createText: (value: string) => Text;
+        createComment: (value: string) => Comment;
+        appendChild: (parent: HTMLElement, newChild: Node) => void;
+        insertBefore: (parent: Node, newChild: Node, refChild: Node | null) => void;
+        removeChild: (parent: Node, oldChild: Node, isHostElement?: boolean) => void;
+        selectRootElement: (selectorOrNode: string | HTMLElement, preserveContent?: boolean) => HTMLElement;
+        parentNode: (node: Node) => Node | null;
+        nextSibling: (node: Node) => Node | null;
+        setValue: (node: Node, value: string) => void;
+        listen: (target: HTMLElement | Window | Document | "window" | "document" | "body", eventName: string, callback: (event: Event) => boolean | void) => (() => void);
+        destroyNode: (node: Node) => void;
+        replaceChild: (parent: Node, newChild: Node, oldChild: Node) => void;
+        empty: (element: HTMLElement) => void;
+        setTextContent: (element: HTMLElement, text: string) => void;
+        setInnerHTML: (element: HTMLElement, html: string) => void;
+        setAttributes: (element: HTMLElement, attributes: Record<string, string | null>, namespace?: string | null) => void;
+        setDataAttributes: (element: HTMLElement, data: Record<string, string | null>) => void;
+        setCssProperty: (element: HTMLElement, name: string, value: string | null) => void;
+        setCssProperties: (element: HTMLElement, properties: Record<string, string | null>) => void;
+        renderer: _angular_core.Renderer2;
+    } | null;
+};
+type AngularRenderer = NonNullable<ReturnType<typeof injectRenderer>>;
+
+declare const previousSignalValue: <T>(signal: Signal<T>) => Signal<T | undefined>;
+type SyncSignalOptions = {
+    /**
+     * If true, the target signal will not be updated with the source signal's value in a sync operation.
+     * This should be set to true for signals that need to be initialized first before syncing (eg. required inputs)
+     * @default false
+     */
+    skipSyncRead?: boolean;
+    /**
+     * If true, the first time the effect will be triggered will be skipped.
+     * @default false
+     */
+    skipFirstRun?: boolean;
+};
+declare const syncSignal: <T>(from: Signal<T>, to: WritableSignal<T>, options?: SyncSignalOptions) => _angular_core.EffectRef;
+type MaybeSignal<T> = T | Signal<T>;
+declare const maybeSignalValue: <T>(value: MaybeSignal<T>) => T;
+/**
+ * A computed that will only be reactive until the source signal contains a truthy value.
+ * All subsequent changes inside the computation will be ignored.
+ */
+declare const computedTillTruthy: <T>(source: Signal<T>) => Signal<T | null>;
+/**
+ * A computed that will only be reactive until the source signal contains a falsy value.
+ * All subsequent changes inside the computation will be ignored.
+ */
+declare const computedTillFalsy: <T>(source: Signal<T>) => Signal<T | null>;
+/**
+ * A writeable signal that will be set to the provided value once all inputs are set.
+ * During that time, the signal will be set to `null`.
+ */
+declare const deferredSignal: <T extends () => unknown>(valueFn: T) => WritableSignal<ReturnType<T> | null>;
+declare const memoizeSignal: <T>(factory: () => Signal<T>) => () => Signal<T>;
+
+type SignalAnimatedNumberOptions = {
+    /**
+     * The initial value to start animating from.
+     * If not provided, the animation will start from 0
+     */
+    initialValue?: number;
+    /**
+     * Duration of the animation in milliseconds.
+     * @default 1000
+     */
+    duration?: number;
+    /**
+     * Easing function that takes a progress value (0 to 1) and returns an eased value (0 to 1).
+     * Options:
+     * - `easeLinear()`
+     * - `easeIn()`
+     * - `easeOut()`
+     * - `easeInOut()`
+     * - `easeElastic()`
+     * - `easeOutBack()`
+     * - `easeOutBackStrong()`
+     * @default easeOut()
+     */
+    easing?: (t: number) => number;
+    /**
+     * Function to round the animated value.
+     * @default (v: number) => Math.round(v)
+     */
+    round?: (value: number) => number;
+    /**
+     * Callback invoked when the animation starts.
+     */
+    onAnimationStart?: () => void;
+    /**
+     * Callback invoked when the animation ends.
+     */
+    onAnimationEnd?: () => void;
+};
+type AnimatedNumberSignal = Signal<number> & {
+    /**
+     * Starts the animation from the current value to the target value.
+     * @returns The animated signal for chaining
+     */
+    play: () => AnimatedNumberSignal;
+    /**
+     * Resets the animation to the initial value and stops any ongoing animation.
+     * @returns The animated signal for chaining
+     */
+    reset: () => AnimatedNumberSignal;
+    /**
+     * Stops the current animation at its current position.
+     * @returns The animated signal for chaining
+     */
+    stop: () => AnimatedNumberSignal;
+};
+/**
+ * Creates a signal that animates the transition of a numeric signal's value over time.
+ */
+declare const signalAnimatedNumber: (source: MaybeSignal<number>, options?: SignalAnimatedNumberOptions) => AnimatedNumberSignal;
+declare const easeLinear: (t: number) => number;
+declare const easeIn: (t: number) => number;
+declare const easeOut: (t: number) => number;
+declare const easeInOut: (t: number) => number;
+/** Elastic easing function (overshoots) */
+declare const easeElastic: (t: number) => number;
+/** Back easing function (overshoots slightly then settles) */
+declare const easeOutBack: (t: number) => number;
+/** Back easing function with more overshoot */
+declare const easeOutBackStrong: (t: number) => number;
+
+type ControlValueSignalOptions = {
+    debounceTime?: number;
+    /**
+     * @default false
+     */
+    debounceFirst?: boolean;
+};
+declare const controlValueSignal: <TControlInput extends Signal<AbstractControl | null> | AbstractControl, TControl extends TControlInput extends Signal<infer TSignalControl> ? TSignalControl : TControlInput>(control: TControlInput, options?: ControlValueSignalOptions) => Signal<ReturnType<NonNullable<TControl>["getRawValue"]> | null>;
+/**
+ * The first item in the pair is the previous value and the second item is the current value.
+ */
+declare const controlValueSignalWithPrevious: <T extends AbstractControl>(control: T, options?: ControlValueSignalOptions) => Signal<[ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null, ReturnType<NonNullable<T extends Signal<infer TSignalControl> ? TSignalControl : T>["getRawValue"]> | null]>;
+
+type SignalElementBindingComplexType = HTMLElement | ElementRef<HTMLElement> | QueryList<ElementRef<HTMLElement> | HTMLElement> | Array<ElementRef<HTMLElement> | HTMLElement> | null | undefined;
+type SignalElementBindingType = HTMLElement | ElementRef<HTMLElement> | Observable<SignalElementBindingComplexType> | Signal<SignalElementBindingComplexType> | QueryList<ElementRef<HTMLElement> | HTMLElement> | ElementSignal;
+type ElementSignal = Signal<{
+    currentElements: HTMLElement[];
+    previousElements: HTMLElement[];
+}>;
+type ElementSignalValue = ReturnType<ElementSignal>;
+declare const isElementSignal: (el: unknown) => el is ElementSignal;
+declare const createDocumentElementSignal: () => ElementSignal;
+declare const createEmptyElementSignal: () => ElementSignal;
+declare const buildElementSignal: (el: SignalElementBindingType | null | undefined) => ElementSignal;
+declare const firstElementSignal: (el: ElementSignal) => Signal<{
+    currentElement: HTMLElement | null;
+    previousElement: HTMLElement | null;
+}>;
+
+declare const signalElementChildren: (el: SignalElementBindingType) => _angular_core.Signal<HTMLElement[]>;
+
+type BuildSignalEffectsConfig<T extends Record<string, Signal<unknown>>> = {
+    /** The tokens to apply and their signal value  */
+    tokenMap: T;
+    /** This function will be invoked for elements that were removed from the signal effects */
+    cleanupFn: (el: HTMLElement, tokens: string[]) => void;
+    /** This function will be invoked for elements that were added to the signal effects or when their signal value changes */
+    updateFn: (el: HTMLElement, tokens: string[], conditionResult: unknown) => void;
+};
+declare const buildSignalEffects: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, config: BuildSignalEffectsConfig<T>) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalClasses: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, classMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostClasses: <T extends Record<string, Signal<unknown>>>(classMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalAttributes: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, attributeMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostAttributes: <T extends Record<string, Signal<unknown>>>(attributeMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalStyles: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, styleMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+declare const signalHostStyles: <T extends Record<string, Signal<unknown>>>(styleMap: T) => {
+    remove: (tokens: string) => void;
+    removeMany: (tokens: string[]) => void;
+    has: (tokens: string) => boolean;
+    push: (tokens: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
+};
+
+type LogicalSize = {
+    inlineSize: number;
+    blockSize: number;
+};
+type ElementRect = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type ElementSize = {
+    width: number;
+    height: number;
+};
+declare const boundingClientRectToElementRect: (rect: DOMRectReadOnly) => ElementRect;
+declare const createElementDimensions: (el: HTMLElement | null, rect?: DOMRect) => NullableElementDimensions;
+type ElementDimensions = {
+    rect: () => ElementRect;
+    client: ElementSize;
+    scroll: ElementSize;
+    offset: ElementSize;
+};
+type NullableElementDimensions = {
+    [K in keyof ElementDimensions]: ElementDimensions[K] | null;
+};
+declare const signalElementDimensions: (el: SignalElementBindingType) => _angular_core.Signal<NullableElementDimensions>;
+declare const signalHostElementDimensions: () => _angular_core.Signal<NullableElementDimensions>;
+
+type SignalElementIntersectionOptions = Omit<IntersectionObserverInit, 'root'> & {
+    root?: SignalElementBindingType;
+    enabled?: Signal<boolean>;
+};
+type IntersectionObserverEntryWithDetails = IntersectionObserverEntry & {
+    isAbove: boolean;
+    isBelow: boolean;
+    isLeft: boolean;
+    isRight: boolean;
+    isVisible: boolean;
+};
+declare const signalElementIntersection: (el: SignalElementBindingType, options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
+declare const signalHostElementIntersection: (options?: SignalElementIntersectionOptions) => Signal<IntersectionObserverEntryWithDetails[]>;
+
+declare const signalElementMutations: (el: SignalElementBindingType, options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
+declare const signalHostElementMutations: (options?: MutationObserverInit) => _angular_core.Signal<MutationRecord | null>;
+
+type ElementLastScrollDirectionType = 'up' | 'down' | 'left' | 'right';
+type ElementLastScrollDirection = {
+    type: ElementLastScrollDirectionType;
+    time: number;
+};
+declare const signalElementLastScrollDirection: (el: SignalElementBindingType) => _angular_core.Signal<ElementLastScrollDirection | null>;
+declare const signalHostElementLastScrollDirection: () => _angular_core.Signal<ElementLastScrollDirection | null>;
+
+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>;
+
+/** Inject a signal containing a boolean value indicating if the viewport is xs */
+declare const injectIsXs: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is sm */
+declare const injectIsSm: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is md */
+declare const injectIsMd: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is lg */
+declare const injectIsLg: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is xl */
+declare const injectIsXl: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing a boolean value indicating if the viewport is 2xl */
+declare const injectIs2Xl: () => _angular_core.Signal<boolean>;
+/**
+ * Inject a boolean value indicating if the viewport is matching the provided options.
+ * This value is not reactive. If you want to react to changes, use the {@link injectObserveBreakpoint} function instead.
+ */
+declare const injectBreakpointIsMatched: (options: BuildMediaQueryOptions) => boolean;
+/**
+ * Inject a boolean value indicating if the media query is matched.
+ * This value is not reactive. If you want to react to changes, use the {@link injectObserveMediaQuery} function instead.
+ */
+declare const injectMediaQueryIsMatched: (mediaQuery: string) => boolean;
+/**
+ * Inject a signal containing a boolean value indicating if the viewport is matching the provided options.
+ */
+declare const injectObserveBreakpoint: (options: BuildMediaQueryOptions) => _angular_core.Signal<boolean>;
+/**
+ * Inject a signal containing a boolean value indicating if the media query is matched.
+ */
+declare const injectObserveMediaQuery: (mediaQuery: string) => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current breakpoint. */
+declare const injectCurrentBreakpoint: () => _angular_core.Signal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+/** Inject a signal that indicates if the user is using a portrait display */
+declare const injectIsPortrait: () => _angular_core.Signal<boolean>;
+/** Inject a signal that indicates if the user is using a landscape display */
+declare const injectIsLandscape: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current display orientation */
+declare const injectDisplayOrientation: () => _angular_core.Signal<"portrait" | "landscape">;
+/** Inject a signal that indicates if the device has a touch input */
+declare const injectHasTouchInput: () => _angular_core.Signal<boolean>;
+/** Inject a signal that indicates if the device has a fine input (mouse or stylus)  */
+declare const injectHasPrecisionInput: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the current device input type */
+declare const injectDeviceInputType: () => _angular_core.Signal<"touch" | "mouse">;
+/** Inject a signal containing a boolean value indicating if the user can hover (eg. using a mouse) */
+declare const injectCanHover: () => _angular_core.Signal<boolean>;
+/** Inject a signal containing the viewport dimensions */
+declare const injectViewportDimensions: () => _angular_core.Signal<_ethlete_core.NullableElementDimensions>;
+/** Inject a signal containing the scrollbar dimensions. Dimensions will be 0 if scrollbars overlap the page contents (like on mobile). */
+declare const injectScrollbarDimensions: () => _angular_core.Signal<_ethlete_core.NullableElementDimensions>;
+
+/**
+ * Applies scrollbar size CSS variables to the documentElement (html tag) in pixels.
+ * - `--et-sw`: scrollbar width
+ * - `--et-sh`: scrollbar height
+ */
+declare const writeScrollbarSizeToCssVariables: () => void;
+/**
+ * Applies viewport size CSS variables to the documentElement (html tag) in pixels.
+ * - `--et-vw`: viewport width excluding scrollbar width
+ * - `--et-vh`: viewport height excluding scrollbar height
+ */
+declare const writeViewportSizeToCssVariables: () => void;
+
+type CursorDragScrollDirection = 'horizontal' | 'vertical' | 'both';
+type CursorDragScrollOptions = {
+    /** If true, cursor drag scrolling will be enabled. */
+    enabled?: Signal<boolean>;
+    /** The allowed scroll direction. */
+    allowedDirection?: MaybeSignal<CursorDragScrollDirection>;
+};
+/** A function to apply cursor drag scroll behavior to an element. */
+declare const useCursorDragScroll: (el: SignalElementBindingType, options?: CursorDragScrollOptions) => {
+    isDragging: Signal<boolean>;
+    currentDragAmount: Signal<{
+        x: number;
+        y: number;
+    }>;
+};
+
+type SetupScrollRestorationConfig = {
+    /**
+     * 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;
+    };
+};
+declare const ET_DISABLE_SCROLL_TOP: unique symbol;
+declare const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE: unique symbol;
+declare const ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE: unique symbol;
+type RouterDisableScrollTopConfig = {
+    /**
+     * Whether to disable scroll to top ONLY when navigating back to this route.
+     * @default false
+     */
+    asReturnRoute?: boolean;
+    /**
+     * Whether to disable scroll to top when a path param changes.
+     * @default false
+     */
+    onPathParamChange?: boolean;
+};
+declare const routerDisableScrollTop: (config?: RouterDisableScrollTopConfig) => {
+    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
+    [ET_DISABLE_SCROLL_TOP]: boolean;
+} | {
+    [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]?: boolean | undefined;
+    [ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE]: boolean;
+};
+declare const setupScrollRestoration: (config?: SetupScrollRestorationConfig) => void;
+
+declare const signalIsRendered: () => _angular_core.Signal<boolean>;
+declare const createIsRenderedSignal: () => {
+    state: _angular_core.WritableSignal<boolean>;
+    bind: () => _angular_core.EffectRef;
+};
+declare const createCanAnimateSignal: () => {
+    state: _angular_core.Signal<boolean>;
+};
+
+type RouterState = {
+    data: Data;
+    pathParams: Params;
+    queryParams: Params;
+    title: string | null;
+    fragment: string | null;
+};
+declare const ET_PROPERTY_REMOVED: unique symbol;
+type InjectUtilConfig = {
+    /** The injector to use for the injection. Must be provided if the function is not called from within a injection context. */
+    injector?: Injector;
+};
+type InjectUtilTransformConfig<In, Out> = {
+    /**
+     * A transform function similar to the `transform` function in Angular input bindings.
+     * Can be used to transform the value before it is returned.
+     * E.g. transforming `"true"` to `true` for a boolean attribute.
+     */
+    transform?: (value: In) => Out;
+};
+declare const transformOrReturn: <In, Out>(src: Signal<In>, config?: InjectUtilTransformConfig<In, Out>) => Signal<Out>;
+/** Inject the current router event */
+declare const injectRouterEvent: () => Signal<Event$1>;
+/**
+ * Signal that indicates whether the router has been initialized.
+ * The router is considered initialized once the first NavigationEnd event with an id different than -1 has been emitted.
+ */
+declare const injectIsRouterInitialized: () => Signal<boolean>;
+/**
+ * Inject the current url.
+ * The url includes query params as well as the fragment. Use `injectRoute` instead if you are not intrusted in those.
+ * @example "/my-page?query=1&param=true#fragment"
+ */
+declare const injectUrl: () => Signal<string>;
+/**
+ * Inject the current route
+ * @example "/my-page"
+ */
+declare const injectRoute: () => Signal<string>;
+/**
+ * Inject the complete router state. This includes the current route data, path params, query params, title and fragment.
+ */
+declare const injectRouterState: () => Signal<RouterState>;
+/** Inject a signal containing the current route fragment (the part after the # inside the url if present) */
+declare const injectFragment: <T = string | null>(config?: InjectUtilConfig & InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+/** Inject all currently available query parameters as a signal */
+declare const injectQueryParams: () => Signal<Params>;
+/** Inject all currently available route data as a signal */
+declare const injectRouteData: () => Signal<Data>;
+/** Inject the current route title as a signal */
+declare const injectRouteTitle: <T = string | null>(config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+/** Inject all currently available path parameters as a signal */
+declare const injectPathParams: () => Signal<Params>;
+type InjectQueryParamConfig<T> = InjectUtilTransformConfig<string | null, T> & {
+    /**
+     * If true, the initial value will be read from the browser's url.
+     * Note that this will not work with arrays or complex objects.
+     */
+    requireSync?: boolean;
+};
+/** Inject a specific query parameter as a signal */
+declare const injectQueryParam: <T = string | null>(key: string, config?: InjectQueryParamConfig<T>) => Signal<T>;
+/** Inject a specific route data item as a signal */
+declare const injectRouteDataItem: <T = unknown>(key: string, config?: InjectUtilTransformConfig<unknown, T>) => Signal<T>;
+/** Inject a specific path parameter as a signal */
+declare const injectPathParam: <T = string | null>(key: string, config?: InjectUtilTransformConfig<string | null, T>) => Signal<T>;
+/**
+ * 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>>;
+
+type HeadBinding<T> = {
+    id: symbol;
+    value: T;
+    priority?: number;
+};
+declare const applyHeadBinding: <T>(binding: MaybeSignal<T | null | undefined>, applyFn: (value: T) => void, removeFn: () => void, isValid?: (value: T | null | undefined) => value is T) => void;
+declare const createPropertyBinding: <TConfig>(configBuilder: (value: string) => TConfig, applyConfigFn: (config: MaybeSignal<TConfig | null | undefined>) => void) => (binding: MaybeSignal<string | null | undefined>) => void;
+declare const createArrayPropertyBinding: <TConfig>(configBuilder: (value: string, index: number) => TConfig, applyConfigFn: (config: MaybeSignal<TConfig | null | undefined>) => void) => (binding: MaybeSignal<string[] | null | undefined>) => void;
+declare const toStringBinding: (binding: MaybeSignal<string | number | null | undefined>) => MaybeSignal<string | null | undefined>;
+declare const createBulkPropertyBinding: <TConfig extends Record<string, unknown>>(propertyPrefix: string, applyConfigFn: (property: string, binding: MaybeSignal<string | null | undefined>) => void) => (config: TConfig) => void;
+
+type Context = {
+    '@context': 'https://schema.org';
+};
+type Thing = {
+    '@type': string;
+    name?: string;
+    description?: string;
+    url?: string;
+    image?: string | string[];
+};
+type Organization = Thing & {
+    '@type': 'Organization';
+    logo?: string;
+    email?: string;
+    telephone?: string;
+    address?: PostalAddress;
+};
+type Person = Thing & {
+    '@type': 'Person';
+    givenName?: string;
+    familyName?: string;
+    email?: string;
+    jobTitle?: string;
+};
+type Article = Thing & {
+    '@type': 'Article';
+    headline?: string;
+    author?: Person | Organization;
+    datePublished?: string;
+    dateModified?: string;
+};
+type WebPage = Thing & {
+    '@type': 'WebPage';
+    headline?: string;
+    author?: Person | Organization;
+    datePublished?: string;
+};
+type PostalAddress = {
+    '@type': 'PostalAddress';
+    streetAddress?: string;
+    addressLocality?: string;
+    addressRegion?: string;
+    postalCode?: string;
+    addressCountry?: string;
+};
+type BreadcrumbList = Thing & {
+    '@type': 'BreadcrumbList';
+    itemListElement: ListItem[];
+};
+type ListItem = {
+    '@type': 'ListItem';
+    position: number;
+    name: string;
+    item?: string;
+};
+type SportsEvent = Thing & {
+    '@type': 'SportsEvent';
+    startDate?: string;
+    endDate?: string;
+    location?: Place;
+    competitor?: SportsTeam | Person;
+    organizer?: Organization | Person;
+    sport?: string;
+};
+type SportsTeam = Organization & {
+    '@type': 'SportsTeam';
+    athlete?: Person[];
+    coach?: Person;
+    memberOf?: SportsOrganization;
+};
+type SportsOrganization = Organization & {
+    '@type': 'SportsOrganization';
+    sport?: string;
+};
+type Place = Thing & {
+    '@type': 'Place';
+    address?: PostalAddress;
+};
+type VideoGame = Thing & {
+    '@type': 'VideoGame';
+    genre?: string;
+    publisher?: Organization;
+    gamePlatform?: string | string[];
+    playMode?: string;
+};
+type VideoGameSeries = Thing & {
+    '@type': 'VideoGameSeries';
+    containsSeason?: CreativeWorkSeason[];
+};
+type CreativeWorkSeason = Thing & {
+    '@type': 'CreativeWorkSeason';
+    seasonNumber?: number;
+    startDate?: string;
+    endDate?: string;
+};
+type SportsActivityLocation = Place & {
+    '@type': 'SportsActivityLocation';
+};
+type WithContext<T extends Thing> = T & Context;
+type Graph = {
+    '@context': 'https://schema.org';
+    '@graph': Thing[];
+};
+
+type jsonLd_d_Article = Article;
+type jsonLd_d_BreadcrumbList = BreadcrumbList;
+type jsonLd_d_Context = Context;
+type jsonLd_d_CreativeWorkSeason = CreativeWorkSeason;
+type jsonLd_d_Graph = Graph;
+type jsonLd_d_ListItem = ListItem;
+type jsonLd_d_Organization = Organization;
+type jsonLd_d_Person = Person;
+type jsonLd_d_Place = Place;
+type jsonLd_d_PostalAddress = PostalAddress;
+type jsonLd_d_SportsActivityLocation = SportsActivityLocation;
+type jsonLd_d_SportsEvent = SportsEvent;
+type jsonLd_d_SportsOrganization = SportsOrganization;
+type jsonLd_d_SportsTeam = SportsTeam;
+type jsonLd_d_Thing = Thing;
+type jsonLd_d_VideoGame = VideoGame;
+type jsonLd_d_VideoGameSeries = VideoGameSeries;
+type jsonLd_d_WebPage = WebPage;
+type jsonLd_d_WithContext<T extends Thing> = WithContext<T>;
+declare namespace jsonLd_d {
+  export type { jsonLd_d_Article as Article, jsonLd_d_BreadcrumbList as BreadcrumbList, jsonLd_d_Context as Context, jsonLd_d_CreativeWorkSeason as CreativeWorkSeason, jsonLd_d_Graph as Graph, jsonLd_d_ListItem as ListItem, jsonLd_d_Organization as Organization, jsonLd_d_Person as Person, jsonLd_d_Place as Place, jsonLd_d_PostalAddress as PostalAddress, jsonLd_d_SportsActivityLocation as SportsActivityLocation, jsonLd_d_SportsEvent as SportsEvent, jsonLd_d_SportsOrganization as SportsOrganization, jsonLd_d_SportsTeam as SportsTeam, jsonLd_d_Thing as Thing, jsonLd_d_VideoGame as VideoGame, jsonLd_d_VideoGameSeries as VideoGameSeries, jsonLd_d_WebPage as WebPage, jsonLd_d_WithContext as WithContext };
+}
+
+type LinkConfig = {
+    rel: string;
+    href: string;
+    hreflang?: string;
+    type?: string;
+    sizes?: string;
+    media?: string;
+    as?: string;
+    crossorigin?: string;
+    integrity?: string;
+    referrerpolicy?: string;
+    /** Unique identifier for the link */
+    key?: string;
+    /** Whether multiple instances of this link are allowed */
+    allowMultiple?: boolean;
+};
+type LinkStoreConfig = {
+    /**
+     * Link rels that are allowed to have multiple instances
+     * If you want to override the default set, extend your set from {@link DEFAULT_MULTI_INSTANCE_RELS}.
+     * Otherwise, common multiple instance links may be removed unintentionally.
+     * @example
+     * ```ts
+     * import { DEFAULT_MULTI_INSTANCE_RELS, provideLinkStoreConfig } from '@ethlete/core';
+     *
+     * provideLinkStoreConfig({
+     *   multiInstanceRels: new Set([
+     *     ...DEFAULT_MULTI_INSTANCE_RELS,
+     *     'custom-rel',
+     *   ]),
+     * });
+     * ```
+     */
+    multiInstanceRels: Set<string>;
+};
+declare const DEFAULT_MULTI_INSTANCE_RELS: Set<string>;
+declare const provideLinkStoreConfig: (valueOverride?: Partial<LinkStoreConfig> | undefined) => _angular_core.Provider[];
+declare const injectLinkStoreConfig: {
+    (): LinkStoreConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): LinkStoreConfig;
+    (options: _angular_core.InjectOptions): LinkStoreConfig | null;
+};
+declare const provideLinkStore: () => _angular_core.Provider[];
+declare const injectLinkStore: {
+    (): {
+        addLink: (id: symbol, linkConfig: LinkConfig) => void;
+        removeLink: (id: symbol, key?: string) => void;
+        getLinkKey: (linkConfig: LinkConfig) => string;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        addLink: (id: symbol, linkConfig: LinkConfig) => void;
+        removeLink: (id: symbol, key?: string) => void;
+        getLinkKey: (linkConfig: LinkConfig) => string;
+    };
+    (options: _angular_core.InjectOptions): {
+        addLink: (id: symbol, linkConfig: LinkConfig) => void;
+        removeLink: (id: symbol, key?: string) => void;
+        getLinkKey: (linkConfig: LinkConfig) => string;
+    } | null;
+};
+declare const applyLinkBinding: (binding: MaybeSignal<LinkConfig | null | undefined>) => void;
+declare const applyCanonicalBinding: (binding: MaybeSignal<string | null | undefined>) => void;
+declare const applyAlternateBinding: (hreflang: string, binding: MaybeSignal<string | null | undefined>) => void;
+type AlternateLanguagesConfig = {
+    [hreflang: string]: MaybeSignal<string | null | undefined>;
+};
+declare const applyAlternateLanguagesBindings: (config: AlternateLanguagesConfig) => void;
+declare const applyPrevBinding: (binding: MaybeSignal<string | null | undefined>) => void;
+declare const applyNextBinding: (binding: MaybeSignal<string | null | undefined>) => void;
+type ResourceHintsConfig = {
+    preconnect?: MaybeSignal<string[] | null | undefined>;
+    dnsPrefetch?: MaybeSignal<string[] | null | undefined>;
+    prefetch?: MaybeSignal<string[] | null | undefined>;
+    prerender?: MaybeSignal<string[] | null | undefined>;
+};
+declare const applyResourceHintsBindings: (config: ResourceHintsConfig) => void;
+
+type MetaTagConfig = {
+    /** Unique identifier for the tag  */
+    key?: string;
+    /** Whether multiple instances of this tag are allowed */
+    allowMultiple?: boolean;
+    charset?: string;
+    content?: string;
+    httpEquiv?: string;
+    id?: string;
+    itemprop?: string;
+    name?: string;
+    property?: string;
+    scheme?: string;
+    url?: string;
+};
+type MetaConfig = {
+    /**
+     * A function to transform meta tag content based on locale.
+     * Use `provideLocale()` to update the locale dynamically.
+     */
+    transformer: (content: string, locale: string) => string;
+    /**
+     * Tags that are allowed to have multiple instances
+     * If you want to override the default set, extend your set from {@link DEFAULT_MULTI_INSTANCE_TAGS}.
+     * Otherwise, common multiple instance tags may be removed unintentionally.
+     * @example
+     * ```ts
+     * import { DEFAULT_MULTI_INSTANCE_TAGS, provideMetaConfig } from '@ethlete/core';
+     *
+     * provideMetaConfig({
+     *   multiInstanceTags: new Set([
+     *     ...DEFAULT_MULTI_INSTANCE_TAGS,
+     *     'name="custom-multiple-tag"',
+     *   ]),
+     * });
+     * ```
+     */
+    multiInstanceTags: Set<string>;
+};
+declare const DEFAULT_MULTI_INSTANCE_TAGS: Set<string>;
+declare const provideMetaConfig: (valueOverride?: Partial<MetaConfig> | undefined) => _angular_core.Provider[];
+declare const injectMetaConfig: {
+    (): MetaConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): MetaConfig;
+    (options: _angular_core.InjectOptions): MetaConfig | null;
+};
+declare const provideMetaStore: () => _angular_core.Provider[];
+declare const injectMetaStore: {
+    (): {
+        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
+        removeTag: (id: symbol, selector?: string) => void;
+        getSelector: (config: MetaTagConfig) => string;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
+        removeTag: (id: symbol, selector?: string) => void;
+        getSelector: (config: MetaTagConfig) => string;
+    };
+    (options: _angular_core.InjectOptions): {
+        addTag: (id: symbol, rawConfig: MetaTagConfig) => void;
+        removeTag: (id: symbol, selector?: string) => void;
+        getSelector: (config: MetaTagConfig) => string;
+    } | null;
+};
+declare const applyMetaBinding: (binding: MaybeSignal<MetaTagConfig | null | undefined>) => void;
+declare const applyDescriptionBinding: (binding: MaybeSignal<string | null | undefined>) => void;
+declare const applyKeywordsBinding: (binding: MaybeSignal<string[] | null | undefined>) => void;
+declare const applyAuthorBinding: (binding: MaybeSignal<string | null | undefined>) => void;
+type RobotsConfig = {
+    index?: boolean;
+    follow?: boolean;
+    noarchive?: boolean;
+    nosnippet?: boolean;
+    noimageindex?: boolean;
+    maxSnippet?: number;
+    maxImagePreview?: 'none' | 'standard' | 'large';
+    maxVideoPreview?: number;
+};
+declare const applyRobotsBinding: (binding: MaybeSignal<RobotsConfig | null | undefined>) => void;
+declare const applyOgBinding: (property: string, binding: MaybeSignal<string | null | undefined>) => void;
+type OpenGraphConfig = {
+    title?: MaybeSignal<string | null | undefined>;
+    description?: MaybeSignal<string | null | undefined>;
+    url?: MaybeSignal<string | null | undefined>;
+    type?: MaybeSignal<string | null | undefined>;
+    siteName?: MaybeSignal<string | null | undefined>;
+    locale?: MaybeSignal<string | null | undefined>;
+    image?: MaybeSignal<string | null | undefined>;
+    images?: MaybeSignal<string[] | null | undefined>;
+    imageUrl?: MaybeSignal<string | null | undefined>;
+    imageSecureUrl?: MaybeSignal<string | null | undefined>;
+    imageType?: MaybeSignal<string | null | undefined>;
+    imageWidth?: MaybeSignal<string | number | null | undefined>;
+    imageHeight?: MaybeSignal<string | number | null | undefined>;
+    imageAlt?: MaybeSignal<string | null | undefined>;
+    video?: MaybeSignal<string | null | undefined>;
+    videos?: MaybeSignal<string[] | null | undefined>;
+    videoUrl?: MaybeSignal<string | null | undefined>;
+    videoSecureUrl?: MaybeSignal<string | null | undefined>;
+    videoType?: MaybeSignal<string | null | undefined>;
+    videoWidth?: MaybeSignal<string | number | null | undefined>;
+    videoHeight?: MaybeSignal<string | number | null | undefined>;
+    audio?: MaybeSignal<string | null | undefined>;
+    audios?: MaybeSignal<string[] | null | undefined>;
+};
+declare const applyOpenGraphBindings: (config: OpenGraphConfig) => void;
+type TwitterCardConfig = {
+    card?: MaybeSignal<'summary' | 'summary_large_image' | 'app' | 'player' | null | undefined>;
+    site?: MaybeSignal<string | null | undefined>;
+    siteId?: MaybeSignal<string | null | undefined>;
+    creator?: MaybeSignal<string | null | undefined>;
+    creatorId?: MaybeSignal<string | null | undefined>;
+    title?: MaybeSignal<string | null | undefined>;
+    description?: MaybeSignal<string | null | undefined>;
+    image?: MaybeSignal<string | null | undefined>;
+    images?: MaybeSignal<string[] | null | undefined>;
+    imageAlt?: MaybeSignal<string | null | undefined>;
+    player?: MaybeSignal<string | null | undefined>;
+    playerWidth?: MaybeSignal<string | number | null | undefined>;
+    playerHeight?: MaybeSignal<string | number | null | undefined>;
+    playerStream?: MaybeSignal<string | null | undefined>;
+};
+declare const applyTwitterCardBindings: (config: TwitterCardConfig) => void;
+type ArticleConfig = {
+    publishedTime?: MaybeSignal<string | null | undefined>;
+    modifiedTime?: MaybeSignal<string | null | undefined>;
+    expirationTime?: MaybeSignal<string | null | undefined>;
+    author?: MaybeSignal<string | null | undefined>;
+    authors?: MaybeSignal<string[] | null | undefined>;
+    section?: MaybeSignal<string | null | undefined>;
+    tag?: MaybeSignal<string | null | undefined>;
+    tags?: MaybeSignal<string[] | null | undefined>;
+};
+declare const applyArticleBindings: (config: ArticleConfig) => void;
+type SocialMediaConfig = {
+    title?: MaybeSignal<string | null | undefined>;
+    description?: MaybeSignal<string | null | undefined>;
+    image?: MaybeSignal<string | null | undefined>;
+    url?: MaybeSignal<string | null | undefined>;
+    openGraph?: Partial<OpenGraphConfig>;
+    twitter?: Partial<TwitterCardConfig>;
+    article?: Partial<ArticleConfig>;
+};
+declare const applySocialMediaBindings: (config: SocialMediaConfig) => void;
+
+type MaybeObservable<T> = T | Observable<T>;
+type SeoConfig = {
+    title?: MaybeObservable<string>;
+    description?: MaybeObservable<string>;
+    keywords?: MaybeObservable<string[]>;
+    icon?: MaybeObservable<string>;
+    themeColor?: MaybeObservable<string>;
+    colorScheme?: MaybeObservable<'light' | 'dark'>;
+    robots?: MaybeObservable<string>;
+    canonical?: MaybeObservable<string>;
+    alternate?: MaybeObservable<AlternateLink>[];
+    og?: MaybeObservable<OpenGraph>;
+    twitter?: MaybeObservable<TwitterCard>;
+    facebook?: MaybeObservable<FacebookCard>;
+    [key: string]: MaybeObservable<unknown>;
+};
+type AlternateLink = {
+    href: string;
+    hreflang: string;
+};
+type OpenGraph = {
+    title?: MaybeObservable<string>;
+    description?: MaybeObservable<string>;
+    type?: MaybeObservable<string>;
+    url?: MaybeObservable<string>;
+    image?: MaybeObservable<string>;
+    siteName?: MaybeObservable<string>;
+    locale?: MaybeObservable<string>;
+    localeAlternate?: MaybeObservable<string[]>;
+};
+type TwitterCard = {
+    card?: MaybeObservable<string>;
+    site?: MaybeObservable<string>;
+    creator?: MaybeObservable<string>;
+    title?: MaybeObservable<string>;
+    description?: MaybeObservable<string>;
+    image?: MaybeObservable<string>;
+    imageAlt?: MaybeObservable<string>;
+};
+type FacebookCard = {
+    title?: MaybeObservable<string>;
+    description?: MaybeObservable<string>;
+    image?: MaybeObservable<string>;
+    imageAlt?: MaybeObservable<string>;
+    type?: MaybeObservable<string>;
+    url?: MaybeObservable<string>;
+    siteName?: MaybeObservable<string>;
+    locale?: MaybeObservable<string>;
+    localeAlternate?: MaybeObservable<string[]>;
+};
+
+declare const SEO_DIRECTIVE_TOKEN: InjectionToken<SeoDirective>;
+/** @deprecated use binding utils instead */
+declare class SeoDirective implements OnInit, OnDestroy {
+    private readonly _metaService;
+    private readonly _titleService;
+    private readonly _onDeactivate$;
+    private _isDeactivated;
+    readonly parent: SeoDirective | null;
+    get config(): SeoConfig;
+    private _config;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updateConfig(config: SeoConfig): void;
+    _activate(): void;
+    _deactivate(): void;
+    private _update;
+    private _cleanUp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeoDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SeoDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type StructuredDataConfig = {
+    /**
+     * Where to place the JSON-LD script tag.
+     * - 'head': Traditional placement, loaded before body content
+     * - 'body': Google recommended, better for performance
+     *
+     * Note: You can also use the `StructuredDataComponent` to place structured data
+     * directly within your component templates.
+     *
+     * @default 'body'
+     */
+    placement: 'head' | 'body';
+};
+declare const provideStructuredDataConfig: (valueOverride?: Partial<StructuredDataConfig> | undefined) => _angular_core.Provider[];
+declare const injectStructuredDataConfig: {
+    (): StructuredDataConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StructuredDataConfig;
+    (options: _angular_core.InjectOptions): StructuredDataConfig | null;
+};
+declare const provideStructuredDataStore: () => _angular_core.Provider[];
+declare const injectStructuredDataStore: {
+    (): {
+        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
+        removeStructuredData: (id: symbol) => void;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
+        removeStructuredData: (id: symbol) => void;
+    };
+    (options: _angular_core.InjectOptions): {
+        addStructuredData: (id: symbol, data: WithContext<Thing> | Graph) => void;
+        removeStructuredData: (id: symbol) => void;
+    } | null;
+};
+declare const applyStructuredDataBinding: (binding: MaybeSignal<WithContext<Thing> | Graph | null | undefined>) => void;
+
+declare class StructuredDataComponent {
+    private sanitizer;
+    data: _angular_core.InputSignal<Graph | WithContext<Thing> | null | undefined>;
+    jsonLD: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StructuredDataComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StructuredDataComponent, "et-structured-data", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TitlePart = {
+    /** The text to be displayed as the title */
+    text: string;
+    /** Whether this part should be used as the starting point for the title construction */
+    useAsStart?: boolean;
+};
+type TitleConfig = {
+    /**
+     * The divider string used between title parts
+     * @default '|'
+     */
+    divider: string;
+    /** The default title to use when no parts are available */
+    defaultTitle: string;
+    /**
+     * A function to transform the title text based on locale.
+     * Use `provideLocale()` to update the locale dynamically.
+     */
+    transformer: (title: string, locale: string) => string;
+    /**
+     * A title part to be prefixed to all titles
+     */
+    suffixPart?: TitlePart;
+    /**
+     * A title part to be suffixed to all titles
+     */
+    prefixPart?: TitlePart;
+};
+declare const provideTitleConfig: (valueOverride?: Partial<TitleConfig> | undefined) => _angular_core.Provider[];
+declare const injectTitleConfig: {
+    (): TitleConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): TitleConfig;
+    (options: _angular_core.InjectOptions): TitleConfig | null;
+};
+declare const provideTitleStore: () => _angular_core.Provider[];
+declare const injectTitleStore: {
+    (): {
+        title: _angular_core.Signal<string>;
+        addPart: (id: symbol, part: TitlePart) => void;
+        removePart: (id: symbol) => void;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        title: _angular_core.Signal<string>;
+        addPart: (id: symbol, part: TitlePart) => void;
+        removePart: (id: symbol) => void;
+    };
+    (options: _angular_core.InjectOptions): {
+        title: _angular_core.Signal<string>;
+        addPart: (id: symbol, part: TitlePart) => void;
+        removePart: (id: symbol) => void;
+    } | null;
+};
+declare const applyHeadTitleBinding: (binding: MaybeSignal<string | number | null | undefined>, options?: Omit<TitlePart, "text">) => void;
+
+export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, BOUNDARY_ELEMENT_TOKEN, ClickOutsideDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUS_VISIBLE_TRACKER_TOKEN, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, IsArrayNotEmpty, IsEmail, jsonLd_d as JsonLD, KeyPressManager, MUST_MATCH, MatchStateType, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideThemeDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, RuntimeError, SEO_DIRECTIVE_TOKEN, SeoDirective, StructuredDataComponent, THEME_PROVIDER, ToArrayPipe, TypedQueryList, ValidateAtLeastOneRequired, Validators, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyDescriptionBinding, applyHeadBinding, applyHeadTitleBinding, applyHostListener, applyHostListeners, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boundingClientRectToElementRect, buildElementSignal, buildSignalEffects, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, createArrayPropertyBinding, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssThemeName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createPropHandlers, createPropertyBinding, createProps, createProvider, createRootProvider, createRootThemeCss, createRxHostListener, createSetup, createStaticProvider, createStaticRootProvider, createSwatchCss, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, deferredSignal, deleteCookie, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, equal, firstElementSignal, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, hasCookie, inferMimeType, injectAngularRootElement, injectBoundaryElement, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectPathParam, injectPathParamChanges, injectPathParams, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectTemplateRef, injectThemesPrefix, injectTitleConfig, injectTitleStore, injectUrl, injectViewportConfig, injectViewportDimensions, isArray, isElementSignal, isElementVisible, isGroupMatch, isKnockoutMatch, isObject, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, previousSignalValue, provideBoundaryElement, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideTitleConfig, provideTitleStore, provideViewportConfig, round, routerDisableScrollTop, scrollToElement, setCookie, setInputSignal, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toStringBinding, transformOrReturn, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideThemesPrefix };
+export type { AlternateLanguagesConfig, AlternateLink, AngularRenderer, AnimatedLifecycleState, AnimatedNumberSignal, AnimatedOverlayComponentBase, AnimatedOverlayMountConfig, AnimatedOverlayState, AnimationEndEvent, AnyTemplateType, ArticleConfig, BindPropsOptions, Breakpoint, BuildMediaQueryOptions, BuildSignalEffectsConfig, ComponentTemplate, ComponentTypeWithInputs, ControlValueSignalOptions, CreateLoggerConfig, CreatePropsOptions, CreateProviderOptions, CurrentElementVisibility, CursorDragScrollDirection, CursorDragScrollOptions, ElementDimensions, ElementLastScrollDirection, ElementLastScrollDirectionType, ElementRect, ElementScrollState, ElementSignal, ElementSignalValue, ElementSize, FacebookCard, FlipAnimationConfig, HeadBinding, HostProps, InjectQueryParamConfig, InjectUtilConfig, InjectUtilTransformConfig, IntersectionObserverEntryWithDetails, IsElementVisibleOptions, LinkConfig, LinkStoreConfig, LogicalSize, MaybeObservable, MaybeSignal, MetaConfig, MetaTagConfig, NgClassType, NgTemplateTemplate, NormalizedGameResultType, NormalizedMatchParticipant, NormalizedMatchParticipants, NormalizedMatchScore, NullableElementDimensions, OnThemeColorMap, OpenGraph, OpenGraphConfig, PropHandlers, Props, PropsAttachedElements, PropsAttachedElementsInternal, PropsInternal, ProviderResult, ResourceHintsConfig, RobotsConfig, RootProviderResult, RouterDisableScrollTopConfig, RouterState, ScrollToElementOptions, SeoConfig, SetupScrollRestorationConfig, SignalAnimatedNumberOptions, SignalElementBindingComplexType, SignalElementBindingType, SignalElementIntersectionOptions, SignalElementScrollStateOptions, SocialMediaConfig, StaticProviderResult, StringTemplate, StructuredDataConfig, SyncSignalOptions, TemplateRefWithContext, Theme, ThemeColor, ThemeColorMap, ThemeHSLColor, ThemeRGBColor, ThemeSwatch, TitleConfig, TitlePart, Translatable, TwitterCard, TwitterCardConfig, UnbindPropsOptions, ValidateAtLeastOneRequiredConfig, Vec2, ViewportConfig };