@ethlete/components 0.1.0-next.14 → 0.1.0-next.16

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, OnInit, ComponentRef, OnDestroy, computed, Provider, EnvironmentInjector, ApplicationRef, Binding } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
-import { AnimatableDirective, DragHandleDirective, ResizeEdge, ResizeMoveEvent, OverlayRuntimePositionStrategy, Breakpoint, OverlayRuntimeRef, AnimatedLifecycleDirective, OverlayRuntimeCloseSource, AnimatedLifecycleState, AngularRenderer, OverlayRuntimeAnimationDelegate, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective, ProvideSurfaceDirective } from '@ethlete/core';
+import { 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 {
@@ -1019,8 +1019,10 @@ type GridDragState = {
 };
 declare class GridDirective {
     private injector;
-    private renderer;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
     private gridConfig;
+    private reducedMotion;
     breakpoints: _angular_core.InputSignal<GridBreakpointConfig[]>;
     rowHeight: _angular_core.InputSignal<number>;
     gap: _angular_core.InputSignal<number>;
@@ -1034,47 +1036,53 @@ declare class GridDirective {
     dragState: _angular_core.WritableSignal<GridDragState | null>;
     private constraintsRegistry;
     private resizeBaseLayout;
-    private itemElements;
-    private contentElements;
-    private ghostElement;
-    private lastFlipAt;
-    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;
-    /**
-     * The item's inner content wrapper. Used by the counter-scaled resize FLIP so the
-     * box can scale while the content takes the inverse scale and stays undistorted.
-     */
-    registerContentElement(id: string, el: HTMLElement): void;
-    setGhostElement(el: HTMLElement | null): void;
+    unregisterConstraints(id: string): void;
     getConstraints(id: string): GridItemConstraints;
-    snapshotRects(): void;
-    animateLayoutTransition(options?: {
-        excludeIds?: Set<string>;
-        durationMs?: number;
+    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. */
@@ -1082,13 +1090,244 @@ declare class GridDirective {
     private updateLayoutForCurrentBreakpoint;
     private updateItemLayout;
     private emitLayoutChange;
-    private animateCounterScaled;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDirective, never>;
     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>;
@@ -1096,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>;
 }
@@ -1113,18 +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;
-    private dragMoveCount;
-    private lastGhostMoveAt;
-    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"; }; }]>;
 }
@@ -1132,20 +1390,27 @@ declare class GridDragDirective {
 declare class GridResizeDirective {
     private grid;
     private gridItem;
-    private injector;
-    private elementRef;
-    private renderer;
+    private destroyRef;
+    private document;
     isResizing: _angular_core.WritableSignal<boolean>;
     resizeEdges: _angular_core.Signal<ResizeEdge[]>;
-    private resizeStartPos;
-    private liftedRect;
+    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;
-    private currentFixedRect;
-    private applyFixed;
-    private releaseFixed;
+    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>;
 }
@@ -1193,17 +1458,14 @@ declare class GridComponent {
     grid: GridDirective;
     private gridConfig;
     private locale;
-    private ghostRef;
     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"; }; }]>;
 }
@@ -1218,7 +1480,6 @@ declare class GridItemComponent {
     private surfaceThemes;
     ariaLabel: _angular_core.InputSignal<string>;
     removed: _angular_core.OutputEmitterRef<void>;
-    private itemContent;
     protected isReadOnly: _angular_core.Signal<boolean>;
     private resolvedSurface;
     constructor();
@@ -1299,8 +1560,45 @@ declare const GridImports: readonly [typeof GridComponent, typeof GridItemCompon
 
 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>>;
@@ -1344,12 +1642,20 @@ declare class IconDirective {
     private icons;
     private sanitizer;
     iconNameToUse: _angular_core.InputSignal<string>;
+    /**
+     * Style variant to resolve (e.g. `'light'`). When omitted, the directive matches a
+     * variant-less registration first, then falls back to the `'solid'` variant — so
+     * `<i etIcon="shield">` resolves the solid style and `<i etIcon="shield" variant="light">`
+     * the light one, without encoding the variant into the name.
+     */
+    variant: _angular_core.InputSignal<string | 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;
@@ -1411,254 +1717,41 @@ 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;
-    }>;
-    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;
+declare class MenuContextTriggerDirective {
+    private menu;
+    private document;
+    elementRef: ElementRef<HTMLElement>;
     private destroyRef;
-    private injector;
-    private renderer;
-    /** @internal */
-    registeredItems: _angular_core.WritableSignal<RegisteredNotificationItem[]>;
-    displayRefs: _angular_core.Signal<{
-        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();
-    /** @internal */
-    registerItem(id: string, el: HTMLElement): void;
-    /** @internal */
-    unregisterItem(id: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationStackDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationStackDirective, "[etNotificationStack]", ["etNotificationStack"], {}, {}, never, never, true, never>;
-}
-
-declare class NotificationDirective {
-    private animatedLifecycle;
-    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;
-    }>;
-    entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
-    status: _angular_core.Signal<_ethlete_components.NotificationStatus>;
-    isLoading: _angular_core.Signal<boolean>;
-    isSuccess: _angular_core.Signal<boolean>;
-    isError: _angular_core.Signal<boolean>;
-    isInfo: _angular_core.Signal<boolean>;
-    title: _angular_core.Signal<string>;
-    message: _angular_core.Signal<string | undefined>;
-    action: _angular_core.Signal<_ethlete_components.NotificationAction | undefined>;
-    progress: _angular_core.Signal<number | undefined>;
-    ariaRole: _angular_core.Signal<"status" | "alert">;
-    /** @internal */
-    registeredAction: _angular_core.WritableSignal<NotificationActionDirective | null>;
-    /** @internal */
-    registeredDismiss: _angular_core.WritableSignal<NotificationDismissDirective | null>;
+    private repositionSubscription;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDirective, "[etNotification]", ["etNotification"], { "ref": { "alias": "ref"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
-declare const NOTIFICATION_STATUS: {
-    readonly LOADING: "loading";
-    readonly SUCCESS: "success";
-    readonly ERROR: "error";
-    readonly INFO: "info";
-};
-type NotificationStatus = (typeof NOTIFICATION_STATUS)[keyof typeof NOTIFICATION_STATUS];
-type NotificationAction = {
-    label: string;
-    handler: () => void;
+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 NotificationConfig = {
-    status: NotificationStatus;
-    title: string;
-    message?: string;
-    action?: NotificationAction;
-    /**
-     * Auto-dismiss duration in milliseconds.
-     * `0` or `undefined` uses the manager's `defaultDuration` for the current status.
-     * Set explicitly to override the default (e.g. `duration: 0` to prevent auto-dismiss
-     * for a status that defaults to non-zero).
-     */
-    duration?: number;
-    /** Optional progress value (0–100). When set, a progress bar is shown below the notification body. */
-    progress?: number;
-};
-type NotificationManagerConfig = {
-    /** Position of the notification stack on screen. @default 'bottom-end' */
-    position: 'bottom-center' | 'bottom-start' | 'bottom-end' | 'top-center' | 'top-start' | 'top-end';
-    /** Maximum number of simultaneously visible notifications. @default 3 */
-    maxVisible: number;
-    /**
-     * Default auto-dismiss duration (ms) per status.
-     * `0` means no auto-dismiss.
-     * @default `{ success: 4000, info: 4000, loading: 0, error: 0 }`
-     */
-    defaultDuration: Partial<Record<NotificationStatus, number>>;
-    /**
-     * Maps each notification status to a color key used by `ProvideColorDirective`.
-     * When set, the notification host element receives the corresponding color class
-     * so that `et-button` and other colored components render correctly inside the notification.
-     */
-    statusColorMapping?: Partial<Record<NotificationStatus, string>>;
-    /**
-     * Color key applied to control elements (e.g. the dismiss button).
-     * Uses the notification's status color when not set.
-     */
-    controlsColor?: string;
-    /**
-     * Accessible label for the dismiss button.
-     * @default 'Dismiss'
-     */
-    dismissLabel: string;
-};
-declare const DEFAULT_NOTIFICATION_MANAGER_CONFIG: NotificationManagerConfig;
-declare const provideNotificationManagerConfig: (valueOverride?: Partial<NotificationManagerConfig> | undefined) => _angular_core.Provider[];
-declare const injectNotificationManagerConfig: {
-    (): NotificationManagerConfig;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): NotificationManagerConfig;
-    (options: _angular_core.InjectOptions): NotificationManagerConfig | null;
-};
-
-declare const NOTIFICATION_ERROR_CODES: {
-    readonly ACTION_OUTSIDE_NOTIFICATION: 1700;
-    readonly DISMISS_OUTSIDE_NOTIFICATION: 1701;
-};
-
-type NotificationEntry = {
-    id: string;
-    config: NotificationConfig;
-    isDismissing: boolean;
-    isDismissed: boolean;
-};
-declare const createNotificationRef: (config: NotificationConfig, { managerConfig, beforeChange }: {
-    managerConfig: NotificationManagerConfig;
-    beforeChange?: () => void;
-}) => {
-    id: string;
-    entry: _angular_core.Signal<NotificationEntry>;
-    update: (partial: Partial<NotificationConfig>) => void;
-    dismiss: () => void;
-    pauseTimer: () => void;
-    resumeTimer: () => void;
-    afterDismissed: () => rxjs.Observable<void>;
-    markDismissed: () => void;
-};
-type NotificationRef = ReturnType<typeof createNotificationRef>;
-
-type NotificationManager = {
-    open: (config: NotificationConfig) => NotificationRef;
-    dismissAll: () => void;
-    notifications: Signal<NotificationRef[]>;
-    visibleNotifications: Signal<NotificationRef[]>;
-};
-declare const provideNotificationManagerInstance: () => _angular_core.Provider[];
-declare const injectNotificationManager: {
-    (): NotificationManager;
-    (options: _angular_core.InjectOptions & {
-        optional?: false;
-    }): NotificationManager;
-    (options: _angular_core.InjectOptions): NotificationManager | null;
-};
-declare const provideNotificationManager: (config?: Partial<NotificationManagerConfig>) => _angular_core.Provider[];
-
-type NotificationStackContext = {
-    visibleNotifications: Signal<NotificationRef[]>;
-    position: NotificationManagerConfig['position'];
-    /** @internal Set by the stack component. Called by the manager before any mutation. */
-    captureBeforeState: (() => void) | null;
-};
-declare const NOTIFICATION_STACK_CONTEXT_TOKEN: InjectionToken<NotificationStackContext>;
-
-declare class NotificationComponent {
-    protected notification: NotificationDirective;
-    private animatedLifecycle;
-    private provideTheme;
-    private provideSurface;
-    private managerConfig;
-    private surfaceThemes;
-    private surfaceContextTracker;
-    private resolvedColor;
-    private resolvedSurface;
-    protected controlsColor: _angular_core.Signal<string | null>;
-    protected dismissLabel: _angular_core.Signal<string>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "et-notification", never, {}, {}, never, never, true, [{ directive: typeof NotificationDirective; inputs: { "ref": "ref"; }; outputs: {}; }, { directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }]>;
-}
-
-declare const NOTIFICATION_IMPORTS: readonly [typeof NotificationComponent, typeof NotificationDirective, typeof NotificationActionDirective, typeof NotificationDismissDirective];
-
-type OverlayStrategyContext = {
-    overlayRef: OverlayRef<object, unknown>;
-    runtimeRef: OverlayRuntimeRef<object, unknown>;
-    /** The mounted container component's host element (the runtime pane element). */
-    containerEl: HTMLElement;
-    /** The runtime host element wrapping backdrop and pane. */
-    hostEl: HTMLElement;
-    backdropEl: HTMLElement | null;
-    /** The container's animated lifecycle, driving enter/leave transitions. */
-    lifecycle: AnimatedLifecycleDirective;
-    config: OverlayBreakpointConfig;
-    previousConfig?: OverlayBreakpointConfig;
-    origin?: HTMLElement | Event;
-};
-type OverlayStrategy = {
-    /** Unique identifier for the strategy */
-    id: string;
-    /** Configuration for the overlay when this strategy is applied */
-    config: OverlayBreakpointConfig;
+type OverlayStrategy = {
+    /** Unique identifier for the strategy */
+    id: string;
+    /** Configuration for the overlay when this strategy is applied */
+    config: OverlayBreakpointConfig;
     /**
      * Called when the overlay transitions FROM another strategy TO this strategy.
      * Only called during breakpoint changes, not on initial open.
@@ -1768,187 +1861,804 @@ type OverlayBreakpointConfig = {
      *
      * @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;
+    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;
+    inputBindings?: Record<string, unknown>;
+    /** Event listeners bound to the overlay component's outputs. */
+    outputBindings?: Record<string, (event: unknown) => unknown>;
+    ariaDescribedBy?: string | null;
+    ariaLabelledBy?: string | null;
+    ariaLabel?: string | null;
+    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 */
+    registeredItems: _angular_core.WritableSignal<RegisteredNotificationItem[]>;
+    displayRefs: _angular_core.Signal<{
+        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();
+    /** @internal */
+    registerItem(id: string, el: HTMLElement): void;
+    /** @internal */
+    unregisterItem(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationStackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationStackDirective, "[etNotificationStack]", ["etNotificationStack"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationDirective {
+    private animatedLifecycle;
+    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;
+    }>;
+    entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+    status: _angular_core.Signal<_ethlete_components.NotificationStatus>;
+    isLoading: _angular_core.Signal<boolean>;
+    isSuccess: _angular_core.Signal<boolean>;
+    isError: _angular_core.Signal<boolean>;
+    isInfo: _angular_core.Signal<boolean>;
+    title: _angular_core.Signal<string>;
+    message: _angular_core.Signal<string | undefined>;
+    action: _angular_core.Signal<_ethlete_components.NotificationAction | undefined>;
+    progress: _angular_core.Signal<number | undefined>;
+    ariaRole: _angular_core.Signal<"status" | "alert">;
+    /** @internal */
+    registeredAction: _angular_core.WritableSignal<NotificationActionDirective | null>;
+    /** @internal */
+    registeredDismiss: _angular_core.WritableSignal<NotificationDismissDirective | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDirective, "[etNotification]", ["etNotification"], { "ref": { "alias": "ref"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const NOTIFICATION_STATUS: {
+    readonly LOADING: "loading";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly INFO: "info";
+};
+type NotificationStatus = (typeof NOTIFICATION_STATUS)[keyof typeof NOTIFICATION_STATUS];
+type NotificationAction = {
+    label: string;
+    handler: () => void;
+};
+type NotificationConfig = {
+    status: NotificationStatus;
+    title: string;
+    message?: string;
+    action?: NotificationAction;
+    /**
+     * Auto-dismiss duration in milliseconds.
+     * `0` or `undefined` uses the manager's `defaultDuration` for the current status.
+     * Set explicitly to override the default (e.g. `duration: 0` to prevent auto-dismiss
+     * for a status that defaults to non-zero).
+     */
+    duration?: number;
+    /** Optional progress value (0–100). When set, a progress bar is shown below the notification body. */
+    progress?: number;
+};
+type NotificationManagerConfig = {
+    /** Position of the notification stack on screen. @default 'bottom-end' */
+    position: 'bottom-center' | 'bottom-start' | 'bottom-end' | 'top-center' | 'top-start' | 'top-end';
+    /** Maximum number of simultaneously visible notifications. @default 3 */
+    maxVisible: number;
+    /**
+     * Default auto-dismiss duration (ms) per status.
+     * `0` means no auto-dismiss.
+     * @default `{ success: 4000, info: 4000, loading: 0, error: 0 }`
+     */
+    defaultDuration: Partial<Record<NotificationStatus, number>>;
     /**
-     * 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.
+     * Maps each notification status to a color key used by `ProvideColorDirective`.
+     * When set, the notification host element receives the corresponding color class
+     * so that `et-button` and other colored components render correctly inside the notification.
      */
-    origin?: HTMLElement | Event;
-    role?: OverlayRole;
-    hasBackdrop?: boolean;
-    disableClose?: boolean;
-    inputBindings?: Record<string, unknown>;
-    /** Event listeners bound to the overlay component's outputs. */
-    outputBindings?: Record<string, (event: unknown) => unknown>;
-    ariaDescribedBy?: string | null;
-    ariaLabelledBy?: string | null;
-    ariaLabel?: string | null;
-    autoFocus?: OverlayAutoFocusTarget | string | false;
-    restoreFocus?: boolean;
-    providers?: StaticProvider[];
-    hostClass?: string | string[];
-    backdropClass?: string | string[];
-    panelClass?: string | string[];
-    mode?: OverlayMode;
-    closeOnOutsidePointer?: boolean;
-    closeOnEscape?: boolean;
+    statusColorMapping?: Partial<Record<NotificationStatus, string>>;
     /**
-     * Breakpoint-driven overlay strategies (dialog, sheets, full-screen, …).
-     * When set, position, sizing and classes are controlled by the active strategy.
+     * Color key applied to control elements (e.g. the dismiss button).
+     * Uses the notification's status color when not set.
      */
-    strategies?: () => OverlayStrategyBreakpoint[];
+    controlsColor?: string;
     /**
-     * Disables the default overlay animations so custom ones can be applied.
-     *
-     * @default false
+     * Accessible label for the dismiss button.
+     * @default 'Dismiss'
      */
-    customAnimated?: boolean;
+    dismissLabel: string;
+};
+declare const DEFAULT_NOTIFICATION_MANAGER_CONFIG: NotificationManagerConfig;
+declare const provideNotificationManagerConfig: (valueOverride?: Partial<NotificationManagerConfig> | undefined) => _angular_core.Provider[];
+declare const injectNotificationManagerConfig: {
+    (): NotificationManagerConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): NotificationManagerConfig;
+    (options: _angular_core.InjectOptions): NotificationManagerConfig | null;
 };
 
-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;
-    attachComponentInstanceOverride: (getter: () => TComponent | null) => void;
-    afterOpened: () => Observable<void>;
-    beforeClosed: () => Observable<TResult | undefined>;
-    afterClosed: () => Observable<TResult | undefined>;
-    attachRuntime: (runtimeRef: OverlayRuntimeRef<TComponent, TResult>) => void;
+declare const NOTIFICATION_ERROR_CODES: {
+    readonly ACTION_OUTSIDE_NOTIFICATION: 1700;
+    readonly DISMISS_OUTSIDE_NOTIFICATION: 1701;
 };
-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;
-    attachComponentInstanceOverride: (getter: () => object | null) => void;
-    afterOpened: () => Observable<void>;
-    beforeClosed: () => Observable<unknown>;
-    afterClosed: () => Observable<unknown>;
-    attachRuntime: (runtimeRef: OverlayRuntimeRef<object, unknown>) => void;
-}>;
 
-declare const getClosestOverlay: (element: ElementRef<HTMLElement>, openOverlays: OverlayRef<object, unknown>[]) => OverlayRef<object, unknown> | null;
-type ResolveClosestOverlayOptions = {
-    overlayRef: OverlayRef<object, unknown> | null;
-    element: ElementRef<HTMLElement>;
-    openOverlays: OverlayRef<object, unknown>[];
+type NotificationEntry = {
+    id: string;
+    config: NotificationConfig;
+    isDismissing: boolean;
+    isDismissed: boolean;
 };
-/** 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 const createNotificationRef: (config: NotificationConfig, { managerConfig, beforeChange }: {
+    managerConfig: NotificationManagerConfig;
+    beforeChange?: () => void;
+}) => {
+    id: string;
+    entry: _angular_core.Signal<NotificationEntry>;
+    update: (partial: Partial<NotificationConfig>) => void;
+    dismiss: () => void;
+    pauseTimer: () => void;
+    resumeTimer: () => void;
+    afterDismissed: () => rxjs.Observable<void>;
+    markDismissed: () => void;
+};
+type NotificationRef = ReturnType<typeof createNotificationRef>;
 
-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 NotificationManager = {
+    open: (config: NotificationConfig) => NotificationRef;
+    dismissAll: () => void;
+    notifications: Signal<NotificationRef[]>;
+    visibleNotifications: Signal<NotificationRef[]>;
+};
+declare const provideNotificationManagerInstance: () => _angular_core.Provider[];
+declare const injectNotificationManager: {
+    (): NotificationManager;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): NotificationManager;
+    (options: _angular_core.InjectOptions): NotificationManager | null;
+};
+declare const provideNotificationManager: (config?: Partial<NotificationManagerConfig>) => _angular_core.Provider[];
 
-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>;
-}
+type NotificationStackContext = {
+    visibleNotifications: Signal<NotificationRef[]>;
+    position: NotificationManagerConfig['position'];
+    /** @internal Set by the stack component. Called by the manager before any mutation. */
+    captureBeforeState: (() => void) | null;
+};
+declare const NOTIFICATION_STACK_CONTEXT_TOKEN: InjectionToken<NotificationStackContext>;
 
-declare class OverlayTriggerDirective {
-    private overlay;
-    private destroyRef;
-    elementRef: ElementRef<HTMLElement>;
+declare class NotificationComponent {
+    protected notification: NotificationDirective;
+    private animatedLifecycle;
+    private provideTheme;
+    private provideSurface;
+    private managerConfig;
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private resolvedColor;
+    private resolvedSurface;
+    protected controlsColor: _angular_core.Signal<string | null>;
+    protected dismissLabel: _angular_core.Signal<string>;
     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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "et-notification", never, {}, {}, never, never, true, [{ directive: typeof NotificationDirective; inputs: { "ref": "ref"; }; outputs: {}; }, { directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }]>;
 }
 
-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>;
-}
+declare const NOTIFICATION_IMPORTS: readonly [typeof NotificationComponent, typeof NotificationDirective, typeof NotificationActionDirective, typeof NotificationDismissDirective];
 
-type OverlaySurfaceContext = {
-    $implicit: OverlayDirective;
-    overlay: OverlayDirective;
-    close: (result?: unknown) => void;
+declare const getClosestOverlay: (element: ElementRef<HTMLElement>, openOverlays: OverlayRef<object, unknown>[]) => OverlayRef<object, unknown> | null;
+type ResolveClosestOverlayOptions = {
+    overlayRef: OverlayRef<object, unknown> | null;
+    element: ElementRef<HTMLElement>;
+    openOverlays: OverlayRef<object, unknown>[];
 };
-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>;
-}
+/** 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 const OVERLAY_BODY_TOKEN: InjectionToken<OverlayBodyComponent>;
 type OverlayBodyDividerType = 'static' | 'dynamic' | false;
@@ -2002,6 +2712,7 @@ declare class OverlayContainerComponent {
         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>;
@@ -2210,6 +2921,7 @@ declare class OverlayRouteHeaderTemplateOutletComponent {
         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>;
@@ -2344,6 +3056,7 @@ declare class OverlayRouterOutletComponent {
     private injector;
     private overlayRef;
     private elementRef;
+    private document;
     protected router: _ethlete_components.OverlayRouter;
     private renderer;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
@@ -2358,6 +3071,12 @@ declare class OverlayRouterOutletComponent {
     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>;
 }
@@ -4772,23 +5491,18 @@ declare class ToggletipDirective {
 
 declare class ToggletipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
     protected injector: Injector;
-    private surfaceThemes;
     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>;
     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 {
@@ -4819,21 +5533,16 @@ declare const TOGGLETIP_IMPORTS: readonly [typeof ToggletipDirective, typeof Tog
 
 declare class TooltipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
-    private surfaceThemes;
     tooltipId: _angular_core.InputSignal<string>;
     content: _angular_core.InputSignal<TooltipContent>;
     colorProvider: _angular_core.InputSignal<ProvideColorDirective | null>;
-    surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
     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>;
@@ -4880,5 +5589,5 @@ declare const TOOLTIP_ERROR_CODES: {
 
 declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
 
-export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BOLD_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, FACEBOOK_PLAYER_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_TOKEN, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridImports, GridItemComponent, 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, NAV_TABS_TOKEN, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NavTabImports, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CONFIG_CLASS_KEYS, OVERLAY_CONTENT_IMPORTS, OVERLAY_ERROR_CODES, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_IMPORTS, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_REF, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_ROUTER_TOKEN, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OverlayAnchorDirective, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseDirective, OverlayContainerComponent, OverlayDirective, OverlayFooterDirective, OverlayHandlerLinkDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayMainDirective, OverlayOriginCloneComponent, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlaySurfaceDirective, OverlayTitleDirective, OverlayTriggerDirective, PENCIL_ICON, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLUS_ICON, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, RICH_TEXT_EDITOR_IMPORTS, RadioComponent, RadioGroupComponent, RichTextEditorComponent, RichTextEditorDirective, RichTextEditorFloatingToolbarComponent, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SIDEBAR_OVERLAY_CONFIG, SIDEBAR_OVERLAY_TOKEN, SOOP_PLAYER_TOKEN, STREAM_CONSENT_TOKEN, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableErrorCode, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamImports, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_PANEL_TOKEN, TAB_SIZES, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabImports, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TextButtonComponent, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, abortFullscreenAnimation, anchoredDialogOverlayStrategy, anchoredOverlayStrategy, bottomSheetOverlayStrategy, buildAnchoredRuntimePositionStrategy, centeredOverlayStrategy, cleanupFullscreenAnimation, cleanupFullscreenAnimationStyles, createGridAdapter, createNotificationRef, createOverlayHandler, createOverlayHandlerWithQueryParamLifecycle, createOverlayRef, createOverlayStrategyController, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, dialogOverlayStrategy, enableDragToDismiss, findNextRelevantHtmlElement, fromGridPosition, fullScreenDialogOverlayStrategy, getClosestOverlay, getOriginCoordinatesAndDimensions, injectAnchoredDialogStrategy, injectAnchoredDialogStrategyDefaults, injectBottomSheetStrategy, injectBottomSheetStrategyDefaults, injectDialogStrategy, injectDialogStrategyDefaults, injectFormSupport, injectFullscreenDialogStrategy, injectFullscreenDialogStrategyDefaults, injectGridConfig, injectLeftSheetStrategy, injectLeftSheetStrategyDefaults, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectOverlayRouter, injectOverlayScrollBlocker, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectRightSheetStrategy, injectRightSheetStrategyDefaults, injectSidebarOverlay, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, injectTopSheetStrategy, injectTopSheetStrategyDefaults, isHtmlElement, isPointerEvent, isTouchEvent, leftSheetOverlayStrategy, mergeOverlayBreakpointConfigs, provideAnchoredDialogStrategy, provideAnchoredDialogStrategyDefaults, provideBottomSheetStrategy, provideBottomSheetStrategyDefaults, provideDialogStrategy, provideDialogStrategyDefaults, provideFormSupport, provideFullscreenDialogStrategy, provideFullscreenDialogStrategyDefaults, provideGridConfig, provideIcons, provideLeftSheetStrategy, provideLeftSheetStrategyDefaults, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlay, provideOverlayManager, provideOverlayRouter, provideOverlayRouterConfig, provideOverlayRouterService, provideOverlayScrollBlocker, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideRightSheetStrategy, provideRightSheetStrategyDefaults, provideSidebarOverlay, provideSidebarOverlayConfig, provideSidebarOverlayService, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, provideTopSheetStrategy, provideTopSheetStrategyDefaults, resolveClosestOverlay, rightSheetOverlayStrategy, startFullscreenEnterAnimation, startFullscreenLeaveAnimation, toGridPosition, topSheetOverlayStrategy, transformingBottomSheetToDialogOverlayStrategy, transformingFullScreenDialogToDialogOverlayStrategy, transformingFullScreenDialogToRightSheetOverlayStrategy };
-export type { AnchoredDialogOverlayStrategyOptions, AnchoredOverlayStrategyOptions, AnchoredPositionOptions, ButtonIconAlignment, ButtonSize, CenteredOverlayStrategyOptions, CreateOverlayHandlerConfig, CreateOverlayHandlerInnerConfig, CreateOverlayHandlerWithQueryParamLifecycleConfig, DragToDismissContext, DragToDismissRef, FacebookVideoPlayer, FacebookWindow, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, FullscreenAnimationCancellable, FullscreenAnimationDeps, FullscreenAnimationState, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridItemActionsComponent, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OverlayAutoFocusTarget, OverlayBodyDividerType, OverlayBreakpointConfig, OverlayConfig, OverlayConsumerConfig, OverlayDragToDismissConfig, OverlayHandler, OverlayHandlerWithQueryParamLifecycle, OverlayManager, OverlayMode, OverlayRef, OverlayRole, OverlayRoute, OverlayRouter, OverlayRouterConfig, OverlayRouterNavigateConfig, OverlayRouterNavigationDirection, OverlayRouterResolvedPath, OverlayRouterTransitionType, OverlayStrategy, OverlayStrategyBreakpoint, OverlayStrategyContext, OverlayStrategyController, OverlayStrategyControllerMountConfig, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, ResolveClosestOverlayOptions, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, SidebarOverlay, SidebarOverlayConfig, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, ToggletipContent, TooltipContent, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, ViewportTransformData, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };
+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 };