@ethlete/components 0.1.0-next.10 → 0.1.0-next.12

package/types/ethlete-components.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { Signal, WritableSignal, InjectionToken, ElementRef, Type, InputSignal, ViewContainerRef, Injector, StaticProvider, TemplateRef, computed, Binding, EnvironmentInjector, ComponentRef } from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, ElementRef, Type, InputSignal, ViewContainerRef, Injector, StaticProvider, TemplateRef, OnInit, ComponentRef, OnDestroy, computed, Provider, EnvironmentInjector, ApplicationRef, Binding } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
-import { AnimatableDirective, DragHandleDirective, ResizeEdge, ResizeMoveEvent, OverlayRuntimePositionStrategy, OverlayRuntimeRef, AnimatedLifecycleDirective, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective, ProvideSurfaceDirective } from '@ethlete/core';
+import { AnimatableDirective, DragHandleDirective, ResizeEdge, ResizeMoveEvent, OverlayRuntimePositionStrategy, Breakpoint, OverlayRuntimeRef, AnimatedLifecycleDirective, OverlayRuntimeCloseSource, AnimatedLifecycleState, AngularRenderer, OverlayRuntimeAnimationDelegate, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective, ProvideSurfaceDirective } from '@ethlete/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
 import { ValidationError, FormCheckboxControl, FormValueControl } from '@angular/forms/signals';
 import * as _ethlete_components from '@ethlete/components';
