@ethlete/core 4.32.1 → 4.33.0

package/types/ethlete-core.d.ts

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