@ethlete/components 0.1.0-next.8 → 1.0.0-next.17

package/types/ethlete-components.d.ts

@@ -1,14 +1,14 @@
 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, Binding, StaticProvider, TemplateRef, OnInit, ComponentRef, OnDestroy, computed, Provider, EnvironmentInjector, ApplicationRef } 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, ResizeEdge, DragHandleDirective, ResizeMoveEvent, OverlayRuntimePositionStrategy, Breakpoint, OverlayRuntimeRef, AnimatedLifecycleDirective, OverlayRuntimeCloseSource, AnimatedLifecycleState, AngularRenderer, OverlayRuntimeAnimationDelegate, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective } 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';
 import * as _angular_platform_browser from '@angular/platform-browser';
+import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
 import * as i1 from '@angular/router';
 
 declare class ButtonStylesDirective {
@@ -31,16 +31,17 @@ declare class ButtonDirective {
     type: _angular_core.InputSignal<ButtonType>;
     pressed: _angular_core.InputSignalWithTransform<boolean, unknown>;
     emitAriaPressed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    mutedUntilPressed: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly IS_BUTTON: boolean;
     readonly IS_ANCHOR: boolean;
     isInactive: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[etButton]", ["etButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "emitAriaPressed": { "alias": "emitAriaPressed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[etButton]", ["etButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "emitAriaPressed": { "alias": "emitAriaPressed"; "required": false; "isSignal": true; }; "mutedUntilPressed": { "alias": "mutedUntilPressed"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.SurfaceInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class FocusRingDirective {
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private styleManager;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected active: _angular_core.WritableSignal<boolean>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FocusRingDirective, never>;
@@ -85,7 +86,7 @@ declare class ButtonComponent {
     }>;
     pressedVariant: _angular_core.Signal<string | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "[et-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "[et-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; "mutedUntilPressed": "mutedUntilPressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 type FabVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];
@@ -121,7 +122,7 @@ declare class IconButtonComponent {
     }>;
     pressedVariant: _angular_core.Signal<string | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "[et-icon-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "[et-icon-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; "mutedUntilPressed": "mutedUntilPressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class TextButtonComponent {
@@ -179,6 +180,7 @@ declare const FORM_FIELD_ERROR_CODES: {
 
 declare const FORM_FIELD_CONTROL_TYPES: {
     readonly TEXT_INPUT: "text-input";
+    readonly RICH_TEXT: "rich-text";
     readonly CHECKBOX: "checkbox";
     readonly RADIO: "radio";
     readonly SWITCH: "switch";
@@ -370,10 +372,6 @@ declare class CheckboxComponent {
 declare const CHECKBOX_IMPORTS: readonly [typeof CheckboxComponent, typeof CheckboxDirective];
 
 declare class ChoiceFieldComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -391,6 +389,10 @@ declare class ChoiceFieldComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
@@ -462,6 +464,8 @@ declare class FormFieldComponent {
     private provideSurface;
     private parentSurfaceProvider;
     protected formFieldDir: FormFieldDirective;
+    protected errorColorTheme: _ethlete_core.ColorTheme;
+    private surfaceThemes;
     appearance: _angular_core.InputSignal<FormFieldAppearance>;
     fill: _angular_core.InputSignal<FormFieldFill>;
     labelMode: _angular_core.InputSignal<FormFieldLabelMode>;
@@ -471,8 +475,6 @@ declare class FormFieldComponent {
     prefixEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     protected errorAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
     protected hintAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
-    protected errorColorTheme: _ethlete_core.ColorTheme;
-    private surfaceThemes;
     private errorDimensions;
     private hintDimensions;
     private prefixDimensions;
@@ -573,6 +575,131 @@ declare class InputComponent {
 
 declare const INPUT_IMPORTS: readonly [typeof InputComponent, typeof InputDirective];
 
+type InlineTag = 'strong' | 'em' | 'del';
+type ListTag = 'ul' | 'ol';
+type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+type EditableSelection = {
+    selection: Selection;
+    range: Range;
+};
+type RichTextMarkStates = {
+    bold: boolean;
+    italic: boolean;
+    strike: boolean;
+    unorderedList: boolean;
+    orderedList: boolean;
+    link: boolean;
+    /** Heading level of the block the selection starts in, or `null` when it is not a heading. */
+    heading: number | null;
+};
+
+declare class RichTextEditorDirective implements FormValueControl<string>, FormFieldControl {
+    private formField;
+    private destroyRef;
+    private document;
+    /** @internal */
+    editorDom: {
+        root: _angular_core.WritableSignal<HTMLElement | null>;
+        getSelection: () => EditableSelection | null;
+        closestWithin: (node: Node | null, selector: string) => HTMLElement | null;
+        markStates: () => RichTextMarkStates | null;
+        toggleInline: (tag: InlineTag) => void;
+        toggleList: (listTag: ListTag) => void;
+        toggleHeading: (tag: HeadingTag) => void;
+        applyLink: (href: string) => void;
+        removeLink: () => void;
+        insertToken: (node: Node) => void;
+        handleBackspace: () => boolean;
+    };
+    value: _angular_core.ModelSignal<string>;
+    touched: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    hidden: _angular_core.InputSignal<boolean>;
+    invalid: _angular_core.InputSignal<boolean>;
+    errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    required: _angular_core.InputSignal<boolean>;
+    name: _angular_core.InputSignal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    hasValue: _angular_core.Signal<boolean>;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"rich-text">;
+    focused: _angular_core.WritableSignal<boolean>;
+    labelId: _angular_core.Signal<string | null>;
+    describedById: _angular_core.Signal<string | null>;
+    boldActive: _angular_core.WritableSignal<boolean>;
+    italicActive: _angular_core.WritableSignal<boolean>;
+    strikeActive: _angular_core.WritableSignal<boolean>;
+    unorderedListActive: _angular_core.WritableSignal<boolean>;
+    orderedListActive: _angular_core.WritableSignal<boolean>;
+    linkActive: _angular_core.WritableSignal<boolean>;
+    headingLevel: _angular_core.WritableSignal<number | null>;
+    /** @internal */
+    lastEmittedMarkdown: string | null;
+    constructor();
+    activate(): void;
+    syncFromDom(): void;
+    refreshActiveMarks(): void;
+    toggleBold(): void;
+    toggleItalic(): void;
+    toggleStrikethrough(): void;
+    toggleUnorderedList(): void;
+    toggleOrderedList(): void;
+    toggleHeading(level: number): 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 finishContentPointerSelection;
+    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;
+    private editable;
+    constructor();
+    protected syncValueFromDom(): void;
+    protected interceptBackspaceKey(event: KeyboardEvent): void;
+    protected interceptFormattingCommand(event: InputEvent): 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"; }; }]>;
+}
+
+declare const RICH_TEXT_EDITOR_IMPORTS: readonly [typeof RichTextEditorComponent, typeof RichTextEditorDirective];
+
 declare const SELECTION_LIST_TOKEN: InjectionToken<SelectionListDirectiveBase<unknown>>;
 declare const SELECTION_LIST_MULTIPLE: InjectionToken<boolean>;
 type SelectionListItem<TValue = unknown> = {
@@ -633,10 +760,6 @@ declare class SelectionListDirective implements SelectionListDirectiveBase, Form
 }
 
 declare class CheckboxGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -654,6 +777,10 @@ declare class CheckboxGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
@@ -704,10 +831,6 @@ declare class CheckboxOptionComponent {
 }
 
 declare class RadioGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -725,6 +848,10 @@ declare class RadioGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
@@ -743,10 +870,6 @@ declare class RadioComponent {
 }
 
 declare class SegmentedButtonGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -764,6 +887,10 @@ declare class SegmentedButtonGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
@@ -847,6 +974,14 @@ type GridLayoutEntry = {
     id: string;
     position: GridItemPosition;
 };
+/**
+ * Contract for a grid item's `actionsComponent`: a component that receives the item's `itemId` and
+ * `data` as inputs. Both are always provided by the grid.
+ */
+type GridItemActionsComponent<TData = unknown> = Type<{
+    itemId: InputSignal<string>;
+    data: InputSignal<TData>;
+}>;
 type GridComponentRegistration<TData = unknown> = {
     component: Type<{
         data: InputSignal<TData>;
@@ -884,13 +1019,16 @@ type GridDragState = {
 };
 declare class GridDirective {
     private injector;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    private gridConfig;
+    private reducedMotion;
     breakpoints: _angular_core.InputSignal<GridBreakpointConfig[]>;
     rowHeight: _angular_core.InputSignal<number>;
     gap: _angular_core.InputSignal<number>;
     initialItems: _angular_core.InputSignal<GridItemConfig[]>;
     readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     layoutChange: _angular_core.OutputEmitterRef<GridSerializedState>;
-    private gridConfig;
     registrations: _angular_core.Signal<GridComponentRegistration[]>;
     private dimensions;
     private itemConfigs;
@@ -898,40 +1036,53 @@ declare class GridDirective {
     dragState: _angular_core.WritableSignal<GridDragState | null>;
     private constraintsRegistry;
     private resizeBaseLayout;
-    private itemElements;
-    private ghostElement;
-    private rectSnapshot;
+    private pendingResize;
+    private lastResizeTarget;
+    leavingIds: _angular_core.WritableSignal<ReadonlySet<string>>;
+    isResizeActive: _angular_core.WritableSignal<boolean>;
+    private animationsReady;
+    private isContainerResizing;
     containerWidth: _angular_core.Signal<number>;
+    isReady: _angular_core.Signal<boolean>;
+    animationsEnabled: _angular_core.Signal<boolean>;
     activeBreakpoint: _angular_core.Signal<string>;
     activeColumns: _angular_core.Signal<number>;
+    private paddings;
+    geometry: _angular_core.Signal<_ethlete_components.GridGeometry>;
     items: _angular_core.Signal<GridItemConfig[]>;
     baseLayout: _angular_core.Signal<GridLayoutEntry[]>;
     layout: _angular_core.Signal<GridLayoutEntry[]>;
+    containerHeightPx: _angular_core.Signal<number>;
+    protected hostHeight: _angular_core.Signal<number | null>;
+    protected containerTransition: _angular_core.Signal<"none" | "height var(--et-grid-anim-duration, 250ms) cubic-bezier(0.2, 0, 0, 1)">;
     ghostPosition: _angular_core.Signal<GridItemPosition | null>;
     constructor();
+    getContainerOrigin(): {
+        left: number;
+        top: number;
+    };
     registerConstraints(id: string, constraints: GridItemConstraints): void;
-    registerItem(id: string, options: {
-        el: HTMLElement;
-        constraints: GridItemConstraints;
-    }): void;
-    unregisterItem(id: string): void;
-    setGhostElement(el: HTMLElement | null): void;
+    unregisterConstraints(id: string): void;
     getConstraints(id: string): GridItemConstraints;
-    snapshotRects(): void;
-    animateLayoutTransition(options?: {
-        excludeIds?: Set<string>;
-        scaleIds?: Set<string>;
+    beginDrag(itemId: string): GridItemPosition | null;
+    updateDragTarget(cell: {
+        col: number;
+        row: number;
     }): void;
-    beginDrag(itemId: string): void;
-    updateDragTarget(targetPosition: GridItemPosition): void;
-    commitDrag(): void;
+    commitDrag(): GridItemPosition | null;
+    cancelDrag(): void;
+    beginResize(itemId: string): GridItemPosition | null;
+    updateResize(itemId: string, target: GridItemPosition): void;
+    commitResize(): GridItemPosition | null;
+    cancelResize(): void;
+    /** One-shot resize (keyboard / programmatic): begin + update + commit in a single call. */
+    resizeItem(options: ResizeItemOptions): void;
     addItem(type: string, data: unknown): void;
     removeItem(id: string): void;
     moveItem(id: string, newPosition: GridItemPosition): void;
-    resizeItem(options: ResizeItemOptions): void;
-    commitResize(): void;
     getSerializedState(): GridSerializedState;
     restoreState(state: GridSerializedState): void;
+    private finalizeRemove;
     private placeItem;
     private shrinkNeighbors;
     /** Compact all visited breakpoints (layoutOverrides entries) after an item is removed. */
@@ -943,8 +1094,240 @@ declare class GridDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDirective, "[etGrid]", ["etGrid"], { "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "initialItems": { "alias": "initialItems"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; }, never, never, true, never>;
 }
 
+type AutoScrollPointer = {
+    clientX: number;
+    clientY: number;
+};
+type AutoScroller = {
+    /** Begin the edge-proximity loop. No-op if already running. */
+    start: (pointer: AutoScrollPointer) => void;
+    /** Feed the latest pointer position. */
+    update: (pointer: AutoScrollPointer) => void;
+    stop: () => void;
+};
+declare const findScrollableAncestor: (start: Element | null) => HTMLElement | null;
+declare const createAutoScroller: (options: {
+    document: Document;
+    getScrollElement: () => HTMLElement | null;
+    threshold?: number;
+    maxSpeed?: number;
+}) => AutoScroller;
+
+/** A rectangle in container-relative pixels (x/y measured from the container's padding box). */
+type PixelRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type GridGeometry = {
+    /** Width available for columns (container client width minus horizontal padding). */
+    contentWidth: number;
+    columns: number;
+    gap: number;
+    rowHeight: number;
+    cellWidth: number;
+    /** Horizontal distance between the left edges of two adjacent columns. */
+    strideX: number;
+    /** Vertical distance between the top edges of two adjacent rows. */
+    strideY: number;
+    /** Container padding-left - the x of column 0. */
+    originX: number;
+    /** Container padding-top - the y of row 0. */
+    originY: number;
+};
+/**
+ * Effective span bounds for a resize gesture. Grid bounds and item constraints are
+ * unified in span units per edge, so the clamped pixel rect and the snapped span
+ * are always derived from the same limits and can never disagree.
+ */
+type ResizeSpanBounds = {
+    minColSpan: number;
+    maxColSpan: number;
+    minRowSpan: number;
+    maxRowSpan: number;
+};
+declare const computeGeometry: (options: {
+    contentWidth: number;
+    columns: number;
+    gap: number;
+    rowHeight: number;
+    originX?: number;
+    originY?: number;
+}) => GridGeometry;
+declare const spanWidth: (span: number, geometry: GridGeometry) => number;
+declare const spanHeight: (span: number, geometry: GridGeometry) => number;
+declare const positionToPixelRect: (position: GridItemPosition, geometry: GridGeometry) => PixelRect;
+/** Pixel height of the given number of rows (content only, no container padding). */
+declare const rowsToPixelHeight: (rows: number, geometry: GridGeometry) => number;
+declare const pixelRectsEqual: (a: PixelRect | null, b: PixelRect | null) => boolean;
+declare const positionsEqual: (a: GridItemPosition | null, b: GridItemPosition | null) => boolean;
+declare const SNAP_HYSTERESIS = 0.1;
+/**
+ * Rounds a raw cell-unit value to the nearest integer with a hysteresis margin
+ * relative to the last snapped value: the rounding boundary is shifted by
+ * SNAP_HYSTERESIS against the direction of travel, so a pointer jittering exactly
+ * on a cell midpoint cannot flap the snap back and forth (each flap would
+ * re-trigger a full neighbour reflow).
+ */
+declare const hysteresisRound: (raw: number, last: number | null) => number;
+declare const resizeSpanBounds: (options: {
+    edge: ResizeEdge;
+    start: GridItemPosition;
+    constraints: GridItemConstraints;
+    columns: number;
+}) => ResizeSpanBounds;
+declare const clampResizeRect: (options: {
+    edge: ResizeEdge;
+    dx: number;
+    dy: number;
+    startRect: PixelRect;
+    bounds: ResizeSpanBounds;
+    geometry: GridGeometry;
+}) => PixelRect;
+declare const snapResizeSpan: (options: {
+    edge: ResizeEdge;
+    rect: PixelRect;
+    start: GridItemPosition;
+    bounds: ResizeSpanBounds;
+    geometry: GridGeometry;
+    lastSnap: GridItemPosition | null;
+}) => GridItemPosition;
+declare const projectDragCell: (options: {
+    float: {
+        x: number;
+        y: number;
+    };
+    colSpan: number;
+    geometry: GridGeometry;
+    lastTarget: {
+        col: number;
+        row: number;
+    } | null;
+}) => {
+    col: number;
+    row: number;
+};
+
+type FindCollisionOptions = {
+    entries: GridLayoutEntry[];
+    position: GridItemPosition;
+    excludeId?: string;
+};
+type AutoPlaceOptions = {
+    entries: GridLayoutEntry[];
+    colSpan: number;
+    rowSpan: number;
+    columns: number;
+};
+type ClampPositionOptions = {
+    position: GridItemPosition;
+    constraints: GridItemConstraints;
+    columns: number;
+};
+type ResolveCollisionsOptions = {
+    entries: GridLayoutEntry[];
+    movedId: string;
+    columns: number;
+    originPosition?: GridItemPosition;
+    rowFloors?: RowFloors;
+};
+/**
+ * Per-item lower bound (in rows) for the upward compaction pass. An item with a
+ * floor is never pulled above it — used during live resize gestures to keep
+ * unrelated items from collapsing into freshly vacated space while the pointer
+ * is still down. Items without an entry compact all the way up (floor 0).
+ */
+type RowFloors = ReadonlyMap<string, number>;
+type CompactLayoutOptions = {
+    entries: GridLayoutEntry[];
+    columns: number;
+    rowFloors?: RowFloors;
+};
+/**
+ * Checks whether two grid items overlap.
+ */
+declare const itemsCollide: (a: GridItemPosition, b: GridItemPosition) => boolean;
+/**
+ * Returns the first item that collides with the given position, or undefined if none.
+ */
+declare const findCollision: (options: FindCollisionOptions) => GridLayoutEntry | undefined;
+/**
+ * Compacts the layout vertically (moves items up as far as possible without collision).
+ *
+ * Also acts as a self-healing normaliser: positions that overflow the grid horizontally
+ * (e.g. stale data from a wider breakpoint clamped into a narrower one — a colSpan of 12
+ * or a col of 8 in a 6-column grid) are first clamped back into bounds, then any items
+ * left overlapping are pushed down before the upward compaction runs. This guarantees the
+ * returned layout is always in-bounds and overlap-free regardless of the input — clamping
+ * a column alone is not enough, because it can drop an item on top of an existing one.
+ */
+declare const compactLayout: (options: CompactLayoutOptions) => GridLayoutEntry[];
+/**
+ * Finds the first available position for an item with the given span in a grid.
+ * Uses top-left gravity: scans row by row, column by column.
+ */
+declare const autoPlace: (options: AutoPlaceOptions) => GridItemPosition;
+/**
+ * Validates and clamps a position to respect grid boundaries and item constraints.
+ */
+declare const clampPosition: (options: ClampPositionOptions) => {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+};
+/**
+ * Resolves collisions by pushing items down when a moved/resized item overlaps others.
+ * If exactly one item of the same size collides, they swap positions instead.
+ * Cascades: if pushed items collide with others, those are pushed down too.
+ */
+declare const resolveCollisions: (options: ResolveCollisionsOptions) => GridLayoutEntry[];
+/**
+ * Computes the total number of rows occupied by the layout.
+ */
+declare const computeGridHeight: (entries: GridLayoutEntry[]) => number;
+
+type MapLayoutOptions = {
+    entries: GridLayoutEntry[];
+    fromColumns: number;
+    toColumns: number;
+};
+/**
+ * Resolves the active breakpoint name based on the container width.
+ * Breakpoints are sorted by minWidth descending — the first one whose minWidth is <= containerWidth wins.
+ */
+declare const resolveBreakpoint: (breakpoints: GridBreakpointConfig[], containerWidth: number) => GridBreakpointName;
+/**
+ * Auto-generates a layout for a smaller breakpoint from a larger one.
+ * Items are re-flowed into fewer columns, maintaining their relative order.
+ */
+declare const mapLayoutToBreakpoint: (options: MapLayoutOptions) => GridLayoutEntry[];
+declare const DEFAULT_BREAKPOINTS: GridBreakpointConfig[];
+
+type SerializeOptions = {
+    items: GridItemConfig[];
+    breakpoints: GridBreakpointConfig[];
+    rowHeight: number;
+};
+/**
+ * Serializes the current grid state into a JSON-compatible object suitable for DB storage.
+ */
+declare const serializeGridLayout: (options: SerializeOptions) => GridSerializedState;
+/**
+ * Deserializes a stored grid state back into working configuration.
+ * Returns breakpoint configs and item configs.
+ */
+declare const deserializeGridLayout: (state: GridSerializedState, breakpointMinWidths: Record<string, number>) => {
+    breakpoints: GridBreakpointConfig[];
+    items: GridItemConfig[];
+    rowHeight: number;
+};
+
 declare class GridItemDirective {
     private grid;
+    private injector;
+    private destroyRef;
     hostElement: ElementRef<HTMLElement>;
     itemId: _angular_core.InputSignal<string>;
     minColSpan: _angular_core.InputSignalWithTransform<number, unknown>;
@@ -952,16 +1335,26 @@ declare class GridItemDirective {
     minRowSpan: _angular_core.InputSignalWithTransform<number, unknown>;
     maxRowSpan: _angular_core.InputSignalWithTransform<number, unknown>;
     isBeingDragged: _angular_core.Signal<boolean>;
-    private frozenPosition;
     currentPosition: _angular_core.Signal<_ethlete_components.GridItemPosition | null>;
-    renderPosition: _angular_core.Signal<_ethlete_components.GridItemPosition | null>;
-    currentCol: _angular_core.Signal<number>;
-    currentRow: _angular_core.Signal<number>;
-    currentColSpan: _angular_core.Signal<number>;
-    currentRowSpan: _angular_core.Signal<number>;
-    protected gridColumn: _angular_core.Signal<string>;
-    protected gridRow: _angular_core.Signal<string>;
+    /** The layout-derived target rect in container-relative pixels. */
+    slotRect: _angular_core.Signal<PixelRect | null>;
+    private renderModeSignal;
+    private liveRect;
+    private isSettlingSignal;
+    private enteringSignal;
+    renderMode: _angular_core.Signal<"layout" | "direct">;
+    isSettling: _angular_core.Signal<boolean>;
+    protected entering: _angular_core.Signal<boolean>;
+    protected leaving: _angular_core.Signal<boolean>;
+    /** The rect currently bound to the host: pointer-driven while direct-controlled, the slot otherwise. */
+    renderedRect: _angular_core.Signal<PixelRect | null>;
+    protected translateStyle: _angular_core.Signal<string | null>;
+    protected transitionStyle: _angular_core.Signal<"none" | "translate var(--et-grid-anim-duration, 250ms) cubic-bezier(0.2, 0, 0, 1), width var(--et-grid-anim-duration, 250ms) cubic-bezier(0.2, 0, 0, 1), height var(--et-grid-anim-duration, 250ms) cubic-bezier(0.2, 0, 0, 1), scale 200ms cubic-bezier(0.2, 0, 0, 1), opacity 200ms cubic-bezier(0.2, 0, 0, 1)">;
+    private settleListener;
     constructor();
+    startDirectControl(): void;
+    updateDirectRect(rect: PixelRect): void;
+    stopDirectControl(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridItemDirective, "[etGridItem]", ["etGridItem"], { "itemId": { "alias": "itemId"; "required": true; "isSignal": true; }; "minColSpan": { "alias": "minColSpan"; "required": false; "isSignal": true; }; "maxColSpan": { "alias": "maxColSpan"; "required": false; "isSignal": true; }; "minRowSpan": { "alias": "minRowSpan"; "required": false; "isSignal": true; }; "maxRowSpan": { "alias": "maxRowSpan"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -969,16 +1362,27 @@ declare class GridItemDirective {
 declare class GridDragDirective {
     protected grid: _ethlete_components.GridDirective;
     private gridItem;
-    private injector;
     private elementRef;
+    private destroyRef;
+    private document;
     dragHandle: DragHandleDirective;
-    private renderer;
-    private dragStartClient;
-    private dragPixelOffset;
-    protected dragTransform: _angular_core.Signal<string>;
+    private origin;
+    private startBreakpoint;
+    private grabOffset;
+    private containerOrigin;
+    private lastPointer;
+    private lastTarget;
+    private gestureListeners;
+    private autoScroller;
     constructor();
-    private applyFixed;
-    private releaseFixed;
+    private startDrag;
+    private trackDragMove;
+    private applyPointer;
+    private settleDrag;
+    private cancelDrag;
+    private finishGesture;
+    private attachGestureListeners;
+    private detachGestureListeners;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDragDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDragDirective, "[etGridDrag]", never, {}, {}, never, never, true, [{ directive: typeof _ethlete_core.DragHandleDirective; inputs: {}; outputs: { "dragStarted": "dragStarted"; "dragMoved": "dragMoved"; "dragEnded": "dragEnded"; }; }]>;
 }
@@ -986,12 +1390,27 @@ declare class GridDragDirective {
 declare class GridResizeDirective {
     private grid;
     private gridItem;
+    private destroyRef;
+    private document;
     isResizing: _angular_core.WritableSignal<boolean>;
     resizeEdges: _angular_core.Signal<ResizeEdge[]>;
-    private resizeStartPos;
+    private start;
+    private startBreakpoint;
+    private lastSnap;
+    private lastEvent;
+    private startContainerOrigin;
+    private containerOrigin;
+    private gestureListeners;
+    private autoScroller;
+    constructor();
     beginResize(): void;
     updateResize(event: ResizeMoveEvent): void;
     finishResize(): void;
+    cancelResize(): void;
+    private applyResize;
+    private finishGesture;
+    private attachGestureListeners;
+    private detachGestureListeners;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridResizeDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridResizeDirective, "[etGridResize]", never, {}, {}, never, never, true, never>;
 }
@@ -1002,12 +1421,9 @@ type GridConfig = {
     registrations: GridComponentRegistration[];
     interactiveAriaLabel: string;
     readonlyAriaLabel: string;
-    dragHandleAriaLabel: string;
+    removeActionAriaLabel: string;
     transformer: (text: string, locale: string) => string;
-    /** Replaces the default drag handle for all registered items. Receives `data` and `itemId` as inputs. */
-    dragHandleComponent?: Type<unknown>;
-    /** Replaces the default ✕ button for all registered items. Receives `data` and `itemId` as inputs. */
-    actionsComponent?: Type<unknown>;
+    actionsComponent?: GridItemActionsComponent | null;
 };
 declare const provideGridConfig: (valueOverride?: Partial<GridConfig> | undefined) => _angular_core.Provider[];
 declare const injectGridConfig: {
@@ -1040,21 +1456,16 @@ declare const fromGridPosition: (pos: GridItemPosition) => {
 
 declare class GridComponent {
     grid: GridDirective;
-    private ghostRef;
     private gridConfig;
     private locale;
-    protected isReadOnly: _angular_core.Signal<boolean>;
-    protected dragHandleComponent: _angular_core.Signal<_angular_core.Type<unknown> | undefined>;
-    protected actionsComponent: _angular_core.Signal<_angular_core.Type<unknown> | undefined>;
+    protected actionsComponent: _angular_core.Signal<_ethlete_components.GridItemActionsComponent | null>;
     protected registeredItems: _angular_core.Signal<{
         item: _ethlete_components.GridItemConfig;
         reg: _ethlete_components.GridComponentRegistration;
     }[]>;
     protected ariaLabel: _angular_core.Signal<string>;
-    protected gridColumns: _angular_core.Signal<number>;
-    protected gridGap: _angular_core.Signal<string>;
-    protected gridRowHeight: _angular_core.Signal<string>;
-    constructor();
+    protected ghostRect: _angular_core.Signal<_ethlete_components.PixelRect | null>;
+    protected ghostTransition: _angular_core.Signal<"none" | "translate 200ms cubic-bezier(0.2, 0, 0, 1), width 200ms cubic-bezier(0.2, 0, 0, 1), height 200ms cubic-bezier(0.2, 0, 0, 1)">;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridComponent, "et-grid, [et-grid]", never, {}, {}, never, ["*"], true, [{ directive: typeof GridDirective; inputs: { "breakpoints": "breakpoints"; "rowHeight": "rowHeight"; "gap": "gap"; "initialItems": "initialItems"; "readOnly": "readOnly"; }; outputs: { "layoutChange": "layoutChange"; }; }]>;
 }
@@ -1066,18 +1477,33 @@ declare class GridItemComponent {
     private parentSurfaceProvider;
     gridDrag: GridDragDirective;
     gridResize: GridResizeDirective;
+    private surfaceThemes;
     ariaLabel: _angular_core.InputSignal<string>;
     removed: _angular_core.OutputEmitterRef<void>;
-    private surfaceThemes;
-    private gridConfig;
-    private locale;
     protected isReadOnly: _angular_core.Signal<boolean>;
-    protected dragHandleAriaLabel: _angular_core.Signal<string>;
     private resolvedSurface;
     constructor();
+    protected blockPointerDownWhenReadOnly(event: PointerEvent): void;
     applyKeyboardShortcut(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemComponent, "et-grid-item, [et-grid-item]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["[etGridItemDragHandle]", "*", "[etGridItemAction]"], true, [{ directive: typeof GridItemDirective; inputs: { "itemId": "itemId"; "minColSpan": "minColSpan"; "maxColSpan": "maxColSpan"; "minRowSpan": "minRowSpan"; "maxRowSpan": "maxRowSpan"; }; outputs: {}; }, { directive: typeof GridDragDirective; inputs: {}; outputs: {}; }, { directive: typeof GridResizeDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemComponent, "et-grid-item, [et-grid-item]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*", "[etGridItemAction]"], true, [{ directive: typeof GridItemDirective; inputs: { "itemId": "itemId"; "minColSpan": "minColSpan"; "maxColSpan": "maxColSpan"; "minRowSpan": "minRowSpan"; "maxRowSpan": "maxRowSpan"; }; outputs: {}; }, { directive: typeof GridDragDirective; inputs: {}; outputs: {}; }, { directive: typeof GridResizeDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GridItemToolbarComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemToolbarComponent, "et-grid-item-toolbar, [et-grid-item-toolbar]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GridItemDefaultActionsComponent {
+    private grid;
+    private gridConfig;
+    private locale;
+    itemId: _angular_core.InputSignal<string>;
+    data: _angular_core.InputSignal<unknown>;
+    protected removeAriaLabel: _angular_core.Signal<string>;
+    protected remove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemDefaultActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemDefaultActionsComponent, "et-grid-item-default-actions", never, { "itemId": { "alias": "itemId"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -1130,12 +1556,49 @@ declare const GRID_ERROR_CODES: {
     readonly INVALID_LAYOUT_STATE: 1903;
 };
 
-declare const GridImports: readonly [typeof GridComponent, typeof GridItemComponent, typeof GridDebugComponent];
+declare const GridImports: readonly [typeof GridComponent, typeof GridItemComponent, typeof GridItemToolbarComponent, typeof GridItemDefaultActionsComponent, typeof GridDebugComponent];
 
 type IconDefinition = {
     name: string;
+    /**
+     * Optional style variant (e.g. `'solid'`, `'light'`, `'regular'`). Lets the same icon
+     * `name` exist in several styles without encoding the style into the name. Icons
+     * registered without a variant are matched by their bare name.
+     */
+    variant?: string;
     data: string;
 };
+/**
+ * Augmentable registry for the literal set of icon names an app uses. Empty by default,
+ * which keeps `etIcon` typed as plain `string`. The `@ethlete/components:icons` generator
+ * writes an augmentation for this interface, or you can augment it manually:
+ *
+ * ```ts
+ * declare module '@ethlete/components' {
+ *   interface EthleteIconNameRegistry {
+ *     name: 'shield' | 'plus';
+ *   }
+ * }
+ * ```
+ */
+interface EthleteIconNameRegistry {
+}
+/**
+ * Augmentable registry for the literal set of icon variants an app uses. Empty by default,
+ * which keeps the `variant` input typed as plain `string`. See {@link EthleteIconNameRegistry}.
+ */
+interface EthleteIconVariantRegistry {
+}
+type RegisteredIconName = EthleteIconNameRegistry extends {
+    name: infer N extends string;
+} ? N : string;
+type RegisteredIconVariant = EthleteIconVariantRegistry extends {
+    name: infer V extends string;
+} ? V : string;
+/** Variant the {@link IconDirective} falls back to when `etIcon` is used without an explicit `variant`. */
+declare const DEFAULT_ICON_VARIANT = "solid";
+/** Composite registry key for an icon `name` plus an optional `variant`. */
+declare const iconRegistryKey: (name: string, variant?: string | null) => string;
 declare const ICONS_TOKEN: InjectionToken<Record<string, IconDefinition>>;
 declare const provideIcons: (...icons: IconDefinition[]) => {
     provide: InjectionToken<Record<string, IconDefinition>>;
@@ -1146,6 +1609,8 @@ declare const ARROW_OUT_UP_RIGHT_ICON: IconDefinition;
 
 declare const ARROW_RIGHT_ICON: IconDefinition;
 
+declare const BOLD_ICON: IconDefinition;
+
 declare const CHEVRON_ICON: IconDefinition;
 
 declare const CLIPBOARD_CHECK_ICON: IconDefinition;
@@ -1156,6 +1621,12 @@ declare const FOCUS_FRAME_ICON: IconDefinition;
 
 declare const GRID_2X2_ICON: IconDefinition;
 
+declare const HEADING_1_ICON: IconDefinition;
+
+declare const HEADING_2_ICON: IconDefinition;
+
+declare const HEADING_3_ICON: IconDefinition;
+
 declare const ICON_ERROR_CODES: {
     readonly NO_ICONS_PROVIDED: 1800;
     readonly ICON_NOT_FOUND: 1801;
@@ -1170,21 +1641,33 @@ declare const ICON_DIRECTIVE_TOKEN: InjectionToken<IconDirective>;
 declare class IconDirective {
     private icons;
     private sanitizer;
-    iconNameToUse: _angular_core.InputSignal<string>;
+    iconNameToUse: InputSignal<RegisteredIconName>;
+    variant: InputSignal<RegisteredIconVariant | undefined>;
     allowHardcodedColor: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private resolvedIcon;
     iconSrc: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
     hostClasses: _angular_core.Signal<string>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconDirective, "[etIcon]", never, { "iconNameToUse": { "alias": "etIcon"; "required": true; "isSignal": true; }; "allowHardcodedColor": { "alias": "allowHardcodedColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconDirective, "[etIcon]", never, { "iconNameToUse": { "alias": "etIcon"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "allowHardcodedColor": { "alias": "allowHardcodedColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+declare const ITALIC_ICON: IconDefinition;
+
+declare const LINK_ICON: IconDefinition;
+
+declare const LIST_BULLETED_ICON: IconDefinition;
+
+declare const LIST_NUMBERED_ICON: IconDefinition;
+
 declare const LOCK_ICON: IconDefinition;
 
 declare const PENCIL_ICON: IconDefinition;
 
 declare const PLUS_ICON: IconDefinition;
 
+declare const STRIKETHROUGH_ICON: IconDefinition;
+
 declare const TIMES_ICON: IconDefinition;
 
 declare const TRIANGLE_EXCLAMATION_ICON: IconDefinition;
@@ -1228,47 +1711,754 @@ declare class SpinnerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "et-spinner", never, { "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "track": { "alias": "track"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "determinate": { "alias": "determinate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class NotificationActionDirective {
-    private notification;
-    constructor();
-    runAction(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationActionDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationActionDirective, "[etNotificationAction]", ["etNotificationAction"], {}, {}, never, never, true, never>;
-}
-
-declare class NotificationDismissDirective {
-    private notification;
-    constructor();
-    dismiss(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDismissDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDismissDirective, "[etNotificationDismiss]", ["etNotificationDismiss"], {}, {}, never, never, true, never>;
-}
-
-declare class NotificationItemDirective {
-    private elementRef;
-    private stack;
-    ref: _angular_core.InputSignal<{
-        id: string;
-        entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
-        update: (partial: Partial<_ethlete_components.NotificationConfig>) => void;
-        dismiss: () => void;
-        pauseTimer: () => void;
-        resumeTimer: () => void;
-        afterDismissed: () => rxjs.Observable<void>;
-        markDismissed: () => void;
-    }>;
+declare class MenuContextTriggerDirective {
+    private menu;
+    private document;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    private repositionSubscription;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationItemDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationItemDirective, "[etNotificationItem]", never, { "ref": { "alias": "etNotificationItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-type RegisteredNotificationItem = {
+    isOpen(): boolean;
+    protected handleContextMenu(event: MouseEvent): void;
+    private attachRepositionListener;
+    private detachRepositionListener;
+    private isEventOnZone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContextTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContextTriggerDirective, "[etMenuContextTrigger]", ["etMenuContextTrigger"], {}, {}, 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;
-    el: HTMLElement;
-};
-declare class NotificationStackDirective {
-    protected context: _ethlete_components.NotificationStackContext;
-    private destroyRef;
+    /** 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 OverlayConfig = {
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+    id?: string;
+    /**
+     * 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;
+    hasBackdrop?: boolean;
+    disableClose?: boolean;
+    /**
+     * Bindings applied to the overlay component, using Angular's native binding API
+     * (`inputBinding`, `outputBinding`, `twoWayBinding`).
+     */
+    bindings?: Binding[];
+    ariaDescribedBy?: string | null;
+    ariaLabelledBy?: string | null;
+    ariaLabel?: string | null;
+    autoFocus?: OverlayAutoFocusTarget | string | false;
+    restoreFocus?: boolean;
+    providers?: StaticProvider[];
+    hostClass?: string | string[];
+    backdropClass?: string | string[];
+    panelClass?: string | string[];
+    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;
+    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;
+    updatePositionStrategy: (strategy: OverlayRuntimePositionStrategy) => 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;
+    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;
+    updatePositionStrategy: (strategy: OverlayRuntimePositionStrategy) => void;
+    attachComponentInstanceOverride: (getter: () => object | null) => void;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<unknown>;
+    afterClosed: () => Observable<unknown>;
+    attachRuntime: (runtimeRef: OverlayRuntimeRef<object, unknown>) => void;
+}>;
+
+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 OverlayTriggerDirective {
+    private overlay;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    toggle(): void;
+    isOpen(): boolean;
+    expanded(): boolean | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTriggerDirective, "[etOverlayTrigger]", ["etOverlayTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayDirective {
+    private destroyRef;
+    private overlayManager;
+    mode: _angular_core.InputSignal<OverlayMode>;
+    role: _angular_core.InputSignal<OverlayRole | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    disableClose: _angular_core.InputSignal<boolean>;
+    autoFocus: _angular_core.InputSignal<string | false | undefined>;
+    restoreFocus: _angular_core.InputSignal<boolean>;
+    hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
+    closeOnEscape: _angular_core.InputSignal<boolean>;
+    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
+    hostClass: _angular_core.InputSignal<string | string[] | undefined>;
+    backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
+    panelClass: _angular_core.InputSignal<string | string[] | undefined>;
+    placement: _angular_core.InputSignal<Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    autoResize: _angular_core.InputSignal<boolean>;
+    shift: _angular_core.InputSignal<boolean>;
+    autoHide: _angular_core.InputSignal<boolean>;
+    autoCloseIfReferenceHidden: _angular_core.InputSignal<boolean>;
+    mirrorWidth: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    registeredAnchor: _angular_core.WritableSignal<OverlayAnchorDirective | null>;
+    /** @internal */
+    registeredSurface: _angular_core.WritableSignal<OverlaySurfaceDirective | null>;
+    /** @internal */
+    registeredTrigger: _angular_core.WritableSignal<OverlayTriggerDirective | null>;
+    /** @internal */
+    overlayRef: _angular_core.WritableSignal<OverlayRef<OverlayTemplateHostComponent, unknown> | null>;
+    isMounted: _angular_core.Signal<boolean>;
+    private originElement;
+    constructor();
+    show(): void;
+    hide(result?: unknown): void;
+    toggle(): void;
+    /** @internal */
+    unregisterTrigger(trigger: OverlayTriggerDirective): void;
+    /** @internal */
+    unregisterAnchor(anchor: OverlayAnchorDirective): void;
+    /** @internal */
+    unregisterSurface(surface: OverlaySurfaceDirective): void;
+    private mountOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayDirective, "[etOverlay]", ["etOverlay"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePointer": { "alias": "closeOnOutsidePointer"; "required": false; "isSignal": true; }; "hostClass": { "alias": "hostClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; "isSignal": true; }; "mirrorWidth": { "alias": "mirrorWidth"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+type OverlaySurfaceContext = {
+    $implicit: OverlayDirective;
+    overlay: OverlayDirective;
+    close: (result?: unknown) => void;
+};
+declare class OverlaySurfaceDirective {
+    private overlay;
+    templateRef: TemplateRef<OverlaySurfaceContext>;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySurfaceDirective, "ng-template[etOverlaySurface]", ["etOverlaySurface"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayTemplateHostComponent {
+    protected template: _angular_core.InputSignal<TemplateRef<OverlaySurfaceContext>>;
+    protected context: _angular_core.InputSignal<OverlaySurfaceContext>;
+    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, never>;
+}
+
+declare class MenuPanelDirective {
+    /** @internal */
+    menu: MenuDirective | null;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    protected labelledBy: _angular_core.Signal<string | null>;
+    protected busy: _angular_core.Signal<true | null>;
+    constructor();
+    /** @internal */
+    focus(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    protected handlePointerEnter(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuPanelDirective, "[etMenuPanel]", ["etMenuPanel"], {}, {}, never, never, true, never>;
+}
+
+declare class MenuSearchDirective {
+    private menu;
+    private document;
+    elementRef: ElementRef<HTMLInputElement>;
+    private destroyRef;
+    query: _angular_core.ModelSignal<string>;
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    error: _angular_core.InputSignal<string | null>;
+    /** @internal Id of the element rendering the error message, set by the component displaying it. */
+    errorElementId: _angular_core.WritableSignal<string | null>;
+    constructor();
+    /** @internal */
+    isFocused(): boolean;
+    /** @internal */
+    focus(options?: {
+        select?: boolean;
+    }): void;
+    /** @internal Focuses the input and appends a character typed while an item had focus. */
+    appendCharacter(character: string): void;
+    clear(): void;
+    protected handleInput(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSearchDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSearchDirective, "input[etMenuSearch]", ["etMenuSearch"], { "query": { "alias": "query"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "query": "queryChange"; }, never, never, true, never>;
+}
+
+type MenuSurfaceContext = {
+    $implicit: MenuDirective;
+    menu: MenuDirective;
+    close: (result?: unknown) => void;
+};
+declare class MenuSurfaceDirective {
+    private menu;
+    templateRef: TemplateRef<MenuSurfaceContext>;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSurfaceDirective, "ng-template[etMenuSurface]", ["etMenuSurface"], {}, {}, never, never, true, never>;
+}
+
+declare class MenuTriggerDirective {
+    /** @internal The menu this trigger opens - for submenu trigger items, that is the submenu. */
+    menu: MenuDirective | null;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    /** @internal The same-element menu item this trigger is combined with, if any. Set by the item. */
+    hostItem: MenuItemDirective | null;
+    constructor();
+    /** @internal */
+    setHostItem(item: MenuItemDirective): void;
+    isOpen(): boolean;
+    protected expanded(): boolean | null;
+    protected controls(): string | null;
+    protected handleClick(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[etMenuTrigger]", ["etMenuTrigger"], {}, {}, never, never, true, never>;
+}
+
+type MenuCloseReason = 'item' | 'escape' | 'tab' | 'outside' | 'api';
+type MenuOpenSource = 'click' | 'hover' | 'keyboard' | 'api';
+type MenuAnchorPoint = {
+    x: number;
+    y: number;
+};
+declare class MenuDirective {
+    private destroyRef;
+    private document;
+    private overlayManager;
+    parent: MenuDirective | null;
+    placement: _angular_core.InputSignal<Placement | "auto">;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | "auto" | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    autoFocus: _angular_core.InputSignal<boolean>;
+    hoverOpen: _angular_core.InputSignal<boolean>;
+    hoverOpenDelay: _angular_core.InputSignal<number>;
+    hoverCloseDelay: _angular_core.InputSignal<number>;
+    disabled: _angular_core.InputSignal<boolean>;
+    open: _angular_core.ModelSignal<boolean>;
+    root: MenuDirective;
+    depth: number;
+    isRoot: boolean;
+    /** @internal */
+    registeredTrigger: _angular_core.WritableSignal<MenuTriggerDirective | null>;
+    /** @internal */
+    registeredContextTrigger: _angular_core.WritableSignal<MenuContextTriggerDirective | null>;
+    /** @internal */
+    registeredSurface: _angular_core.WritableSignal<MenuSurfaceDirective | null>;
+    /** @internal */
+    registeredPanel: _angular_core.WritableSignal<MenuPanelDirective | null>;
+    /** @internal */
+    registeredSearch: _angular_core.WritableSignal<MenuSearchDirective | null>;
+    /** @internal */
+    overlayRef: _angular_core.WritableSignal<OverlayRef<OverlayTemplateHostComponent, unknown> | null>;
+    /** @internal */
+    openSubmenu: _angular_core.WritableSignal<MenuDirective | null>;
+    /** @internal */
+    activeItem: _angular_core.WritableSignal<MenuItemDirective | null>;
+    /** @internal */
+    anchorPoint: _angular_core.WritableSignal<MenuAnchorPoint | null>;
+    private items;
+    /** @internal */
+    sortedItems: _angular_core.Signal<MenuItemDirective[]>;
+    /** @internal */
+    enabledItems: _angular_core.Signal<MenuItemDirective[]>;
+    isMounted: _angular_core.Signal<boolean>;
+    private openSource;
+    private initialFocusTarget;
+    private hoverIntent;
+    private typeahead;
+    private rootListenersCleanup;
+    constructor();
+    show(source?: MenuOpenSource, initialFocus?: 'first' | 'last'): void;
+    hide(): void;
+    toggle(source?: MenuOpenSource): void;
+    /** Closes the whole menu tree, regardless of which level this is called on. */
+    closeAll(reason?: MenuCloseReason): void;
+    /** Opens the menu anchored to a viewport point instead of the trigger element. */
+    openAt(point: MenuAnchorPoint, source?: MenuOpenSource): void;
+    /** @internal Closes this level and returns focus to the trigger item in the parent menu. */
+    closeLevel(reason: MenuCloseReason): void;
+    /** @internal */
+    openSubmenuExclusive(submenu: MenuDirective): void;
+    /** @internal */
+    registerItem(item: MenuItemDirective): void;
+    /** @internal */
+    unregisterItem(item: MenuItemDirective): void;
+    /** @internal */
+    unregisterTrigger(trigger: MenuTriggerDirective): void;
+    /** @internal */
+    unregisterContextTrigger(trigger: MenuContextTriggerDirective): void;
+    /** @internal */
+    unregisterSurface(surface: MenuSurfaceDirective): void;
+    /** @internal */
+    unregisterPanel(panel: MenuPanelDirective): void;
+    /** @internal */
+    unregisterSearch(search: MenuSearchDirective): void;
+    /** @internal */
+    setActiveItem(item: MenuItemDirective, options?: {
+        focus?: boolean;
+    }): void;
+    /** @internal Central keyboard handling for items, the panel, and the search input. */
+    handleKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    notifyItemPointerEnter(item: MenuItemDirective): void;
+    /** @internal Cancels pending submenu hover timers along the ancestor chain. */
+    notifyPanelPointerEnter(): void;
+    /** @internal */
+    focusTrigger(): void;
+    /** @internal True while a pointerdown target belongs to any open pane of this menu's tree. */
+    isTargetInsideTree(target: EventTarget | null): boolean;
+    private isFocusInsideTree;
+    private handleItemHover;
+    private moveActive;
+    private setActiveToEdge;
+    private mountOverlay;
+    private applyInitialFocus;
+    private attachRootInteractionListeners;
+    private detachRootInteractionListeners;
+    private buildStrategies;
+    private buildVirtualAnchoredPosition;
+    private resolvedPlacement;
+    private resolvedFallbackPlacements;
+    private resolvedOffset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuDirective, "[etMenu]", ["etMenu"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "hoverOpen": { "alias": "hoverOpen"; "required": false; "isSignal": true; }; "hoverOpenDelay": { "alias": "hoverOpenDelay"; "required": false; "isSignal": true; }; "hoverCloseDelay": { "alias": "hoverCloseDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+type MenuItemActivationSource = 'pointer' | 'keyboard-enter' | 'keyboard-space';
+type MenuItemActivationEvent = {
+    source: MenuItemActivationSource;
+};
+declare class MenuItemDirective {
+    private nearestMenu;
+    private sameElementTrigger;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    disabled: _angular_core.InputSignal<boolean>;
+    closeOnActivate: _angular_core.InputSignal<boolean | undefined>;
+    activated: _angular_core.OutputEmitterRef<MenuItemActivationEvent>;
+    /** @internal The menu whose item list this item belongs to. */
+    owner: MenuDirective | null;
+    /** @internal The submenu this item opens when it doubles as a submenu trigger. */
+    submenu: MenuDirective | null;
+    /** @internal Role source overriding the default `menuitem`, e.g. with `menuitemradio` or `menuitemcheckbox`. */
+    roleOverride: _angular_core.WritableSignal<Signal<string> | null>;
+    /** @internal Additional disabled state source, e.g. from a composing selection item directive. */
+    disabledOverride: _angular_core.WritableSignal<Signal<boolean> | null>;
+    private defaultCloseOnActivate;
+    private pendingKeyboardSource;
+    protected role: Signal<string>;
+    protected isActive: Signal<boolean>;
+    /** @internal Combines the item's own `disabled` input with a state pushed in by a composing directive. */
+    isDisabled: Signal<boolean>;
+    protected tabIndex: Signal<0 | -1>;
+    constructor();
+    /** @internal Sets whether activation closes the menu tree when the `closeOnActivate` input is not set. */
+    setDefaultCloseOnActivate(value: boolean): void;
+    /** @internal */
+    focus(): void;
+    /** @internal Returns the visible label used for typeahead matching. */
+    textContent(): string;
+    /** @internal Activates via a synthesized click so consumer (click) handlers fire for keyboard users too. */
+    activateFromKeyboard(source: MenuItemActivationSource): void;
+    protected handleClick(event: MouseEvent): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    protected handleMousedown(event: MouseEvent): void;
+    protected handlePointerEnter(event: PointerEvent): void;
+    protected handleFocus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuItemDirective, "[etMenuItem]", ["etMenuItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnActivate": { "alias": "closeOnActivate"; "required": false; "isSignal": true; }; }, { "activated": "activated"; }, never, never, true, never>;
+}
+
+declare const MENU_SELECTION_GROUP_TOKEN: InjectionToken<MenuSelectionGroupDirectiveBase<unknown>>;
+declare const MENU_SELECTION_GROUP_MULTIPLE: InjectionToken<boolean>;
+declare const MENU_SELECTION_ITEM_KIND: InjectionToken<MenuSelectionItemKind>;
+type MenuSelectionItemKind = 'radio' | 'checkbox';
+type MenuSelectionGroupItem<TValue = unknown> = {
+    value: Signal<TValue | undefined>;
+    checked: WritableSignal<boolean>;
+    disabled: Signal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+};
+type MenuSelectionGroupDirectiveBase<TValue = unknown> = {
+    value: WritableSignal<TValue | TValue[] | null>;
+    multiple: Signal<boolean>;
+    disabled: Signal<boolean>;
+    items: Signal<MenuSelectionGroupItem<TValue>[]>;
+    labelId: WritableSignal<string | null>;
+    registerItem(item: MenuSelectionGroupItem<TValue>): void;
+    unregisterItem(item: MenuSelectionGroupItem<TValue>): void;
+    select(item: MenuSelectionGroupItem<TValue>): void;
+    markTouched(): void;
+};
+
+declare class MenuSelectionGroupDirective implements MenuSelectionGroupDirectiveBase {
+    private multipleOverride;
+    value: _angular_core.ModelSignal<unknown>;
+    touched: _angular_core.ModelSignal<boolean>;
+    multipleInput: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    invalid: _angular_core.InputSignal<boolean>;
+    errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    required: _angular_core.InputSignal<boolean>;
+    name: _angular_core.InputSignal<string>;
+    multiple: _angular_core.Signal<boolean>;
+    items: _angular_core.WritableSignal<MenuSelectionGroupItem[]>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    /** @internal Set by a group label component so `aria-labelledby` can reference it. */
+    labelId: _angular_core.WritableSignal<string | null>;
+    constructor();
+    /** @internal */
+    registerItem(item: MenuSelectionGroupItem): void;
+    /** @internal */
+    unregisterItem(item: MenuSelectionGroupItem): void;
+    markTouched(): void;
+    select(item: MenuSelectionGroupItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSelectionGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSelectionGroupDirective, "[etMenuSelectionGroup]", ["etMenuSelectionGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class MenuSelectionItemDirective {
+    private group;
+    private kindOverride;
+    private menuItem;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    value: _angular_core.InputSignal<unknown>;
+    checked: _angular_core.ModelSignal<boolean>;
+    indeterminate: _angular_core.ModelSignal<boolean>;
+    touched: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    invalid: _angular_core.InputSignal<boolean>;
+    errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    required: _angular_core.InputSignal<boolean>;
+    name: _angular_core.InputSignal<string>;
+    kind: _angular_core.Signal<MenuSelectionItemKind>;
+    ariaChecked: _angular_core.Signal<boolean | "mixed">;
+    private isDisabled;
+    constructor();
+    toggle(): void;
+    protected handleBlur(): void;
+    private handleActivation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSelectionItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSelectionItemDirective, "[etMenuSelectionItem]", ["etMenuSelectionItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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; }; }, { "checked": "checkedChange"; "indeterminate": "indeterminateChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class MenuCheckboxGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuCheckboxGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuCheckboxGroupComponent, "et-menu-checkbox-group", never, {}, {}, never, ["et-menu-group-label", "*"], true, [{ directive: typeof MenuSelectionGroupDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }]>;
+}
+
+declare class MenuCheckboxItemComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuCheckboxItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuCheckboxItemComponent, "et-menu-checkbox-item", never, {}, {}, never, ["*"], true, [{ directive: typeof MenuItemDirective; inputs: { "closeOnActivate": "closeOnActivate"; }; outputs: { "activated": "activated"; }; }, { directive: typeof MenuSelectionItemDirective; inputs: { "value": "value"; "checked": "checked"; "indeterminate": "indeterminate"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; "touchedChange": "touchedChange"; }; }]>;
+}
+
+declare const MENU_ERROR_CODES: {
+    readonly MISSING_MENU_SURFACE: 1300;
+    readonly TRIGGER_OUTSIDE_MENU: 1301;
+    readonly SURFACE_OUTSIDE_MENU: 1302;
+    readonly ITEM_OUTSIDE_MENU: 1303;
+    readonly PANEL_OUTSIDE_MENU: 1304;
+    readonly SEARCH_OUTSIDE_MENU: 1305;
+    readonly CONTEXT_TRIGGER_OUTSIDE_MENU: 1306;
+    readonly CONTEXT_TRIGGER_ON_SUBMENU: 1307;
+    readonly SELECTION_ITEM_MISSING_VALUE: 1320;
+    readonly RADIO_ITEM_OUTSIDE_GROUP: 1321;
+};
+
+declare class MenuGroupLabelComponent {
+    private group;
+    private elementRef;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuGroupLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuGroupLabelComponent, "et-menu-group-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const MENU_ITEM_VARIANTS: {
+    readonly DEFAULT: "default";
+    readonly DESTRUCTIVE: "destructive";
+};
+type MenuItemVariant = (typeof MENU_ITEM_VARIANTS)[keyof typeof MENU_ITEM_VARIANTS];
+declare class MenuItemComponent {
+    variant: _angular_core.InputSignal<MenuItemVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "button[et-menu-item], a[et-menu-item]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[etIcon]", "*", "et-menu-item-shortcut"], true, [{ directive: typeof MenuItemDirective; inputs: { "disabled": "disabled"; "closeOnActivate": "closeOnActivate"; }; outputs: { "activated": "activated"; }; }]>;
+}
+
+declare class MenuItemShortcutComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemShortcutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemShortcutComponent, "et-menu-item-shortcut", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MenuRadioGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioGroupComponent, "et-menu-radio-group", never, {}, {}, never, ["et-menu-group-label", "*"], true, [{ directive: typeof MenuSelectionGroupDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }]>;
+}
+
+declare class MenuRadioItemComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioItemComponent, "et-menu-radio-item", never, {}, {}, never, ["*"], true, [{ directive: typeof MenuItemDirective; inputs: { "closeOnActivate": "closeOnActivate"; }; outputs: { "activated": "activated"; }; }, { directive: typeof MenuSelectionItemDirective; inputs: { "value": "value"; "checked": "checked"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "checkedChange": "checkedChange"; "touchedChange": "touchedChange"; }; }]>;
+}
+
+declare class MenuSeparatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSeparatorComponent, "et-menu-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class MenuComponent {
+    private ownColorProvider;
+    private ownSurfaceProvider;
+    private contextColorProvider;
+    private contextSurfaceProvider;
+    protected menu: MenuDirective | null;
+    private surfaceThemes;
+    protected search: _angular_core.Signal<_ethlete_components.MenuSearchDirective | null>;
+    protected searchLoading: _angular_core.Signal<boolean>;
+    protected searchError: _angular_core.Signal<string | null>;
+    protected searchErrorId: string;
+    private resolvedSurface;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "et-menu", never, {}, {}, never, ["input[etMenuSearch]", "*"], true, [{ directive: typeof MenuPanelDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const MENU_IMPORTS: readonly [typeof MenuDirective, typeof MenuTriggerDirective, typeof MenuContextTriggerDirective, typeof MenuSurfaceDirective, typeof MenuPanelDirective, typeof MenuItemDirective, typeof MenuSearchDirective, typeof MenuSelectionGroupDirective, typeof MenuSelectionItemDirective, typeof MenuComponent, typeof MenuItemComponent, typeof MenuItemShortcutComponent, typeof MenuSeparatorComponent, typeof MenuGroupLabelComponent, typeof MenuRadioGroupComponent, typeof MenuRadioItemComponent, typeof MenuCheckboxGroupComponent, typeof MenuCheckboxItemComponent];
+
+declare class NotificationActionDirective {
+    private notification;
+    constructor();
+    runAction(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationActionDirective, "[etNotificationAction]", ["etNotificationAction"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationDismissDirective {
+    private notification;
+    constructor();
+    dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDismissDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDismissDirective, "[etNotificationDismiss]", ["etNotificationDismiss"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationItemDirective {
+    private elementRef;
+    private stack;
+    ref: _angular_core.InputSignal<{
+        id: string;
+        entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+        update: (partial: Partial<_ethlete_components.NotificationConfig>) => void;
+        dismiss: () => void;
+        pauseTimer: () => void;
+        resumeTimer: () => void;
+        afterDismissed: () => rxjs.Observable<void>;
+        markDismissed: () => void;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationItemDirective, "[etNotificationItem]", never, { "ref": { "alias": "etNotificationItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type RegisteredNotificationItem = {
+    id: string;
+    el: HTMLElement;
+};
+declare class NotificationStackDirective {
+    protected context: _ethlete_components.NotificationStackContext;
+    private destroyRef;
     private injector;
     private renderer;
     /** @internal */
@@ -1457,148 +2647,90 @@ 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 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;
-    role?: OverlayRole;
-    positionStrategy?: OverlayPositionStrategy;
-    hasBackdrop?: boolean;
-    disableClose?: boolean;
-    inputBindings?: Record<string, unknown>;
-    ariaDescribedBy?: string | null;
-    ariaLabelledBy?: string | null;
-    ariaLabel?: string | null;
-    autoFocus?: OverlayAutoFocusTarget | string | false;
-    restoreFocus?: boolean;
-    providers?: StaticProvider[];
-    hostClass?: string | string[];
-    backdropClass?: string | string[];
-    panelClass?: string | string[];
-    mode?: OverlayMode;
-    closeOnOutsidePointer?: boolean;
-    closeOnEscape?: boolean;
-};
-
-declare const createOverlayRef: <TComponent extends object, TResult = unknown>(config: OverlayConfig) => {
-    readonly id: string;
-    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;
+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>[];
 };
-type OverlayRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRef<TComponent, TResult>>;
-declare const OVERLAY_REF: InjectionToken<{
-    readonly id: string;
-    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;
-}>;
-
-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: {}; }]>;
-}
-
-declare class OverlayTriggerDirective {
-    private overlay;
-    private destroyRef;
-    elementRef: ElementRef<HTMLElement>;
-    constructor();
-    toggle(): void;
-    isOpen(): boolean;
-    expanded(): boolean | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTriggerDirective, "[etOverlayTrigger]", ["etOverlayTrigger"], {}, {}, never, never, true, never>;
-}
+/** 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 OverlayDirective {
-    private destroyRef;
-    mode: _angular_core.InputSignal<OverlayMode>;
-    role: _angular_core.InputSignal<OverlayRole | undefined>;
-    open: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    disableClose: _angular_core.InputSignal<boolean>;
-    autoFocus: _angular_core.InputSignal<string | false | undefined>;
-    restoreFocus: _angular_core.InputSignal<boolean>;
-    hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
-    closeOnEscape: _angular_core.InputSignal<boolean>;
-    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
-    hostClass: _angular_core.InputSignal<string | string[] | undefined>;
-    backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
-    panelClass: _angular_core.InputSignal<string | string[] | undefined>;
-    placement: _angular_core.InputSignal<Placement>;
-    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
-    offset: _angular_core.InputSignal<OffsetOptions | null>;
-    viewportPadding: _angular_core.InputSignal<Padding | null>;
-    autoResize: _angular_core.InputSignal<boolean>;
-    shift: _angular_core.InputSignal<boolean>;
-    autoHide: _angular_core.InputSignal<boolean>;
-    autoCloseIfReferenceHidden: _angular_core.InputSignal<boolean>;
-    mirrorWidth: _angular_core.InputSignal<boolean>;
+declare const OVERLAY_BODY_TOKEN: InjectionToken<OverlayBodyComponent>;
+type OverlayBodyDividerType = 'static' | 'dynamic' | false;
+declare class OverlayBodyComponent implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private scrollObserver;
     private overlayManager;
-    /** @internal */
-    registeredAnchor: _angular_core.WritableSignal<OverlayAnchorDirective | null>;
-    /** @internal */
-    registeredSurface: _angular_core.WritableSignal<OverlaySurfaceDirective | null>;
-    /** @internal */
-    registeredTrigger: _angular_core.WritableSignal<OverlayTriggerDirective | null>;
-    /** @internal */
-    overlayRef: _angular_core.WritableSignal<OverlayRef<OverlayTemplateHostComponent, unknown> | null>;
-    isMounted: _angular_core.Signal<boolean>;
-    private originElement;
+    dividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    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();
-    show(): void;
-    hide(result?: unknown): void;
-    toggle(): void;
-    /** @internal */
-    unregisterTrigger(trigger: OverlayTriggerDirective): void;
-    /** @internal */
-    unregisterAnchor(anchor: OverlayAnchorDirective): void;
-    /** @internal */
-    unregisterSurface(surface: OverlaySurfaceDirective): void;
-    private mountOverlay;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayDirective, "[etOverlay]", ["etOverlay"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePointer": { "alias": "closeOnOutsidePointer"; "required": false; "isSignal": true; }; "hostClass": { "alias": "hostClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; "isSignal": true; }; "mirrorWidth": { "alias": "mirrorWidth"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+    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: {}; }]>;
 }
 
-type OverlaySurfaceContext = {
-    $implicit: OverlayDirective;
-    overlay: OverlayDirective;
-    close: (result?: unknown) => void;
-};
-declare class OverlaySurfaceDirective {
-    private overlay;
-    templateRef: TemplateRef<OverlaySurfaceContext>;
+declare class OverlayCloseDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    closeResult: _angular_core.InputSignal<unknown>;
+    closeResultAlt: _angular_core.InputSignal<unknown>;
+    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;
+        updatePositionStrategy: (strategy: _ethlete_core.OverlayRuntimePositionStrategy) => 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;
+    };
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private renderer;
+    rootBoundary: {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    };
+    component: _angular_core.InputSignal<Type<object>>;
+    componentBindings: _angular_core.InputSignal<Binding[] | undefined>;
+    renderArrow: _angular_core.InputSignal<boolean>;
+    private contentOutlet;
+    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
+    contentComponentRef: _angular_core.WritableSignal<ComponentRef<object> | null>;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySurfaceDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySurfaceDirective, "ng-template[etOverlaySurface]", ["etOverlaySurface"], {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayContainerComponent, "et-overlay-container", never, { "component": { "alias": "component"; "required": true; "isSignal": true; }; "componentBindings": { "alias": "componentBindings"; "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: {
@@ -1606,7 +2738,121 @@ declare const OVERLAY_ERROR_CODES: {
     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;
+    private overlayManager;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    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>;
@@ -1621,7 +2867,613 @@ 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;
+    private overlayManager;
+    private renderer;
+    id: _angular_core.InputSignal<string>;
+    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;
+    private router;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    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;
+        updatePositionStrategy: (strategy: _ethlete_core.OverlayRuntimePositionStrategy) => 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;
+    };
+    protected router: _ethlete_components.OverlayRouter;
+    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective>;
+    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;
+    private router;
+    path: _angular_core.InputSignal<string | (string | number)[]>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    navigationDirection: _angular_core.InputSignal<OverlayRouterNavigationDirection | null>;
+    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;
+    private document;
+    protected router: _ethlete_components.OverlayRouter;
+    private renderer;
+    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>[]>;
+    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;
+    /**
+     * Moves focus into the freshly navigated page, mirroring the overlay's own open-time focus behaviour
+     * (first-tabbable by default, so buttons/inputs win over headings). Falls back to the page wrapper when
+     * the page has nothing tabbable. Respects the overlay's `autoFocus` config, including `false`.
+     */
+    private focusActivePage;
+    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 {
+    protected sidebar: _ethlete_components.SidebarOverlay;
+    pageDividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    sidebarContent: _angular_core.Signal<TemplateRef<unknown>>;
+    sidebarHeaderContent: _angular_core.Signal<_ethlete_components.OverlayHeaderTemplateDirective | undefined>;
+    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;
@@ -2277,8 +4129,8 @@ type PipManager = {
 declare class PipBackDirective {
     private chrome;
     private tokenEntry;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     private pipManager;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     back(event: Event): void;
     private resolveEntry;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipBackDirective, never>;
@@ -2457,8 +4309,8 @@ declare class PipCloseDirective {
     private chrome;
     private pipWindow;
     private tokenEntry;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     private pipManager;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     close(event: Event): void;
     private resolveEntry;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipCloseDirective, never>;
@@ -2497,10 +4349,10 @@ declare class PipTitleBarDirective {
 declare const PIP_WINDOW_ASPECT_RATIO_TOKEN: InjectionToken<Signal<number>>;
 
 declare class StreamPipChromeComponent implements PipChromeRef {
+    pipManager: _ethlete_components.PipManager;
     stageRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     pipWindowRef: _angular_core.Signal<PipWindowComponent | undefined>;
     gridBtnRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
-    pipManager: _ethlete_components.PipManager;
     state: _ethlete_components.PipChromeState;
     animations: _ethlete_components.PipChromeAnimations;
     readonly CLOSE_KIND: "close";
@@ -2514,11 +4366,11 @@ declare class PipPlayerComponent {
     private document;
     private el;
     protected pipCell: PipCellDirective | null;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
-    showThumbnail: _angular_core.InputSignal<boolean | undefined>;
     private streamManager;
     private pipManager;
     private renderer;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
+    showThumbnail: _angular_core.InputSignal<boolean | undefined>;
     isReady: _angular_core.WritableSignal<boolean>;
     resolvedEntry: _angular_core.Signal<StreamPipEntry>;
     thumbnailUrl: _angular_core.Signal<string | null>;
@@ -2556,11 +4408,11 @@ declare const injectPipSlotPlaceholderConfig: {
 declare class PipSlotPlaceholderComponent {
     private slotPlayerId;
     private parentSurfaceProvider;
-    private bringBackDir;
     private pipManager;
     private config;
     private locale;
     private surfaceThemes;
+    private bringBackDir;
     cardSurface: _angular_core.Signal<string | null>;
     isInPip: _angular_core.Signal<boolean>;
     message: _angular_core.Signal<string>;
@@ -2603,10 +4455,10 @@ declare class StreamPlayerSlotDirective {
     private playerComponent;
     private provideSurface;
     private parentSurfaceProvider;
-    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
     private surfaceThemes;
     private styleManager;
+    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
     private resolvedSurface;
     slot: _ethlete_components.StreamPlayerSlotHandle;
     constructor();
@@ -3601,6 +5453,7 @@ declare class ToggletipDirective {
     private elementRef;
     private colorProvider;
     private surfaceProvider;
+    private overlayManager;
     content: _angular_core.InputSignal<ToggletipContent | null>;
     ariaLabel: _angular_core.InputSignal<string | null>;
     ariaLabelledBy: _angular_core.InputSignal<string | null>;
@@ -3611,7 +5464,6 @@ declare class ToggletipDirective {
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     disabled: _angular_core.InputSignal<boolean>;
     open: _angular_core.ModelSignal<boolean>;
-    private overlayManager;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<ToggletipComponent, unknown> | null>;
     private toggletipId;
@@ -3634,24 +5486,18 @@ declare class ToggletipDirective {
 
 declare class ToggletipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
     protected injector: Injector;
     toggletipId: _angular_core.InputSignal<string>;
     protected contentId: _angular_core.InputSignal<string>;
     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>;
     contentTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
-    resolvedSurface: _angular_core.Signal<string | null>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggletipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggletipComponent, "et-toggletip", never, { "toggletipId": { "alias": "toggletipId"; "required": true; "isSignal": true; }; "contentId": { "alias": "contentId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; "surfaceProvider": { "alias": "surfaceProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggletipComponent, "et-toggletip", never, { "toggletipId": { "alias": "toggletipId"; "required": true; "isSignal": true; }; "contentId": { "alias": "contentId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: { "surfaceProvider": "surfaceProvider"; }; outputs: {}; }]>;
 }
 
 declare class ToggletipCloseDirective {
@@ -3682,22 +5528,16 @@ declare const TOGGLETIP_IMPORTS: readonly [typeof ToggletipDirective, typeof Tog
 
 declare class TooltipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
     tooltipId: _angular_core.InputSignal<string>;
     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>;
     contentTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
-    resolvedSurface: _angular_core.Signal<string | null>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "et-tooltip", never, { "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; "surfaceProvider": { "alias": "surfaceProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "et-tooltip", never, { "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: { "surfaceProvider": "surfaceProvider"; }; outputs: {}; }]>;
 }
 
 type TooltipContent = string | TemplateRef<unknown>;
@@ -3707,6 +5547,9 @@ declare class TooltipDirective {
     private elementRef;
     private colorProvider;
     private surfaceProvider;
+    private overlayManager;
+    private focusVisibleTracker;
+    private renderer;
     content: _angular_core.InputSignal<TooltipContent | null>;
     ariaDescription: _angular_core.InputSignal<string | null>;
     placement: _angular_core.InputSignal<Placement>;
@@ -3716,9 +5559,6 @@ declare class TooltipDirective {
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     showDelay: _angular_core.InputSignal<number>;
     disabled: _angular_core.InputSignal<boolean>;
-    private overlayManager;
-    private focusVisibleTracker;
-    private renderer;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<TooltipComponent, unknown> | null>;
     private hasHover;
@@ -3744,5 +5584,5 @@ declare const TOOLTIP_ERROR_CODES: {
 
 declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
 
-export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_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, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, 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, RadioComponent, RadioGroupComponent, 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, 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_BREAKPOINTS, DEFAULT_ICON_VARIANT, 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, GridItemDefaultActionsComponent, GridItemDirective, GridItemRef, GridItemToolbarComponent, GridResizeDirective, HEADING_1_ICON, HEADING_2_ICON, HEADING_3_ICON, 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, MENU_ERROR_CODES, MENU_IMPORTS, MENU_ITEM_VARIANTS, MENU_SELECTION_GROUP_MULTIPLE, MENU_SELECTION_GROUP_TOKEN, MENU_SELECTION_ITEM_KIND, MenuCheckboxGroupComponent, MenuCheckboxItemComponent, MenuComponent, MenuContextTriggerDirective, MenuDirective, MenuGroupLabelComponent, MenuItemComponent, MenuItemDirective, MenuItemShortcutComponent, MenuPanelDirective, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSearchDirective, MenuSelectionGroupDirective, MenuSelectionItemDirective, MenuSeparatorComponent, MenuSurfaceDirective, MenuTriggerDirective, 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, SNAP_HYSTERESIS, 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, autoPlace, bottomSheetOverlayStrategy, buildAnchoredRuntimePositionStrategy, centeredOverlayStrategy, clampPosition, clampResizeRect, cleanupFullscreenAnimation, cleanupFullscreenAnimationStyles, compactLayout, computeGeometry, computeGridHeight, createAutoScroller, createGridAdapter, createNotificationRef, createOverlayHandler, createOverlayHandlerWithQueryParamLifecycle, createOverlayRef, createOverlayStrategyController, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, deserializeGridLayout, dialogOverlayStrategy, enableDragToDismiss, findCollision, findNextRelevantHtmlElement, findScrollableAncestor, fromGridPosition, fullScreenDialogOverlayStrategy, getClosestOverlay, getOriginCoordinatesAndDimensions, hysteresisRound, iconRegistryKey, 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, itemsCollide, leftSheetOverlayStrategy, mapLayoutToBreakpoint, mergeOverlayBreakpointConfigs, pixelRectsEqual, positionToPixelRect, positionsEqual, projectDragCell, 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, resizeSpanBounds, resolveBreakpoint, resolveClosestOverlay, resolveCollisions, rightSheetOverlayStrategy, rowsToPixelHeight, serializeGridLayout, snapResizeSpan, spanHeight, spanWidth, startFullscreenEnterAnimation, startFullscreenLeaveAnimation, toGridPosition, topSheetOverlayStrategy, transformingBottomSheetToDialogOverlayStrategy, transformingFullScreenDialogToDialogOverlayStrategy, transformingFullScreenDialogToRightSheetOverlayStrategy };
+export type { AnchoredDialogOverlayStrategyOptions, AnchoredOverlayStrategyOptions, AnchoredPositionOptions, AutoPlaceOptions, AutoScrollPointer, AutoScroller, ButtonIconAlignment, ButtonSize, CenteredOverlayStrategyOptions, ClampPositionOptions, CompactLayoutOptions, CreateOverlayHandlerConfig, CreateOverlayHandlerInnerConfig, CreateOverlayHandlerWithQueryParamLifecycleConfig, DragToDismissContext, DragToDismissRef, EthleteIconNameRegistry, EthleteIconVariantRegistry, FacebookVideoPlayer, FacebookWindow, FindCollisionOptions, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, FullscreenAnimationCancellable, FullscreenAnimationDeps, FullscreenAnimationState, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridGeometry, GridItemActionsComponent, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, MapLayoutOptions, MenuAnchorPoint, MenuCloseReason, MenuItemActivationEvent, MenuItemActivationSource, MenuItemVariant, MenuOpenSource, MenuSelectionGroupDirectiveBase, MenuSelectionGroupItem, MenuSelectionItemKind, MenuSurfaceContext, 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, PixelRect, RegisteredIconName, RegisteredIconVariant, ResizeSpanBounds, ResolveClosestOverlayOptions, ResolveCollisionsOptions, RowFloors, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, SerializeOptions, 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 };