@@ -593,6 +593,7 @@ type RichTextMarkStates = {
 declare class RichTextEditorDirective implements FormValueControl<string>, FormFieldControl {
     private formField;
     private destroyRef;
+    private document;
     value: _angular_core.ModelSignal<string>;
     touched: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
@@ -641,17 +642,43 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     toggleUnorderedList(): void;
     toggleOrderedList(): void;
     setLink(href: string): void;
+    promptForLink(): void;
     handleBackspace(): boolean;
     /**
      * @internal Extension seam for the follow-up `@`/`#` autocomplete: inserts an atomic inline
      * node (a mention/placeholder token) at the caret, then re-syncs.
      */
     insertAtomicToken(node: Node): void;
+    private serializeCleanHtml;
     private runCommand;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RichTextEditorDirective, "[etRichTextEditor]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
+declare class RichTextEditorFloatingToolbarComponent {
+    protected dir: RichTextEditorDirective;
+    private document;
+    private renderer;
+    private destroyRef;
+    private host;
+    protected visible: _angular_core.WritableSignal<boolean>;
+    private activeRange;
+    private floatingReference;
+    private floatingCleanup;
+    private pointerSelectingInContent;
+    constructor();
+    private selectableRange;
+    private onDocumentPointerUp;
+    private evaluate;
+    private reposition;
+    private start;
+    private updatePosition;
+    private hide;
+    private stop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorFloatingToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorFloatingToolbarComponent, "et-rich-text-editor-floating-toolbar", never, {}, {}, never, never, true, never>;
+}
+
 declare class RichTextEditorComponent {
     protected dir: RichTextEditorDirective;
     private document;
@@ -660,7 +687,6 @@ declare class RichTextEditorComponent {
     protected onInput(): void;
     protected onKeydown(event: KeyboardEvent): void;
     protected onBeforeInput(event: InputEvent): void;
-    protected promptForLink(): void;
     private renderExternalValue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "et-rich-text-editor", never, {}, {}, never, never, true, [{ directive: typeof RichTextEditorDirective; inputs: { "value": "value"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "placeholder": "placeholder"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }]>;
@@ -1564,29 +1590,156 @@ declare class NotificationComponent {
 
 declare const NOTIFICATION_IMPORTS: readonly [typeof NotificationComponent, typeof NotificationDirective, typeof NotificationActionDirective, typeof NotificationDismissDirective];
 
-declare class OverlayAnchorDirective {
-    private overlay;
-    private destroyRef;
-    elementRef: ElementRef<HTMLElement>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayAnchorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayAnchorDirective, "[etOverlayAnchor]", ["etOverlayAnchor"], {}, {}, never, never, true, never>;
-}
+type OverlayStrategyContext = {
+    overlayRef: OverlayRef<object, unknown>;
+    runtimeRef: OverlayRuntimeRef<object, unknown>;
+    /** The mounted container component's host element (the runtime pane element). */
+    containerEl: HTMLElement;
+    /** The runtime host element wrapping backdrop and pane. */
+    hostEl: HTMLElement;
+    backdropEl: HTMLElement | null;
+    /** The container's animated lifecycle, driving enter/leave transitions. */
+    lifecycle: AnimatedLifecycleDirective;
+    config: OverlayBreakpointConfig;
+    previousConfig?: OverlayBreakpointConfig;
+    origin?: HTMLElement | Event;
+};
+type OverlayStrategy = {
+    /** Unique identifier for the strategy */
+    id: string;
+    /** Configuration for the overlay when this strategy is applied */
+    config: OverlayBreakpointConfig;
+    /**
+     * Called when the overlay transitions FROM another strategy TO this strategy.
+     * Only called during breakpoint changes, not on initial open.
+     * @example Fullscreen dialog → Regular dialog on viewport resize
+     */
+    onSwitchedTo?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay transitions FROM this strategy TO another strategy.
+     * Only called during breakpoint changes, not on close.
+     * Use this to cleanup strategy-specific state when transitioning layouts.
+     * @example Regular dialog → Fullscreen dialog on viewport resize
+     */
+    onSwitchedAwayFrom?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay is first opened with this strategy.
+     * Use this for initial setup and enter animations.
+     * The hook is responsible for starting the enter transition (e.g. `context.lifecycle.enter()`).
+     */
+    onBeforeEnter?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called after the overlay has completed its enter animation.
+     */
+    onAfterEnter?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay is about to close (beforeClosed).
+     * The hook is responsible for starting the leave transition (e.g. `context.lifecycle.leave()`).
+     */
+    onBeforeLeave?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called after the overlay has been closed (afterClosed).
+     * Use this for final cleanup.
+     */
+    onAfterLeave?: (context: OverlayStrategyContext) => void;
+};
+type OverlayStrategyBreakpoint = {
+    /**
+     * Breakpoint to apply the strategy for. If a number is provided, it will be used as a pixel value.
+     * Always uses the min-width media query.
+     *
+     * @default 'xs' // 0px
+     */
+    breakpoint?: Breakpoint | number;
+    /** Overlay strategy to be applied when the breakpoint is active. */
+    strategy: OverlayStrategy;
+};
+type OverlayDragToDismissConfig = {
+    /** Direction in which the overlay can be dragged. */
+    direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';
+    /**
+     * The minimum distance in pixels that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px
+     */
+    minDistanceToDismiss?: number;
+    /**
+     * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px/s
+     */
+    minVelocityToDismiss?: number;
+};
+type OverlayBreakpointConfig = {
+    /** Min-width of the overlay. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Max-width of the overlay. If a number is provided, assumes pixel units. */
+    maxWidth?: number | string;
+    /** Min-height of the overlay. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-height of the overlay. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Width of the overlay. */
+    width?: number | string;
+    /** Height of the overlay. */
+    height?: number | string;
+    /** Position strategy to be used for the overlay. */
+    positionStrategy?: (origin?: HTMLElement) => OverlayRuntimePositionStrategy;
+    /** Custom class for the overlay container (the runtime pane element hosting the overlay content). */
+    containerClass?: string | string[];
+    /** Custom class for the runtime host element wrapping backdrop and pane. */
+    hostClass?: string | string[];
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Custom class for the document (`<html>` element). */
+    documentClass?: string | string[];
+    /** Custom class for the `<body>` element */
+    bodyClass?: string | string[];
+    /** Determine if and in what direction the overlay should be able to be dragged to dismiss it. */
+    dragToDismiss?: OverlayDragToDismissConfig;
+    /**
+     * Whether a backdrop element is rendered behind the overlay. Only applied at mount time (the
+     * initially matched strategy) — it cannot change during breakpoint switches. An explicit
+     * `hasBackdrop` on the overlay config always wins over this strategy default.
+     *
+     * @default undefined // falls back to the overlay config / modal behavior
+     */
+    hasBackdrop?: boolean;
+    /**
+     * Whether the transform origin should be set using the config's `origin` property value.
+     *
+     * @default false
+     */
+    applyTransformOrigin?: boolean;
+    /**
+     * Renders a floating-ui-positioned arrow on the overlay container that points at the origin.
+     * Only meaningful for anchored positioning. The arrow inherits the pane background; combine with
+     * an `offset` so the pane leaves room for it.
+     *
+     * @default false
+     */
+    arrow?: boolean;
+};
 
 type OverlayAutoFocusTarget = 'container' | 'first-heading' | 'first-tabbable';
 type OverlayRole = 'dialog' | 'alertdialog';
 type OverlayMode = 'modal' | 'non-modal';
-type OverlayPositionStrategy = OverlayRuntimePositionStrategy;
 type OverlayConfig = {
     viewContainerRef?: ViewContainerRef;
     injector?: Injector;
     id?: string;
-    origin?: HTMLElement;
+    /**
+     * The element or event the overlay was opened from. Used as the anchor reference
+     * for anchored positioning and as the transform origin for strategy animations.
+     * When omitted and strategies are used, falls back to the currently focused element.
+     */
+    origin?: HTMLElement | Event;
     role?: OverlayRole;
-    positionStrategy?: OverlayPositionStrategy;
     hasBackdrop?: boolean;
     disableClose?: boolean;
     inputBindings?: Record<string, unknown>;
+    /** Event listeners bound to the overlay component's outputs. */
+    outputBindings?: Record<string, (event: unknown) => unknown>;
     ariaDescribedBy?: string | null;
     ariaLabelledBy?: string | null;
     ariaLabel?: string | null;
@@ -1599,37 +1752,76 @@ type OverlayConfig = {
     mode?: OverlayMode;
     closeOnOutsidePointer?: boolean;
     closeOnEscape?: boolean;
+    /**
+     * Breakpoint-driven overlay strategies (dialog, sheets, full-screen, …).
+     * When set, position, sizing and classes are controlled by the active strategy.
+     */
+    strategies?: () => OverlayStrategyBreakpoint[];
+    /**
+     * Disables the default overlay animations so custom ones can be applied.
+     *
+     * @default false
+     */
+    customAnimated?: boolean;
 };
 
 declare const createOverlayRef: <TComponent extends object, TResult = unknown>(config: OverlayConfig) => {
     readonly id: string;
+    readonly elements: _ethlete_core.OverlayRuntimeElements | null;
     config: OverlayConfig;
-    readonly componentInstance: TComponent | null;
-    close(result?: TResult): void;
-    afterOpened(): Observable<void>;
-    beforeClosed(): Observable<TResult | undefined>;
-    afterClosed(): Observable<TResult | undefined>;
-    attachRuntime(runtimeRef: OverlayRuntimeRef<TComponent, TResult>): void;
+    headerTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
+    /** @internal Set (or clear) the active header template. */
+    setHeaderTemplate: (template: TemplateRef<unknown> | null) => void;
+    componentInstance: () => TComponent | null;
+    close: (result?: TResult) => void;
+    closeVia: (source: OverlayRuntimeCloseSource, result?: TResult) => void;
+    attachComponentInstanceOverride: (getter: () => TComponent | null) => void;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<TResult | undefined>;
+    afterClosed: () => Observable<TResult | undefined>;
+    attachRuntime: (runtimeRef: OverlayRuntimeRef<TComponent, TResult>) => void;
 };
 type OverlayRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRef<TComponent, TResult>>;
 declare const OVERLAY_REF: InjectionToken<{
     readonly id: string;
+    readonly elements: _ethlete_core.OverlayRuntimeElements | null;
     config: OverlayConfig;
-    readonly componentInstance: object | null;
-    close(result?: unknown): void;
-    afterOpened(): Observable<void>;
-    beforeClosed(): Observable<unknown>;
-    afterClosed(): Observable<unknown>;
-    attachRuntime(runtimeRef: OverlayRuntimeRef<object, unknown>): void;
+    headerTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
+    /** @internal Set (or clear) the active header template. */
+    setHeaderTemplate: (template: TemplateRef<unknown> | null) => void;
+    componentInstance: () => object | null;
+    close: (result?: unknown) => void;
+    closeVia: (source: OverlayRuntimeCloseSource, result?: unknown) => void;
+    attachComponentInstanceOverride: (getter: () => object | null) => void;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<unknown>;
+    afterClosed: () => Observable<unknown>;
+    attachRuntime: (runtimeRef: OverlayRuntimeRef<object, unknown>) => void;
 }>;
 
+declare const getClosestOverlay: (element: ElementRef<HTMLElement>, openOverlays: OverlayRef<object, unknown>[]) => OverlayRef<object, unknown> | null;
+type ResolveClosestOverlayOptions = {
+    overlayRef: OverlayRef<object, unknown> | null;
+    element: ElementRef<HTMLElement>;
+    openOverlays: OverlayRef<object, unknown>[];
+};
+/** Returns the given ref or resolves the overlay the element is rendered inside of. Throws if neither exists. */
+declare const resolveClosestOverlay: (options: ResolveClosestOverlayOptions) => OverlayRef<object, unknown>;
+
+declare class OverlayAnchorDirective {
+    private overlay;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayAnchorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayAnchorDirective, "[etOverlayAnchor]", ["etOverlayAnchor"], {}, {}, never, never, true, never>;
+}
+
 declare class OverlayTemplateHostComponent {
-    private animatedLifecycleInstance;
     protected template: _angular_core.InputSignal<TemplateRef<OverlaySurfaceContext>>;
     protected context: _angular_core.InputSignal<OverlaySurfaceContext>;
-    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTemplateHostComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayTemplateHostComponent, "et-overlay-template-host", never, { "template": { "alias": "template"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayTemplateHostComponent, "et-overlay-template-host", never, { "template": { "alias": "template"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class OverlayTriggerDirective {
@@ -1708,13 +1900,204 @@ declare class OverlaySurfaceDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySurfaceDirective, "ng-template[etOverlaySurface]", ["etOverlaySurface"], {}, {}, never, never, true, never>;
 }
 
+declare const OVERLAY_BODY_TOKEN: InjectionToken<OverlayBodyComponent>;
+type OverlayBodyDividerType = 'static' | 'dynamic' | false;
+declare class OverlayBodyComponent implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private scrollObserver;
+    dividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    private overlayManager;
+    dividersEnabled: _angular_core.Signal<boolean>;
+    dynamicDividersEnabled: _angular_core.Signal<boolean>;
+    containerScrollState: _angular_core.Signal<_ethlete_core.ElementScrollState>;
+    canScroll: _angular_core.Signal<boolean>;
+    isAtStart: _angular_core.Signal<boolean>;
+    isAtEnd: _angular_core.Signal<boolean>;
+    enableDividerAnimations: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    scrollToTop(behavior?: ScrollBehavior): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayBodyComponent, "[et-overlay-body], et-overlay-body", never, { "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.ScrollObserverDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class OverlayCloseDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    closeResult: _angular_core.InputSignal<unknown>;
+    closeResultAlt: _angular_core.InputSignal<unknown>;
+    private overlayManager;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayCloseDirective, "[et-overlay-close], [etOverlayClose]", ["etOverlayClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "closeResult": { "alias": "etOverlayClose"; "required": false; "isSignal": true; }; "closeResultAlt": { "alias": "et-overlay-close"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OverlayContainerComponent {
+    private ownColorProvider;
+    private ownSurfaceProvider;
+    private parentColorProvider;
+    private parentSurfaceProvider;
+    private destroyRef;
+    private elementRef;
+    protected overlayRef: {
+        readonly id: string;
+        readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+        config: _ethlete_components.OverlayConfig;
+        headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+        setHeaderTemplate: (template: _angular_core.TemplateRef<unknown> | null) => void;
+        componentInstance: () => object | null;
+        close: (result?: unknown) => void;
+        closeVia: (source: _ethlete_core.OverlayRuntimeCloseSource, result?: unknown) => void;
+        attachComponentInstanceOverride: (getter: () => object | null) => void;
+        afterOpened: () => rxjs.Observable<void>;
+        beforeClosed: () => rxjs.Observable<unknown>;
+        afterClosed: () => rxjs.Observable<unknown>;
+        attachRuntime: (runtimeRef: _ethlete_core.OverlayRuntimeRef<object, unknown>) => void;
+    };
+    component: _angular_core.InputSignal<Type<object>>;
+    componentInputs: _angular_core.InputSignal<Record<string, unknown> | undefined>;
+    componentOutputs: _angular_core.InputSignal<Record<string, (event: unknown) => unknown> | undefined>;
+    renderArrow: _angular_core.InputSignal<boolean>;
+    private contentOutlet;
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private renderer;
+    rootBoundary: {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    };
+    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
+    contentComponentRef: _angular_core.WritableSignal<ComponentRef<object> | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayContainerComponent, "et-overlay-container", never, { "component": { "alias": "component"; "required": true; "isSignal": true; }; "componentInputs": { "alias": "componentInputs"; "required": false; "isSignal": true; }; "componentOutputs": { "alias": "componentOutputs"; "required": false; "isSignal": true; }; "renderArrow": { "alias": "renderArrow"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
 declare const OVERLAY_ERROR_CODES: {
     readonly MISSING_OVERLAY_SURFACE: 1200;
     readonly TRIGGER_OUTSIDE_OVERLAY: 1201;
     readonly ANCHOR_OUTSIDE_OVERLAY: 1202;
     readonly SURFACE_OUTSIDE_OVERLAY: 1203;
+    readonly MULTIPLE_LAYOUT_CLASSES: 1204;
+    readonly NO_CLOSEST_OVERLAY: 1205;
+    readonly NESTED_OVERLAY_MAIN: 1206;
 };
 
+declare const OVERLAY_FOOTER_TOKEN: InjectionToken<OverlayFooterDirective>;
+declare class OverlayFooterDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayFooterDirective, "[etOverlayFooter], et-overlay-footer", never, {}, {}, never, never, true, never>;
+}
+
+type CreateOverlayHandlerConfig<TComponent extends object> = OverlayConfig & {
+    /** The overlay component. */
+    component: Type<TComponent>;
+};
+/** Per-open config overrides. Strategies are fixed by the handler's root config. */
+type OverlayConsumerConfig = Omit<OverlayConfig, 'strategies'>;
+type OverlayHandler<TComponent extends object, TResult = unknown> = {
+    /** Open the overlay using a combination of the given configs  */
+    open: (config?: OverlayConsumerConfig) => OverlayRef<TComponent, TResult>;
+    /**
+     * Returns the typed overlay ref.
+     * @throws Error if the overlay ref gets accessed outside of the overlay component
+     */
+    injectOverlayRef: () => OverlayRef<TComponent, TResult>;
+};
+type CreateOverlayHandlerInnerConfig<TResult = unknown> = {
+    /** A callback function to be executed once the overlay has been closed */
+    afterClosed?: (result: TResult | null) => void;
+    /** A callback function to be executed before the overlay is closed */
+    beforeClosed?: (result: TResult | null) => void;
+    /** A callback function to be executed once the overlay has been opened */
+    afterOpened?: () => void;
+};
+declare const createOverlayHandler: <TComponent extends object, TResult = unknown>(rootConfig: CreateOverlayHandlerConfig<TComponent>) => (innerConfig?: CreateOverlayHandlerInnerConfig<TResult>) => OverlayHandler<TComponent, TResult>;
+/** The name of the model the overlay component must expose to participate in query-param sync. */
+declare const OVERLAY_QUERY_PARAM_INPUT_NAME = "overlayQueryParam";
+type OverlayHandlerWithQueryParamLifecycle<TQueryParam extends string = string> = {
+    /** Open the overlay by writing the given value to the query param. */
+    open: (value: TQueryParam) => void;
+    /** Close the overlay by removing the query param. */
+    close: () => void;
+};
+type CreateOverlayHandlerWithQueryParamLifecycleConfig<TComponent extends object> = CreateOverlayHandlerConfig<TComponent> & {
+    /** The query param key that drives this overlay's open/close lifecycle. */
+    queryParamKey: string;
+};
+/**
+ * Drives an overlay's lifecycle from a URL query param: the overlay opens while the param is present
+ * and closes (clearing the param) when dismissed. The param value is forwarded to the overlay via an
+ * `overlayQueryParam` {@link https://angular.dev/api/core/model | model}, which is kept in two-way sync
+ * with the URL — reading the model reflects the URL, and writing it updates the URL.
+ *
+ * Open it declaratively with {@link OverlayHandlerLinkDirective}, or imperatively via the returned
+ * handler's `open()` / `close()`.
+ *
+ * @example
+ * // in the overlay component:
+ * readonly overlayQueryParam = model<string>();
+ *
+ * // once, in a long-lived component (e.g. AppComponent):
+ * private handler = createProductOverlay(); // returned by this factory
+ */
+declare const createOverlayHandlerWithQueryParamLifecycle: <TComponent extends object, TQueryParam extends string = string, TResult = unknown>(config: CreateOverlayHandlerWithQueryParamLifecycleConfig<TComponent>) => {
+    (innerConfig?: CreateOverlayHandlerInnerConfig<TResult>): OverlayHandlerWithQueryParamLifecycle<TQueryParam>;
+    injectOverlayRef(): OverlayRef<TComponent, TResult>;
+};
+
+declare class OverlayHandlerLinkDirective {
+    private routerLink;
+    linkValue: _angular_core.InputSignal<string | number>;
+    linkKey: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayHandlerLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayHandlerLinkDirective, "[etOverlayHandlerLink]", never, { "linkValue": { "alias": "etOverlayHandlerLink"; "required": true; "isSignal": true; }; "linkKey": { "alias": "etOverlayHandlerQueryParamName"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RouterLink; inputs: {}; outputs: {}; }]>;
+}
+
+declare const OVERLAY_HEADER_TOKEN: InjectionToken<OverlayHeaderDirective>;
+declare class OverlayHeaderDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayHeaderDirective, "[etOverlayHeader], et-overlay-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_HEADER_TEMPLATE_TOKEN: InjectionToken<OverlayHeaderTemplateDirective>;
+declare class OverlayHeaderTemplateDirective implements OnInit, OnDestroy {
+    private overlayRef;
+    private elementRef;
+    template: TemplateRef<unknown>;
+    private overlayManager;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayHeaderTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayHeaderTemplateDirective, "ng-template[etOverlayHeaderTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_MAIN_TOKEN: InjectionToken<OverlayMainDirective>;
+declare class OverlayMainDirective implements OnInit {
+    private parent;
+    private elementRef;
+    private overlayRef;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private overlayManager;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayMainDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayMainDirective, "[etOverlayMain], et-overlay-main", never, { "enabled": { "alias": "etOverlayMain"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 type OverlayManager = {
     open: <TComponent extends object, TResult = unknown>(component: Type<TComponent>, config?: OverlayConfig) => OverlayRef<TComponent, TResult>;
     openOverlays: ReturnType<typeof computed<OverlayRef<object, unknown>[]>>;
@@ -1728,7 +2111,605 @@ declare const injectOverlayManager: {
     (options: _angular_core.InjectOptions): OverlayManager | null;
 };
 
+/**
+ * Blocks body scrolling while a modal overlay is open.
+ * Register once via `provideOverlay()` (or call `injectOverlayScrollBlocker()` in an environment initializer).
+ */
+declare const provideOverlayScrollBlocker: () => _angular_core.Provider[];
+declare const injectOverlayScrollBlocker: {
+    (): void;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): void;
+    (options: _angular_core.InjectOptions): void | null;
+};
+
+declare class OverlayTitleDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    id: _angular_core.InputSignal<string>;
+    private overlayManager;
+    private renderer;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTitleDirective, "[et-overlay-title], [etOverlayTitle]", ["etOverlayTitle"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare const OVERLAY_IMPORTS: readonly [typeof OverlayDirective, typeof OverlayTriggerDirective, typeof OverlayAnchorDirective, typeof OverlaySurfaceDirective];
+declare const OVERLAY_CONTENT_IMPORTS: readonly [typeof OverlayCloseDirective, typeof OverlayTitleDirective, typeof OverlayHeaderDirective, typeof OverlayBodyComponent, typeof OverlayFooterDirective, typeof OverlayMainDirective];
+declare const provideOverlay: () => _angular_core.EnvironmentProviders[];
+
+declare const OVERLAY_BACK_OR_CLOSE_TOKEN: InjectionToken<OverlayBackOrCloseDirective>;
+declare class OverlayBackOrCloseDirective {
+    private overlayRef;
+    private elementRef;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private router;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayBackOrCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayBackOrCloseDirective, "[etOverlayBackOrClose]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OverlayRouteHeaderTemplateOutletComponent {
+    protected overlay: {
+        readonly id: string;
+        readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+        config: _ethlete_components.OverlayConfig;
+        headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+        setHeaderTemplate: (template: _angular_core.TemplateRef<unknown> | null) => void;
+        componentInstance: () => object | null;
+        close: (result?: unknown) => void;
+        closeVia: (source: _ethlete_core.OverlayRuntimeCloseSource, result?: unknown) => void;
+        attachComponentInstanceOverride: (getter: () => object | null) => void;
+        afterOpened: () => rxjs.Observable<void>;
+        beforeClosed: () => rxjs.Observable<unknown>;
+        afterClosed: () => rxjs.Observable<unknown>;
+        attachRuntime: (runtimeRef: _ethlete_core.OverlayRuntimeRef<object, unknown>) => void;
+    };
+    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective>;
+    protected router: _ethlete_components.OverlayRouter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouteHeaderTemplateOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayRouteHeaderTemplateOutletComponent, "et-overlay-route-header-template-outlet", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_CONFIG_TOKEN: InjectionToken<OverlayRouterConfig>;
+type OverlayRoute = {
+    /** The component to render. */
+    component: Type<unknown>;
+    /**
+     * The route of the page.
+     *
+     * @example
+     * "/" // The root route
+     * "/two" // The route "two"
+     */
+    path: `/${string}`;
+    /** The inputs to pass to the component. Signal values are unwrapped. */
+    inputs?: Record<string, unknown>;
+    /**
+     * Overrides the animation direction used when navigating to or away from this route.
+     * Useful for routes that conceptually sit "before" the others, like a sidebar page that
+     * should slide in from the left. An explicit direction passed to `navigate()` always wins.
+     */
+    navigationDirection?: {
+        /** Direction to play when this route becomes active. */
+        to?: OverlayRouterNavigationDirection;
+        /** Direction to play when navigating away from this route. */
+        from?: OverlayRouterNavigationDirection;
+    };
+};
+type OverlayRouterConfig = {
+    /** The routes to be able to navigate to. */
+    routes: OverlayRoute[];
+    /**
+     * The route on which to start.
+     * @default routes[0].path // The first route, or "/" if none is defined
+     */
+    initialRoute?: string;
+    /**
+     * Mirror the active overlay route into the browser URL as a query param, enabling deep-linking and
+     * browser back/forward integration. Requires the Angular `Router` to be available.
+     *
+     * @default false
+     */
+    syncUrl?: boolean;
+};
+type OverlayRouterNavigationDirection = 'forward' | 'backward';
+type OverlayRouterNavigateConfig = {
+    navigationDirection?: OverlayRouterNavigationDirection;
+};
+type OverlayRouterTransitionType = 'slide' | 'fade' | 'overlay' | 'vertical' | 'none';
+type OverlayRouterResolvedPath = {
+    route: string;
+    type: 'back' | 'replace-current' | 'absolute' | 'forward';
+};
+type OverlayRouter = {
+    /** The current route, but delayed by one frame to ensure that the needed animation classes are applied. */
+    currentRoute: Signal<string>;
+    /** Routes registered at runtime in addition to the configured ones. */
+    extraRoutes: WritableSignal<OverlayRoute[]>;
+    /** The transition to play when navigating between routes. */
+    transitionType: WritableSignal<OverlayRouterTransitionType>;
+    /** The direction of the current navigation. */
+    navigationDirection: WritableSignal<OverlayRouterNavigationDirection>;
+    /** Whether an in-memory history entry exists to go back to. */
+    canGoBack: Signal<boolean>;
+    /** All navigable routes (configured + extra) with signal inputs unwrapped. */
+    routes: Signal<OverlayRoute[]>;
+    /** The route currently being displayed. */
+    currentPage: Signal<OverlayRoute | null>;
+    navigate: (route: string | (string | number)[], config?: OverlayRouterNavigateConfig) => void;
+    back: () => boolean;
+    resolvePath: (route: string | (string | number)[]) => OverlayRouterResolvedPath;
+    addRoute: (route: OverlayRoute) => void;
+    removeRoute: (path: string) => void;
+    /** @internal Returns `true` when the route actually changed. */
+    updateCurrentRoute: (route: string) => boolean;
+    /** @internal */
+    navigateToInitialRoute: () => void;
+};
+declare const provideOverlayRouterService: () => Provider[];
+declare const injectOverlayRouter: {
+    (): OverlayRouter;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayRouter;
+    (options: _angular_core.InjectOptions): OverlayRouter | null;
+};
+declare const OVERLAY_ROUTER_TOKEN: InjectionToken<OverlayRouter>;
+declare const provideOverlayRouterConfig: (config: OverlayRouterConfig) => Provider[];
+/**
+ * Provides both the overlay router config and the overlay router itself, so a consumer only needs
+ * a single entry in the overlay's `providers` instead of wiring the router separately.
+ *
+ * @example
+ * overlayManager.open(MyOverlay, {
+ *   strategies: dialogOverlayStrategy(),
+ *   providers: [provideOverlayRouter({ routes: [...] })],
+ * });
+ */
+declare const provideOverlayRouter: (config: OverlayRouterConfig) => Provider[];
+
+declare const OVERLAY_ROUTER_LINK_TOKEN: InjectionToken<OverlayRouterLinkDirective>;
+declare class OverlayRouterLinkDirective {
+    private elementRef;
+    path: _angular_core.InputSignal<string | (string | number)[]>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    navigationDirection: _angular_core.InputSignal<OverlayRouterNavigationDirection | null>;
+    private router;
+    isActive: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayRouterLinkDirective, "[etOverlayRouterLink]", never, { "path": { "alias": "etOverlayRouterLink"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "navigationDirection": { "alias": "navigationDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN: InjectionToken<OverlayRouterOutletDisabledTemplateDirective>;
+declare class OverlayRouterOutletDisabledTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterOutletDisabledTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayRouterOutletDisabledTemplateDirective, "ng-template[etOverlayRouterOutletDisabledTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_OUTLET_TOKEN: InjectionToken<OverlayRouterOutletComponent>;
+declare class OverlayRouterOutletComponent {
+    private injector;
+    private overlayRef;
+    private elementRef;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    sharedRouteTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    outletDisabledTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    pageWrappers: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    protected router: _ethlete_components.OverlayRouter;
+    private renderer;
+    readonly hasSidebar: boolean;
+    wasDisabled: _angular_core.WritableSignal<boolean>;
+    keepDisabledTransition: _angular_core.Signal<boolean>;
+    activePageElement: _angular_core.Signal<HTMLElement | null>;
+    protected transitionType: _angular_core.Signal<_ethlete_components.OverlayRouterTransitionType>;
+    constructor();
+    scrollActivePageTo(options?: ScrollToOptions | undefined): void;
+    disabledPageAnimationStateChange(state: AnimatedLifecycleState): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayRouterOutletComponent, "et-overlay-router-outlet", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["sharedRouteTemplate", "outletDisabledTemplate"], ["*"], true, never>;
+}
+
+declare class OverlaySharedRouteTemplateOutletComponent {
+    protected routerOutlet: _ethlete_components.OverlayRouterOutletComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySharedRouteTemplateOutletComponent, "et-overlay-shared-route-template-outlet", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN: InjectionToken<OverlaySharedRouteTemplateDirective>;
+declare class OverlaySharedRouteTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySharedRouteTemplateDirective, "ng-template[etOverlaySharedRouteTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class OverlaySidebarPageComponent {
+    headerTemplate: _angular_core.InputSignal<OverlayHeaderTemplateDirective | null>;
+    bodyTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    pageDividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySidebarPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySidebarPageComponent, "et-overlay-sidebar-page", never, { "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": true; "isSignal": true; }; "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof OverlayMainDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class OverlaySidebarComponent {
+    pageDividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    sidebarContent: _angular_core.Signal<TemplateRef<unknown>>;
+    sidebarHeaderContent: _angular_core.Signal<_ethlete_components.OverlayHeaderTemplateDirective | undefined>;
+    protected sidebar: _ethlete_components.SidebarOverlay;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySidebarComponent, "et-overlay-sidebar", never, { "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, ["sidebarHeaderContent"], ["*"], true, never>;
+}
+
+declare const SIDEBAR_OVERLAY_CONFIG: InjectionToken<SidebarOverlayConfig>;
+type SidebarOverlayConfig = {
+    /**
+     * On mobile devices, the sidebar is shown as a separate page that can be navigated to.
+     * This is the route to that sidebar page.
+     *
+     * @default "/sidebar"
+     */
+    sidebarPageRoute?: `/${string}`;
+    /**
+     * The width from which the sidebar renders inline (rather than collapsing into a page). Compared
+     * against the overlay's own pane width — not the viewport — so a narrow dialog collapses its
+     * sidebar even on a wide screen. Can be a breakpoint name or a pixel number. Works best with an
+     * overlay that has a defined width.
+     *
+     * @default "md"
+     */
+    renderSidebarFrom?: Breakpoint | number;
+};
+type SidebarOverlay = {
+    /** Whether the sidebar renders inline (`true`) or is collapsed into a navigable page (`false`). */
+    renderSidebar: Signal<boolean>;
+    sidebarContentTemplate: WritableSignal<TemplateRef<unknown> | null>;
+    sidebarHeaderTemplate: WritableSignal<OverlayHeaderTemplateDirective | null>;
+    sidebarPageDividers: WritableSignal<OverlayBodyDividerType>;
+};
+declare const provideSidebarOverlayService: () => Provider[];
+declare const injectSidebarOverlay: {
+    (): SidebarOverlay;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): SidebarOverlay;
+    (options: _angular_core.InjectOptions): SidebarOverlay | null;
+};
+declare const SIDEBAR_OVERLAY_TOKEN: InjectionToken<SidebarOverlay>;
+declare const provideSidebarOverlayConfig: (config: SidebarOverlayConfig) => Provider[];
+/**
+ * Provides both the sidebar config and the sidebar overlay service in one call, mirroring
+ * {@link provideOverlayRouter}. Requires an overlay router to also be provided.
+ */
+declare const provideSidebarOverlay: (config?: SidebarOverlayConfig) => Provider[];
+
+type AnchoredOverlayStrategyOptions = {
+    containerClass?: string | string[];
+    hostClass?: string | string[];
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+    placement?: Placement;
+    fallbackPlacements?: Placement[];
+    offset?: OffsetOptions | null;
+    arrowPadding?: Padding | null;
+    viewportPadding?: Padding | null;
+    shift?: boolean;
+    autoResize?: boolean;
+    autoHide?: boolean;
+    autoCloseIfReferenceHidden?: boolean;
+    mirrorWidth?: boolean;
+    /** Render a floating-ui-positioned arrow on the container pointing at the origin. */
+    arrow?: boolean;
+};
+type CenteredOverlayStrategyOptions = {
+    containerClass?: string | string[];
+    hostClass?: string | string[];
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+};
+type AnchoredPositionOptions = Pick<AnchoredOverlayStrategyOptions, 'placement' | 'fallbackPlacements' | 'offset' | 'arrowPadding' | 'viewportPadding' | 'shift' | 'autoResize' | 'autoHide' | 'autoCloseIfReferenceHidden' | 'mirrorWidth'>;
+declare const buildAnchoredRuntimePositionStrategy: (options?: AnchoredPositionOptions) => (origin?: HTMLElement) => OverlayRuntimePositionStrategy;
+declare const anchoredOverlayStrategy: (options?: AnchoredOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+declare const centeredOverlayStrategy: (options?: CenteredOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+
+type AnchoredDialogOverlayStrategyOptions = Partial<OverlayBreakpointConfig> & AnchoredPositionOptions;
+declare const provideAnchoredDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectAnchoredDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideAnchoredDialogStrategy: () => _angular_core.Provider[];
+declare const injectAnchoredDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const anchoredDialogOverlayStrategy: (options?: AnchoredDialogOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideBottomSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectBottomSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideBottomSheetStrategy: () => _angular_core.Provider[];
+declare const injectBottomSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const bottomSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideDialogStrategy: () => _angular_core.Provider[];
+declare const injectDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const dialogOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideFullscreenDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectFullscreenDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideFullscreenDialogStrategy: () => _angular_core.Provider[];
+declare const injectFullscreenDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const fullScreenDialogOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare class OverlayOriginCloneComponent {
+    animatedLifecycle: AnimatedLifecycleDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayOriginCloneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayOriginCloneComponent, "et-overlay-origin-clone", never, {}, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type ViewportTransformData = {
+    viewportWidth: number;
+    viewportHeight: number;
+    rect: DOMRect;
+    scaleUpX: number;
+    scaleUpY: number;
+    viewportCenterX: number;
+    viewportCenterY: number;
+    buttonCenterX: number;
+    buttonCenterY: number;
+    cloneTranslateX: number;
+    cloneTranslateY: number;
+    containerTranslateX: number;
+    containerTranslateY: number;
+    scaleX: number;
+    scaleY: number;
+};
+type FullscreenAnimationCancellable = {
+    unsubscribe: () => void;
+};
+type FullscreenAnimationState = {
+    readonly originElement: HTMLElement | null;
+    readonly cloneComponentRef: ComponentRef<OverlayOriginCloneComponent> | null;
+    readonly subscriptions: FullscreenAnimationCancellable[];
+    readonly isOriginHidden: boolean;
+};
+type FullscreenAnimationDeps = {
+    readonly injector: EnvironmentInjector;
+    readonly document: Document;
+    readonly appRef: ApplicationRef;
+    readonly renderer: AngularRenderer;
+};
+declare const cleanupFullscreenAnimationStyles: (options: {
+    containerEl: HTMLElement;
+    renderer: AngularRenderer;
+    state: FullscreenAnimationState | null;
+}) => void;
+declare const startFullscreenEnterAnimation: (options: {
+    context: OverlayStrategyContext;
+    deps: FullscreenAnimationDeps;
+    applyTransformOrigin: boolean;
+    skipAnimation: boolean;
+}) => FullscreenAnimationState;
+declare const startFullscreenLeaveAnimation: (options: {
+    context: OverlayStrategyContext;
+    state: FullscreenAnimationState;
+    deps: FullscreenAnimationDeps;
+    applyTransformOrigin: boolean;
+}) => FullscreenAnimationState;
+declare const cleanupFullscreenAnimation: (state: FullscreenAnimationState, deps: FullscreenAnimationDeps) => void;
+declare const abortFullscreenAnimation: (options: {
+    context: OverlayStrategyContext;
+    state: FullscreenAnimationState;
+    deps: FullscreenAnimationDeps;
+}) => void;
+
+declare const provideLeftSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectLeftSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideLeftSheetStrategy: () => _angular_core.Provider[];
+declare const injectLeftSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const leftSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+type DragToDismissContext = {
+    element: HTMLElement;
+    overlayRef: OverlayRef<object, unknown>;
+    config: OverlayDragToDismissConfig;
+    renderer: AngularRenderer;
+};
+type DragToDismissRef = {
+    unsubscribe: () => void;
+};
+/**
+ * Enables drag-to-dismiss functionality on an overlay element.
+ * Returns a cleanup function to disable the feature.
+ */
+declare const enableDragToDismiss: (context: DragToDismissContext) => DragToDismissRef;
+
+declare const isHtmlElement: (element: unknown) => element is HTMLElement;
+declare const isTouchEvent: (event: Event) => event is TouchEvent;
+declare const isPointerEvent: (event: Event) => event is PointerEvent;
+declare const findNextRelevantHtmlElement: (element: HTMLElement | null, depth?: number) => HTMLElement | null;
+declare const getOriginCoordinatesAndDimensions: (origin: HTMLElement | Event | undefined) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    element: HTMLElement;
+} | null;
+
+declare const OVERLAY_CONFIG_CLASS_KEYS: Set<string>;
+declare const mergeOverlayBreakpointConfigs: (...configs: OverlayBreakpointConfig[]) => OverlayBreakpointConfig;
+
+type OverlayStrategyControllerMountConfig = {
+    positionStrategy: OverlayRuntimePositionStrategy;
+    paneClass: string[];
+    hostClass: string[];
+    backdropClass: string[];
+    animationDelegate: OverlayRuntimeAnimationDelegate;
+    renderArrow: boolean;
+    hasBackdrop: boolean | undefined;
+};
+type OverlayStrategyController = {
+    /** Values the overlay manager merges into the runtime mount config before mounting. */
+    initialMountConfig: OverlayStrategyControllerMountConfig;
+    /** Wires strategy lifecycle hooks and breakpoint switching. Must be called right after mounting. */
+    attach: (runtimeRef: OverlayRuntimeRef<object, unknown>, overlayRef: OverlayRef<object, unknown>) => void;
+};
+declare const createOverlayStrategyController: (config: OverlayConfig, parentInjector: EnvironmentInjector) => OverlayStrategyController;
+
+declare const transformingBottomSheetToDialogOverlayStrategy: (customConfig?: {
+    bottomSheet?: OverlayBreakpointConfig;
+    dialog?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+declare const transformingFullScreenDialogToRightSheetOverlayStrategy: (customConfig?: {
+    fullScreenDialog?: OverlayBreakpointConfig;
+    rightSheet?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+declare const transformingFullScreenDialogToDialogOverlayStrategy: (customConfig?: {
+    fullScreenDialog?: OverlayBreakpointConfig;
+    dialog?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideRightSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectRightSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideRightSheetStrategy: () => _angular_core.Provider[];
+declare const injectRightSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const rightSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideTopSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectTopSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideTopSheetStrategy: () => _angular_core.Provider[];
+declare const injectTopSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const topSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
 
 declare class ScrollableActiveChildDirective {
     private scrollable;
@@ -3750,7 +4731,6 @@ declare class ToggletipComponent {
     content: _angular_core.InputSignal<ToggletipContent>;
     colorProvider: _angular_core.InputSignal<ProvideColorDirective | null>;
     surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
-    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective | undefined>;
     private surfaceThemes;
     hasTemplate: _angular_core.Signal<boolean>;
     contentText: _angular_core.Signal<string | null>;
@@ -3796,7 +4776,6 @@ declare class TooltipComponent {
     content: _angular_core.InputSignal<TooltipContent>;
     colorProvider: _angular_core.InputSignal<ProvideColorDirective | null>;
     surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
-    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective | undefined>;
     private surfaceThemes;
     hasTemplate: _angular_core.Signal<boolean>;
     contentText: _angular_core.Signal<string | null>;
@@ -3851,5 +4830,5 @@ declare const TOOLTIP_ERROR_CODES: {
 
 declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
 
-export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BOLD_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, FACEBOOK_PLAYER_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_TOKEN, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridImports, GridItemComponent, GridItemDirective, GridItemRef, GridResizeDirective, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, INPUT_IMPORTS, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, ITALIC_ICON, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LINK_ICON, LIST_BULLETED_ICON, LIST_NUMBERED_ICON, LOCK_ICON, LabelDirective, NAV_TABS_TOKEN, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NavTabImports, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, OVERLAY_ERROR_CODES, OVERLAY_IMPORTS, OVERLAY_REF, OverlayAnchorDirective, OverlayDirective, OverlaySurfaceDirective, OverlayTriggerDirective, PENCIL_ICON, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLUS_ICON, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, RICH_TEXT_EDITOR_IMPORTS, RadioComponent, RadioGroupComponent, RichTextEditorComponent, RichTextEditorDirective, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SOOP_PLAYER_TOKEN, STREAM_CONSENT_TOKEN, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableErrorCode, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamImports, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_PANEL_TOKEN, TAB_SIZES, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabImports, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TextButtonComponent, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, createGridAdapter, createNotificationRef, createOverlayRef, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, fromGridPosition, injectFormSupport, injectGridConfig, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, provideFormSupport, provideGridConfig, provideIcons, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlayManager, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, toGridPosition };
-export type { ButtonIconAlignment, ButtonSize, FacebookVideoPlayer, FacebookWindow, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OverlayAutoFocusTarget, OverlayConfig, OverlayManager, OverlayMode, OverlayPositionStrategy, OverlayRef, OverlayRole, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, ToggletipContent, TooltipContent, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };
+export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BOLD_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, FACEBOOK_PLAYER_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_TOKEN, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridImports, GridItemComponent, GridItemDirective, GridItemRef, GridResizeDirective, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, INPUT_IMPORTS, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, ITALIC_ICON, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LINK_ICON, LIST_BULLETED_ICON, LIST_NUMBERED_ICON, LOCK_ICON, LabelDirective, NAV_TABS_TOKEN, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NavTabImports, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CONFIG_CLASS_KEYS, OVERLAY_CONTENT_IMPORTS, OVERLAY_ERROR_CODES, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_IMPORTS, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_REF, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_ROUTER_TOKEN, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OverlayAnchorDirective, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseDirective, OverlayContainerComponent, OverlayDirective, OverlayFooterDirective, OverlayHandlerLinkDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayMainDirective, OverlayOriginCloneComponent, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlaySurfaceDirective, OverlayTitleDirective, OverlayTriggerDirective, PENCIL_ICON, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLUS_ICON, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, RICH_TEXT_EDITOR_IMPORTS, RadioComponent, RadioGroupComponent, RichTextEditorComponent, RichTextEditorDirective, RichTextEditorFloatingToolbarComponent, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SIDEBAR_OVERLAY_CONFIG, SIDEBAR_OVERLAY_TOKEN, SOOP_PLAYER_TOKEN, STREAM_CONSENT_TOKEN, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableErrorCode, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamImports, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_PANEL_TOKEN, TAB_SIZES, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabImports, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TextButtonComponent, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, abortFullscreenAnimation, anchoredDialogOverlayStrategy, anchoredOverlayStrategy, bottomSheetOverlayStrategy, buildAnchoredRuntimePositionStrategy, centeredOverlayStrategy, cleanupFullscreenAnimation, cleanupFullscreenAnimationStyles, createGridAdapter, createNotificationRef, createOverlayHandler, createOverlayHandlerWithQueryParamLifecycle, createOverlayRef, createOverlayStrategyController, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, dialogOverlayStrategy, enableDragToDismiss, findNextRelevantHtmlElement, fromGridPosition, fullScreenDialogOverlayStrategy, getClosestOverlay, getOriginCoordinatesAndDimensions, injectAnchoredDialogStrategy, injectAnchoredDialogStrategyDefaults, injectBottomSheetStrategy, injectBottomSheetStrategyDefaults, injectDialogStrategy, injectDialogStrategyDefaults, injectFormSupport, injectFullscreenDialogStrategy, injectFullscreenDialogStrategyDefaults, injectGridConfig, injectLeftSheetStrategy, injectLeftSheetStrategyDefaults, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectOverlayRouter, injectOverlayScrollBlocker, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectRightSheetStrategy, injectRightSheetStrategyDefaults, injectSidebarOverlay, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, injectTopSheetStrategy, injectTopSheetStrategyDefaults, isHtmlElement, isPointerEvent, isTouchEvent, leftSheetOverlayStrategy, mergeOverlayBreakpointConfigs, provideAnchoredDialogStrategy, provideAnchoredDialogStrategyDefaults, provideBottomSheetStrategy, provideBottomSheetStrategyDefaults, provideDialogStrategy, provideDialogStrategyDefaults, provideFormSupport, provideFullscreenDialogStrategy, provideFullscreenDialogStrategyDefaults, provideGridConfig, provideIcons, provideLeftSheetStrategy, provideLeftSheetStrategyDefaults, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlay, provideOverlayManager, provideOverlayRouter, provideOverlayRouterConfig, provideOverlayRouterService, provideOverlayScrollBlocker, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideRightSheetStrategy, provideRightSheetStrategyDefaults, provideSidebarOverlay, provideSidebarOverlayConfig, provideSidebarOverlayService, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, provideTopSheetStrategy, provideTopSheetStrategyDefaults, resolveClosestOverlay, rightSheetOverlayStrategy, startFullscreenEnterAnimation, startFullscreenLeaveAnimation, toGridPosition, topSheetOverlayStrategy, transformingBottomSheetToDialogOverlayStrategy, transformingFullScreenDialogToDialogOverlayStrategy, transformingFullScreenDialogToRightSheetOverlayStrategy };
+export type { AnchoredDialogOverlayStrategyOptions, AnchoredOverlayStrategyOptions, AnchoredPositionOptions, ButtonIconAlignment, ButtonSize, CenteredOverlayStrategyOptions, CreateOverlayHandlerConfig, CreateOverlayHandlerInnerConfig, CreateOverlayHandlerWithQueryParamLifecycleConfig, DragToDismissContext, DragToDismissRef, FacebookVideoPlayer, FacebookWindow, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, FullscreenAnimationCancellable, FullscreenAnimationDeps, FullscreenAnimationState, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OverlayAutoFocusTarget, OverlayBodyDividerType, OverlayBreakpointConfig, OverlayConfig, OverlayConsumerConfig, OverlayDragToDismissConfig, OverlayHandler, OverlayHandlerWithQueryParamLifecycle, OverlayManager, OverlayMode, OverlayRef, OverlayRole, OverlayRoute, OverlayRouter, OverlayRouterConfig, OverlayRouterNavigateConfig, OverlayRouterNavigationDirection, OverlayRouterResolvedPath, OverlayRouterTransitionType, OverlayStrategy, OverlayStrategyBreakpoint, OverlayStrategyContext, OverlayStrategyController, OverlayStrategyControllerMountConfig, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, ResolveClosestOverlayOptions, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, SidebarOverlay, SidebarOverlayConfig, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, ToggletipContent, TooltipContent, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, ViewportTransformData, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };