@ethlete/components 0.1.0-next.9 → 1.0.0-next.18

package/types/ethlete-components.d.ts

@@ -1,14 +1,15 @@
 import * as _angular_core from '@angular/core';
-import { Signal, WritableSignal, InjectionToken, ElementRef, Type, InputSignal, ViewContainerRef, Injector, StaticProvider, TemplateRef, computed, Binding, EnvironmentInjector, ComponentRef } from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, ElementRef, Type, InputSignal, ViewContainerRef, Injector, Binding, StaticProvider, TemplateRef, OnInit, ComponentRef, ModelSignal, OnDestroy, computed, Provider, EnvironmentInjector, ApplicationRef } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
-import { AnimatableDirective, DragHandleDirective, ResizeEdge, ResizeMoveEvent, OverlayRuntimePositionStrategy, OverlayRuntimeRef, AnimatedLifecycleDirective, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective, ProvideSurfaceDirective } from '@ethlete/core';
+import { AnimatableDirective, ResizeEdge, DragHandleDirective, ResizeMoveEvent, OverlayRuntimePositionStrategy, Breakpoint, OverlayRuntimeRef, AnimatedLifecycleDirective, OverlayRuntimeCloseSource, AnimatedLifecycleState, OverlayRuntimeShiftOptions, 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 { ValidationError, FormCheckboxControl, PathKind, SchemaPath, SchemaPathRules, FormValueControl } from '@angular/forms/signals';
 import * as _ethlete_components from '@ethlete/components';
+import { QueryArgs, QueryCreator, RequestArgs, ResponseType, AnyNewQuery, QueryErrorResponse } from '@ethlete/query';
 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 {
@@ -39,9 +40,44 @@ declare class ButtonDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[etButton]", ["etButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "emitAriaPressed": { "alias": "emitAriaPressed"; "required": false; "isSignal": true; }; "mutedUntilPressed": { "alias": "mutedUntilPressed"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.SurfaceInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
+declare class SplitButtonActionDirective {
+    private splitButton;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButtonActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SplitButtonActionDirective, "[etSplitButtonAction]", ["etSplitButtonAction"], {}, {}, never, never, true, never>;
+}
+
+declare const SPLIT_BUTTON_ERROR_CODES: {
+    readonly MISSING_ACTION: 2300;
+    readonly MISSING_TRIGGER: 2301;
+    readonly ACTION_OUTSIDE_SPLIT_BUTTON: 2302;
+    readonly TRIGGER_OUTSIDE_SPLIT_BUTTON: 2303;
+};
+
+declare class SplitButtonTriggerDirective {
+    private splitButton;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButtonTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SplitButtonTriggerDirective, "[etSplitButtonTrigger]", ["etSplitButtonTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare class SplitButtonDirective {
+    registeredAction: _angular_core.WritableSignal<SplitButtonActionDirective | null>;
+    registeredTrigger: _angular_core.WritableSignal<SplitButtonTriggerDirective | null>;
+    constructor();
+    /** @internal */
+    unregisterAction(action: SplitButtonActionDirective): void;
+    /** @internal */
+    unregisterTrigger(trigger: SplitButtonTriggerDirective): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SplitButtonDirective, "[etSplitButton]", ["etSplitButton"], {}, {}, never, never, true, never>;
+}
+
 declare class FocusRingDirective {
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private styleManager;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected active: _angular_core.WritableSignal<boolean>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FocusRingDirective, never>;
@@ -125,6 +161,11 @@ declare class IconButtonComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "[et-icon-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; "mutedUntilPressed": "mutedUntilPressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
+declare class SplitButtonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitButtonComponent, "et-split-button", never, {}, {}, never, ["*"], true, [{ directive: typeof SplitButtonDirective; inputs: {}; outputs: {}; }]>;
+}
+
 declare class TextButtonComponent {
     protected buttonDir: ButtonDirective;
     size: _angular_core.InputSignal<ButtonSize>;
@@ -172,10 +213,10 @@ declare class WindowControlButtonComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowControlButtonComponent, "[et-window-control-button]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "kind": { "alias": "kind"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
-declare const BUTTON_IMPORTS: readonly [typeof ButtonComponent, typeof FabComponent, typeof IconButtonComponent, typeof TextButtonComponent, typeof WindowControlButtonComponent, typeof ButtonDirective];
+declare const BUTTON_IMPORTS: readonly [typeof ButtonComponent, typeof FabComponent, typeof IconButtonComponent, typeof SplitButtonComponent, typeof TextButtonComponent, typeof WindowControlButtonComponent, typeof ButtonDirective, typeof SplitButtonDirective, typeof SplitButtonActionDirective, typeof SplitButtonTriggerDirective];
 
 declare const FORM_FIELD_ERROR_CODES: {
-    readonly MISSING_CONTROL: 1800;
+    readonly MISSING_CONTROL: 2200;
 };
 
 declare const FORM_FIELD_CONTROL_TYPES: {
@@ -186,6 +227,7 @@ declare const FORM_FIELD_CONTROL_TYPES: {
     readonly SWITCH: "switch";
     readonly SEGMENTED_BUTTON: "segmented-button";
     readonly SELECTION_LIST: "selection-list";
+    readonly DROPZONE: "dropzone";
 };
 type FormFieldControlType = (typeof FORM_FIELD_CONTROL_TYPES)[keyof typeof FORM_FIELD_CONTROL_TYPES];
 type FormFieldControl = {
@@ -371,11 +413,31 @@ declare class CheckboxComponent {
 
 declare const CHECKBOX_IMPORTS: readonly [typeof CheckboxComponent, typeof CheckboxDirective];
 
+declare const FORM_FIELD_APPEARANCES: {
+    readonly BOX: "box";
+    readonly UNDERLINE: "underline";
+};
+type FormFieldAppearance = (typeof FORM_FIELD_APPEARANCES)[keyof typeof FORM_FIELD_APPEARANCES];
+declare const FORM_FIELD_FILLS: {
+    readonly TRANSPARENT: "transparent";
+    readonly FILLED: "filled";
+};
+type FormFieldFill = (typeof FORM_FIELD_FILLS)[keyof typeof FORM_FIELD_FILLS];
+declare const FORM_FIELD_LABEL_MODES: {
+    readonly STATIC: "static";
+    readonly INLINE: "inline";
+    readonly FLOATING_INSIDE: "floating-inside";
+    readonly FLOATING_OUTSIDE: "floating-outside";
+};
+type FormFieldLabelMode = (typeof FORM_FIELD_LABEL_MODES)[keyof typeof FORM_FIELD_LABEL_MODES];
+declare const FORM_FIELD_SIZES: {
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+};
+type FormFieldSize = (typeof FORM_FIELD_SIZES)[keyof typeof FORM_FIELD_SIZES];
+
 declare class ChoiceFieldComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -393,12 +455,17 @@ declare class ChoiceFieldComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    size: _angular_core.InputSignal<FormFieldSize>;
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChoiceFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChoiceFieldComponent, "et-choice-field", never, {}, {}, never, ["*", "et-label", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChoiceFieldComponent, "et-choice-field", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-label", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class HintComponent implements HintComponentBase {
@@ -416,36 +483,328 @@ declare class DescriptionComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionComponent, "et-description", never, {}, {}, never, ["*"], true, never>;
 }
 
+/**
+ * Display information for a value that is already part of the form control
+ * (e.g. media uploaded in a previous session inside an edit form).
+ */
+type DropzoneExistingFileInfo = {
+    /** URL rendered as a preview thumbnail. */
+    previewUrl?: string | null;
+    /** Human readable name of the file. Falls back to the stringified value. */
+    name?: string;
+    /** File size in bytes. */
+    size?: number | null;
+};
+type DropzoneUploadConfig<TArgs extends QueryArgs = QueryArgs, TValue = unknown> = {
+    /**
+     * The query creator used to upload a single file (e.g. a POST multipart route).
+     *
+     * For per-file upload progress, create it with `reportProgress: true` and make sure the
+     * app uses the XHR `HttpClient` backend (upload progress events are not supported with
+     * `provideHttpClient(withFetch())`). Without progress information the dropzone falls
+     * back to an indeterminate progress display.
+     */
+    queryCreator: QueryCreator<TArgs>;
+    /**
+     * Builds the request args for one file.
+     * Override to change the multipart field name or to add extra fields, path params,
+     * query params or headers.
+     *
+     * @default (file) => ({ body: FormData with the file appended as "file" })
+     */
+    createArgs?: (file: File) => RequestArgs<TArgs>;
+    /**
+     * Maps the upload response to the value that gets pushed into the form control
+     * (e.g. `(media) => media.uuid`).
+     */
+    selectValue: (response: NonNullable<ResponseType<TArgs>>) => TValue;
+    /**
+     * Maps a value that is already part of the form control (edit forms) to display info.
+     * Called in a reactive context — reading signals inside it is supported, so async
+     * lookups can be modeled as signals updating over time.
+     *
+     * Required as soon as the form control can start with a non-empty value.
+     */
+    resolveExisting?: (value: TValue) => DropzoneExistingFileInfo;
+};
+type AnyDropzoneUploadConfig<TValue = unknown> = DropzoneUploadConfig<any, TValue>;
+/**
+ * Identity helper that correlates the query args type with the form control value type,
+ * so `DropzoneUploadConfig` objects get full type inference at the definition site.
+ */
+declare const createDropzoneUpload: <TArgs extends QueryArgs, TValue>(config: DropzoneUploadConfig<TArgs, TValue>) => DropzoneUploadConfig<TArgs, TValue>;
+declare const createDefaultDropzoneArgs: (file: File) => RequestArgs<QueryArgs>;
+
+declare const DROPZONE_ENTRY_STATUSES: {
+    readonly UPLOADING: "uploading";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly EXISTING: "existing";
+};
+type DropzoneEntryStatus = (typeof DROPZONE_ENTRY_STATUSES)[keyof typeof DROPZONE_ENTRY_STATUSES];
+type DropzoneEntrySource<TValue = unknown> = {
+    type: 'file';
+    file: File;
+} | {
+    type: 'existing';
+    value: TValue;
+};
+type DropzoneEntry<TValue = unknown> = {
+    /** Unique id of this entry. Stable for the lifetime of the entry. */
+    id: string;
+    /** What this entry was created from — a picked/dropped file or an existing form control value. */
+    source: DropzoneEntrySource<TValue>;
+    /** Human readable name (file name or resolved from the existing value). */
+    name: Signal<string>;
+    /** File size in bytes. `null` when unknown. */
+    size: Signal<number | null>;
+    /** Preview URL (object URL for image files, resolver-provided URL for existing values). */
+    previewUrl: Signal<string | null>;
+    status: Signal<DropzoneEntryStatus>;
+    /** Upload progress in percent. `null` means indeterminate (or not uploading). */
+    progress: Signal<number | null>;
+    /** The upload error, if the last upload attempt failed. */
+    error: Signal<QueryErrorResponse | null>;
+    /** The form control value of this entry. `null` until the upload succeeded. */
+    value: Signal<TValue | null>;
+    /** @internal The upload query. `null` for existing entries. */
+    query: AnyNewQuery | null;
+    /** @internal The frozen request args of the upload. Reused for retries. */
+    args: RequestArgs<QueryArgs> | null;
+    /** @internal Object URL that must be revoked when the entry is disposed. */
+    objectUrl: string | null;
+};
+type CreateFileDropzoneEntryOptions<TValue> = {
+    file: File;
+    query: AnyNewQuery;
+    args: RequestArgs<QueryArgs>;
+    selectValue: (response: unknown) => TValue;
+};
+declare const createFileDropzoneEntry: <TValue>(options: CreateFileDropzoneEntryOptions<TValue>) => DropzoneEntry<TValue>;
+type CreateExistingDropzoneEntryOptions<TValue> = {
+    value: TValue;
+    upload: Signal<AnyDropzoneUploadConfig<TValue>>;
+};
+declare const createExistingDropzoneEntry: <TValue>(options: CreateExistingDropzoneEntryOptions<TValue>) => DropzoneEntry<TValue>;
+/** Releases all resources held by an entry (object URL, in-flight upload). */
+declare const disposeDropzoneEntry: <TValue>(entry: DropzoneEntry<TValue>) => void;
+/** Checks a file against the native `accept` attribute semantics (`.ext`, `type/subtype`, `type/*`). */
+declare const isFileAccepted: (file: File, accept: string) => boolean;
+/** Formats a byte count as a short human readable string (e.g. `1.5 MB`). */
+declare const formatFileSize: (bytes: number) => string;
+
+declare const DROPZONE_FILE_REJECTION_REASONS: {
+    readonly ACCEPT: "accept";
+    readonly MAX_FILE_SIZE: "maxFileSize";
+    readonly MIN_FILE_SIZE: "minFileSize";
+    readonly MAX_FILES: "maxFiles";
+};
+type DropzoneFileRejectionReason = (typeof DROPZONE_FILE_REJECTION_REASONS)[keyof typeof DROPZONE_FILE_REJECTION_REASONS];
+type DropzoneFileRejection = {
+    file: File;
+    reason: DropzoneFileRejectionReason;
+};
+/** The `kind` of the {@link ValidationError}s produced by {@link dropzoneFiles}. */
+declare const DROPZONE_FILES_ERROR_KIND = "dropzoneFiles";
+type DropzoneFileConstraints = {
+    /**
+     * Accepted file types using the native `accept` attribute semantics
+     * (`.png`, `image/png`, `image/*`). Also applied to the native file picker.
+     */
+    accept?: string;
+    /** Maximum size of a single file in bytes. */
+    maxFileSize?: number;
+    /** Minimum size of a single file in bytes. */
+    minFileSize?: number;
+    /** Overrides the built-in per-rejection error message (e.g. for i18n). */
+    message?: (rejection: DropzoneFileRejection) => string;
+};
+/**
+ * @internal
+ * The channel between the {@link dropzoneFiles} schema rule and the dropzone directive:
+ * the schema publishes the constraints, the directive publishes the rejected files of
+ * the most recent selection.
+ */
+type DropzoneFileValidationChannel = {
+    constraints: Signal<DropzoneFileConstraints | undefined>;
+    rejections: WritableSignal<DropzoneFileRejection[]>;
+};
+/** @internal Read by the dropzone directive via the bound field's metadata. */
+declare const DROPZONE_FILE_CONSTRAINTS: _angular_forms_signals.MetadataKey<DropzoneFileValidationChannel, DropzoneFileConstraints, DropzoneFileConstraints | undefined>;
+declare const defaultDropzoneRejectionMessage: (rejection: DropzoneFileRejection, constraints: DropzoneFileConstraints | undefined) => string;
+/**
+ * Schema rule that validates the files selected in a dropzone bound to this field.
+ *
+ * Files violating the constraints are never uploaded; each violation surfaces as a
+ * regular validation error (`kind: 'dropzoneFiles'`) on the field until the next
+ * selection, removal or clear. Count and emptiness constraints are plain value
+ * validation — use `required()`, `minLength()` and `maxLength()` for those.
+ *
+ * @example
+ * ```ts
+ * form(model, (s) => {
+ *   required(s.media, { message: 'Please upload a file' });
+ *   maxLength(s.media, 5, { message: 'Upload at most 5 files' });
+ *   dropzoneFiles(s.media, { accept: 'image/*', maxFileSize: 5 * 1024 * 1024 });
+ * });
+ * ```
+ */
+declare const dropzoneFiles: <TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, constraints: DropzoneFileConstraints | (() => DropzoneFileConstraints)) => void;
+
+declare class DropzoneDirective<TValue = unknown> implements FormValueControl<TValue | TValue[] | null>, FormFieldControl {
+    private formField;
+    private signalFormField;
+    private destroyRef;
+    private injector;
+    value: _angular_core.ModelSignal<TValue | TValue[] | null>;
+    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>;
+    /** The upload workflow configuration. Create it via `createDropzoneUpload()`. */
+    upload: _angular_core.InputSignal<AnyDropzoneUploadConfig<TValue>>;
+    /** Whether multiple files can be uploaded. The control value becomes an array. */
+    multiple: _angular_core.InputSignal<boolean>;
+    /** Emits all files of a selection that were rejected, with the reason per file. */
+    filesRejected: _angular_core.OutputEmitterRef<DropzoneFileRejection[]>;
+    /** Emits when the upload of an entry succeeded (after the control value was updated). */
+    uploadSucceeded: _angular_core.OutputEmitterRef<DropzoneEntry<TValue>>;
+    /** Emits when the upload of an entry failed. */
+    uploadFailed: _angular_core.OutputEmitterRef<DropzoneEntry<TValue>>;
+    private internalEntries;
+    private internalLastRejections;
+    private dragDepth;
+    private entryWatchers;
+    private lastSyncedValue;
+    private hasSyncedValue;
+    /** All entries currently managed by the dropzone, including uploading and failed ones. */
+    entries: _angular_core.Signal<DropzoneEntry<TValue>[]>;
+    /** The rejections of the most recent file selection. Reset by the next selection, removal or clear. */
+    lastRejections: _angular_core.Signal<DropzoneFileRejection[]>;
+    /**
+     * The file validation channel of the bound form field, if its schema uses the
+     * `dropzoneFiles()` rule. Provides the constraints and receives the rejections.
+     */
+    private fileValidation;
+    /** The `accept` constraint of the bound field's `dropzoneFiles()` rule. Empty accepts everything. */
+    accept: _angular_core.Signal<string>;
+    /** Whether a files drag is currently hovering the dropzone. */
+    isDragOver: _angular_core.Signal<boolean>;
+    anyUploading: _angular_core.Signal<boolean>;
+    anyFailed: _angular_core.Signal<boolean>;
+    hasValue: _angular_core.Signal<boolean>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"dropzone">;
+    describedById: _angular_core.Signal<string | null>;
+    labelId: _angular_core.Signal<string | null>;
+    /** @internal */
+    focusTarget: _angular_core.WritableSignal<HTMLElement | null>;
+    constructor();
+    /** Validates the given files and uploads all accepted ones. */
+    selectFiles(files: FileList | readonly File[]): void;
+    /** Removes an entry. Cancels its upload if it is still in flight. */
+    removeEntry(id: string): void;
+    /** Retries the upload of a failed entry with its original request args. */
+    retryEntry(id: string): void;
+    /** Removes all entries and resets the control value. */
+    clear(): void;
+    activate(): void;
+    protected handleDragEnter(event: DragEvent): void;
+    protected handleDragOver(event: DragEvent): void;
+    protected handleDragLeave(): void;
+    protected handleDrop(event: DragEvent): void;
+    private setRejections;
+    private createFileEntry;
+    private disposeEntry;
+    private syncValue;
+    private reconcileValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropzoneDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DropzoneDirective<any>, "[etDropzone]", never, { "value": { "alias": "value"; "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; }; "upload": { "alias": "upload"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "filesRejected": "filesRejected"; "uploadSucceeded": "uploadSucceeded"; "uploadFailed": "uploadFailed"; }, never, never, true, never>;
+}
+
+declare class DropzoneComponent {
+    protected dropzoneDir: DropzoneDirective<any>;
+    support: {
+        errorColorTheme: _ethlete_core.ColorTheme;
+        formFieldDir: FormFieldDirective;
+        errorContent: _angular_core.WritableSignal<ElementRef<HTMLElement> | undefined>;
+        hintContent: _angular_core.WritableSignal<ElementRef<HTMLElement> | undefined>;
+        errorAnimatable: _angular_core.WritableSignal<AnimatableDirective | undefined>;
+        hintAnimatable: _angular_core.WritableSignal<AnimatableDirective | undefined>;
+        semanticSupportState: _angular_core.Signal<"none" | "hint" | "error">;
+        displaysError: _angular_core.Signal<boolean>;
+        shouldRenderSupport: _angular_core.Signal<boolean>;
+        shouldRenderError: _angular_core.Signal<boolean>;
+        shouldRenderHint: _angular_core.Signal<boolean>;
+        errorActive: _angular_core.Signal<boolean>;
+        hintActive: _angular_core.Signal<boolean>;
+        visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
+        supportHeight: _angular_core.Signal<number>;
+    };
+    private injector;
+    private renderer;
+    private prefersReducedMotion;
+    /** Label of the retry button shown for failed uploads. */
+    retryLabel: _angular_core.InputSignal<string>;
+    /** Accessible label prefix of the remove button. The entry name is appended. */
+    removeLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the replace button shown in single mode. */
+    replaceLabel: _angular_core.InputSignal<string>;
+    /** Fallback error message shown when the upload error has no message. */
+    uploadErrorLabel: _angular_core.InputSignal<string>;
+    /** Overrides the built-in per-entry upload failure message (e.g. for i18n). */
+    uploadErrorMessage: _angular_core.InputSignal<((entry: DropzoneEntry) => string) | null>;
+    private fileInput;
+    private browseButton;
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    private entryElements;
+    private removingEntryIds;
+    private filePickerOpen;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    protected singleEntry: _angular_core.Signal<DropzoneEntry<any> | null>;
+    protected liveStatusMessage: _angular_core.Signal<string>;
+    /** Upload failures, rendered like validation errors below the field. */
+    protected internalErrorMessages: _angular_core.Signal<string[]>;
+    protected readonly FORMAT_FILE_SIZE: (bytes: number) => string;
+    constructor();
+    protected openFilePicker(): void;
+    /**
+     * Opening the system file picker blurs the trigger — the control must not be
+     * marked as touched (and show validation errors) while the dialog is open.
+     */
+    protected markTriggerTouched(): void;
+    /** Called when focus returns to the trigger or the picker dialog is cancelled. */
+    protected resetFilePickerState(): void;
+    protected uploadPickedFiles(event: Event): void;
+    /** Removes an entry, scaling out its element and FLIP-shifting the remaining ones. */
+    protected removeEntryAnimated(entry: DropzoneEntry, entryElement: HTMLElement): void;
+    private defaultUploadErrorMessage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropzoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropzoneComponent, "et-dropzone", never, { "retryLabel": { "alias": "retryLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "replaceLabel": { "alias": "replaceLabel"; "required": false; "isSignal": true; }; "uploadErrorLabel": { "alias": "uploadErrorLabel"; "required": false; "isSignal": true; }; "uploadErrorMessage": { "alias": "uploadErrorMessage"; "required": false; "isSignal": true; }; }, {}, never, ["et-label", "*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof DropzoneDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "upload": "upload"; "multiple": "multiple"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; "filesRejected": "filesRejected"; "uploadSucceeded": "uploadSucceeded"; "uploadFailed": "uploadFailed"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+}
+
+declare const DROPZONE_IMPORTS: readonly [typeof DropzoneComponent, typeof DropzoneDirective];
+
+declare const DROPZONE_ERROR_CODES: {
+    readonly INVALID_UPLOAD_CONFIG: 2400;
+    readonly MISSING_EXISTING_RESOLVER: 2401;
+    readonly VALUE_MODE_MISMATCH: 2402;
+};
+
 declare class FormErrorComponent {
     error: _angular_core.InputSignal<ValidationError.WithOptionalFieldTree>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormErrorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormErrorComponent, "et-form-error", never, { "error": { "alias": "error"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const FORM_FIELD_APPEARANCES: {
-    readonly BOX: "box";
-    readonly UNDERLINE: "underline";
-};
-type FormFieldAppearance = (typeof FORM_FIELD_APPEARANCES)[keyof typeof FORM_FIELD_APPEARANCES];
-declare const FORM_FIELD_FILLS: {
-    readonly TRANSPARENT: "transparent";
-    readonly FILLED: "filled";
-};
-type FormFieldFill = (typeof FORM_FIELD_FILLS)[keyof typeof FORM_FIELD_FILLS];
-declare const FORM_FIELD_LABEL_MODES: {
-    readonly STATIC: "static";
-    readonly INLINE: "inline";
-    readonly FLOATING_INSIDE: "floating-inside";
-    readonly FLOATING_OUTSIDE: "floating-outside";
-};
-type FormFieldLabelMode = (typeof FORM_FIELD_LABEL_MODES)[keyof typeof FORM_FIELD_LABEL_MODES];
-declare const FORM_FIELD_SIZES: {
-    readonly SM: "sm";
-    readonly MD: "md";
-    readonly LG: "lg";
-};
-type FormFieldSize = (typeof FORM_FIELD_SIZES)[keyof typeof FORM_FIELD_SIZES];
-
 declare const SUPPORT_CONTENT_STATE: {
     readonly NONE: "none";
     readonly HINT: "hint";
@@ -464,6 +823,8 @@ declare class FormFieldComponent {
     private provideSurface;
     private parentSurfaceProvider;
     protected formFieldDir: FormFieldDirective;
+    protected errorColorTheme: _ethlete_core.ColorTheme;
+    private surfaceThemes;
     appearance: _angular_core.InputSignal<FormFieldAppearance>;
     fill: _angular_core.InputSignal<FormFieldFill>;
     labelMode: _angular_core.InputSignal<FormFieldLabelMode>;
@@ -473,8 +834,6 @@ declare class FormFieldComponent {
     prefixEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     protected errorAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
     protected hintAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
-    protected errorColorTheme: _ethlete_core.ColorTheme;
-    private surfaceThemes;
     private errorDimensions;
     private hintDimensions;
     private prefixDimensions;
@@ -577,6 +936,7 @@ declare const INPUT_IMPORTS: readonly [typeof InputComponent, typeof InputDirect
 
 type InlineTag = 'strong' | 'em' | 'del';
 type ListTag = 'ul' | 'ol';
+type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
 type EditableSelection = {
     selection: Selection;
     range: Range;
@@ -588,11 +948,28 @@ type RichTextMarkStates = {
     unorderedList: boolean;
     orderedList: boolean;
     link: boolean;
+    /** Heading level of the block the selection starts in, or `null` when it is not a heading. */
+    heading: number | null;
 };
 
 declare class RichTextEditorDirective implements FormValueControl<string>, FormFieldControl {
     private formField;
     private destroyRef;
+    private document;
+    /** @internal */
+    editorDom: {
+        root: _angular_core.WritableSignal<HTMLElement | null>;
+        getSelection: () => EditableSelection | null;
+        closestWithin: (node: Node | null, selector: string) => HTMLElement | null;
+        markStates: () => RichTextMarkStates | null;
+        toggleInline: (tag: InlineTag) => void;
+        toggleList: (listTag: ListTag) => void;
+        toggleHeading: (tag: HeadingTag) => void;
+        applyLink: (href: string) => void;
+        removeLink: () => void;
+        insertToken: (node: Node) => void;
+        handleBackspace: () => boolean;
+    };
     value: _angular_core.ModelSignal<string>;
     touched: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
@@ -616,21 +993,9 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     unorderedListActive: _angular_core.WritableSignal<boolean>;
     orderedListActive: _angular_core.WritableSignal<boolean>;
     linkActive: _angular_core.WritableSignal<boolean>;
+    headingLevel: _angular_core.WritableSignal<number | null>;
     /** @internal */
     lastEmittedMarkdown: string | null;
-    /** @internal */
-    editorDom: {
-        root: _angular_core.WritableSignal<HTMLElement | null>;
-        getSelection: () => EditableSelection | null;
-        closestWithin: (node: Node | null, selector: string) => HTMLElement | null;
-        markStates: () => RichTextMarkStates | null;
-        toggleInline: (tag: InlineTag) => void;
-        toggleList: (listTag: ListTag) => void;
-        applyLink: (href: string) => void;
-        removeLink: () => void;
-        insertToken: (node: Node) => void;
-        handleBackspace: () => boolean;
-    };
     constructor();
     activate(): void;
     syncFromDom(): void;
@@ -640,27 +1005,53 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     toggleStrikethrough(): void;
     toggleUnorderedList(): void;
     toggleOrderedList(): void;
+    toggleHeading(level: number): void;
     setLink(href: string): void;
+    promptForLink(): void;
     handleBackspace(): boolean;
     /**
      * @internal Extension seam for the follow-up `@`/`#` autocomplete: inserts an atomic inline
      * node (a mention/placeholder token) at the caret, then re-syncs.
      */
     insertAtomicToken(node: Node): void;
+    private serializeCleanHtml;
     private runCommand;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RichTextEditorDirective, "[etRichTextEditor]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
+declare class RichTextEditorFloatingToolbarComponent {
+    protected dir: RichTextEditorDirective;
+    private document;
+    private renderer;
+    private destroyRef;
+    private host;
+    protected visible: _angular_core.WritableSignal<boolean>;
+    private activeRange;
+    private floatingReference;
+    private floatingCleanup;
+    private pointerSelectingInContent;
+    constructor();
+    private selectableRange;
+    private finishContentPointerSelection;
+    private evaluate;
+    private reposition;
+    private start;
+    private updatePosition;
+    private hide;
+    private stop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorFloatingToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorFloatingToolbarComponent, "et-rich-text-editor-floating-toolbar", never, {}, {}, never, never, true, never>;
+}
+
 declare class RichTextEditorComponent {
     protected dir: RichTextEditorDirective;
     private document;
     private editable;
     constructor();
-    protected onInput(): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    protected onBeforeInput(event: InputEvent): void;
-    protected promptForLink(): void;
+    protected syncValueFromDom(): void;
+    protected interceptBackspaceKey(event: KeyboardEvent): void;
+    protected interceptFormattingCommand(event: InputEvent): void;
     private renderExternalValue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "et-rich-text-editor", never, {}, {}, never, never, true, [{ directive: typeof RichTextEditorDirective; inputs: { "value": "value"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "placeholder": "placeholder"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }]>;
@@ -728,10 +1119,6 @@ declare class SelectionListDirective implements SelectionListDirectiveBase, Form
 }
 
 declare class CheckboxGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -749,12 +1136,17 @@ declare class CheckboxGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    size: _angular_core.InputSignal<FormFieldSize>;
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxGroupComponent, "et-checkbox-group", never, {}, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxGroupComponent, "et-checkbox-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class SelectionListControlDirective {
@@ -799,10 +1191,6 @@ declare class CheckboxOptionComponent {
 }
 
 declare class RadioGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -820,12 +1208,17 @@ declare class RadioGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    size: _angular_core.InputSignal<FormFieldSize>;
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "et-radio-group", never, {}, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "et-radio-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class RadioComponent {
@@ -838,10 +1231,6 @@ declare class RadioComponent {
 }
 
 declare class SegmentedButtonGroupComponent {
-    private errorContentRef;
-    private hintContentRef;
-    private errorAnimatableRef;
-    private hintAnimatableRef;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -859,19 +1248,29 @@ declare class SegmentedButtonGroupComponent {
         visibleErrors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
         supportHeight: _angular_core.Signal<number>;
     };
+    size: _angular_core.InputSignal<FormFieldSize>;
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    /** @internal The active background element of the currently checked button. Used as the flip animation origin. */
+    lastActiveBackgroundElement: _angular_core.WritableSignal<HTMLElement | null>;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedButtonGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonGroupComponent, "et-segmented-button-group", never, {}, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonGroupComponent, "et-segmented-button-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["et-label", ".et-segmented-button-group-label", "*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "touched": "touched"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class SegmentedButtonComponent {
     optionDirective: SelectionOptionDirective;
+    private group;
+    private backgroundRef;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedButtonComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonComponent, "et-segmented-button", never, {}, {}, never, ["*"], true, [{ directive: typeof SelectionOptionDirective; inputs: { "value": "value"; "checked": "checked"; "disabled": "disabled"; }; outputs: { "checkedChange": "checkedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
@@ -942,6 +1341,14 @@ type GridLayoutEntry = {
     id: string;
     position: GridItemPosition;
 };
+/**
+ * Contract for a grid item's `actionsComponent`: a component that receives the item's `itemId` and
+ * `data` as inputs. Both are always provided by the grid.
+ */
+type GridItemActionsComponent<TData = unknown> = Type<{
+    itemId: InputSignal<string>;
+    data: InputSignal<TData>;
+}>;
 type GridComponentRegistration<TData = unknown> = {
     component: Type<{
         data: InputSignal<TData>;
@@ -979,13 +1386,16 @@ type GridDragState = {
 };
 declare class GridDirective {
     private injector;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    private gridConfig;
+    private reducedMotion;
     breakpoints: _angular_core.InputSignal<GridBreakpointConfig[]>;
     rowHeight: _angular_core.InputSignal<number>;
     gap: _angular_core.InputSignal<number>;
     initialItems: _angular_core.InputSignal<GridItemConfig[]>;
     readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     layoutChange: _angular_core.OutputEmitterRef<GridSerializedState>;
-    private gridConfig;
     registrations: _angular_core.Signal<GridComponentRegistration[]>;
     private dimensions;
     private itemConfigs;
@@ -993,40 +1403,55 @@ declare class GridDirective {
     dragState: _angular_core.WritableSignal<GridDragState | null>;
     private constraintsRegistry;
     private resizeBaseLayout;
-    private itemElements;
-    private ghostElement;
-    private rectSnapshot;
+    private pendingResize;
+    private lastResizeTarget;
+    leavingIds: _angular_core.WritableSignal<ReadonlySet<string>>;
+    isResizeActive: _angular_core.WritableSignal<boolean>;
+    private animationsReady;
+    private isContainerResizing;
     containerWidth: _angular_core.Signal<number>;
+    isReady: _angular_core.Signal<boolean>;
+    animationsEnabled: _angular_core.Signal<boolean>;
     activeBreakpoint: _angular_core.Signal<string>;
     activeColumns: _angular_core.Signal<number>;
+    private paddings;
+    geometry: _angular_core.Signal<_ethlete_components.GridGeometry>;
     items: _angular_core.Signal<GridItemConfig[]>;
     baseLayout: _angular_core.Signal<GridLayoutEntry[]>;
     layout: _angular_core.Signal<GridLayoutEntry[]>;
+    containerHeightPx: _angular_core.Signal<number>;
+    protected hostHeight: _angular_core.Signal<number | null>;
+    protected containerTransition: _angular_core.Signal<"none" | "height var(--et-grid-anim-duration, 250ms) cubic-bezier(0.2, 0, 0, 1)">;
     ghostPosition: _angular_core.Signal<GridItemPosition | null>;
     constructor();
+    getContainerOrigin(): {
+        left: number;
+        top: number;
+    };
     registerConstraints(id: string, constraints: GridItemConstraints): void;
-    registerItem(id: string, options: {
-        el: HTMLElement;
-        constraints: GridItemConstraints;
-    }): void;
-    unregisterItem(id: string): void;
-    setGhostElement(el: HTMLElement | null): void;
+    unregisterConstraints(id: string): void;
     getConstraints(id: string): GridItemConstraints;
-    snapshotRects(): void;
-    animateLayoutTransition(options?: {
-        excludeIds?: Set<string>;
-        scaleIds?: Set<string>;
+    beginDrag(itemId: string): GridItemPosition | null;
+    updateDragTarget(cell: {
+        col: number;
+        row: number;
     }): void;
-    beginDrag(itemId: string): void;
-    updateDragTarget(targetPosition: GridItemPosition): void;
-    commitDrag(): void;
+    commitDrag(): GridItemPosition | null;
+    cancelDrag(): void;
+    beginResize(itemId: string): GridItemPosition | null;
+    updateResize(itemId: string, target: GridItemPosition): void;
+    commitResize(): GridItemPosition | null;
+    cancelResize(): void;
+    /** One-shot resize (keyboard / programmatic): begin + update + commit in a single call. */
+    resizeItem(options: ResizeItemOptions): void;
     addItem(type: string, data: unknown): void;
     removeItem(id: string): void;
     moveItem(id: string, newPosition: GridItemPosition): void;
-    resizeItem(options: ResizeItemOptions): void;
-    commitResize(): void;
     getSerializedState(): GridSerializedState;
     restoreState(state: GridSerializedState): void;
+    /** Dev-mode-only: rejects consumer-provided item configs whose ids are not unique. */
+    private assertValidItemConfigs;
+    private finalizeRemove;
     private placeItem;
     private shrinkNeighbors;
     /** Compact all visited breakpoints (layoutOverrides entries) after an item is removed. */
@@ -1038,42 +1463,295 @@ declare class GridDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDirective, "[etGrid]", ["etGrid"], { "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "initialItems": { "alias": "initialItems"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; }, never, never, true, never>;
 }
 
-declare class GridItemDirective {
-    private grid;
-    hostElement: ElementRef<HTMLElement>;
-    itemId: _angular_core.InputSignal<string>;
-    minColSpan: _angular_core.InputSignalWithTransform<number, unknown>;
-    maxColSpan: _angular_core.InputSignalWithTransform<number, unknown>;
-    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>;
-    constructor();
-    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>;
+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>;
+    maxColSpan: _angular_core.InputSignalWithTransform<number, unknown>;
+    minRowSpan: _angular_core.InputSignalWithTransform<number, unknown>;
+    maxRowSpan: _angular_core.InputSignalWithTransform<number, unknown>;
+    isBeingDragged: _angular_core.Signal<boolean>;
+    currentPosition: _angular_core.Signal<_ethlete_components.GridItemPosition | null>;
+    /** 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>;
 }
 
 declare class GridDragDirective {
-    protected grid: _ethlete_components.GridDirective;
+    protected grid: _ethlete_components.GridDirective | null;
     private gridItem;
-    private injector;
     private elementRef;
+    private destroyRef;
+    private document;
     dragHandle: DragHandleDirective;
-    private renderer;
-    private dragStartClient;
-    private dragPixelOffset;
-    protected dragTransform: _angular_core.Signal<string>;
+    private origin;
+    private startBreakpoint;
+    private grabOffset;
+    private containerOrigin;
+    private lastPointer;
+    private lastTarget;
+    private gestureListeners;
+    private autoScroller;
     constructor();
-    private applyFixed;
-    private releaseFixed;
+    private startDrag;
+    private trackDragMove;
+    private applyPointer;
+    private settleDrag;
+    private cancelDrag;
+    private finishGesture;
+    private attachGestureListeners;
+    private detachGestureListeners;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDragDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDragDirective, "[etGridDrag]", never, {}, {}, never, never, true, [{ directive: typeof _ethlete_core.DragHandleDirective; inputs: {}; outputs: { "dragStarted": "dragStarted"; "dragMoved": "dragMoved"; "dragEnded": "dragEnded"; }; }]>;
 }
@@ -1081,12 +1759,27 @@ declare class GridDragDirective {
 declare class GridResizeDirective {
     private grid;
     private gridItem;
+    private destroyRef;
+    private document;
     isResizing: _angular_core.WritableSignal<boolean>;
     resizeEdges: _angular_core.Signal<ResizeEdge[]>;
-    private resizeStartPos;
+    private start;
+    private startBreakpoint;
+    private lastSnap;
+    private lastEvent;
+    private startContainerOrigin;
+    private containerOrigin;
+    private gestureListeners;
+    private autoScroller;
+    constructor();
     beginResize(): void;
     updateResize(event: ResizeMoveEvent): void;
     finishResize(): void;
+    cancelResize(): void;
+    private applyResize;
+    private finishGesture;
+    private attachGestureListeners;
+    private detachGestureListeners;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridResizeDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridResizeDirective, "[etGridResize]", never, {}, {}, never, never, true, never>;
 }
@@ -1097,12 +1790,9 @@ type GridConfig = {
     registrations: GridComponentRegistration[];
     interactiveAriaLabel: string;
     readonlyAriaLabel: string;
-    dragHandleAriaLabel: string;
+    removeActionAriaLabel: string;
     transformer: (text: string, locale: string) => string;
-    /** Replaces the default drag handle for all registered items. Receives `data` and `itemId` as inputs. */
-    dragHandleComponent?: Type<unknown>;
-    /** Replaces the default ✕ button for all registered items. Receives `data` and `itemId` as inputs. */
-    actionsComponent?: Type<unknown>;
+    actionsComponent?: GridItemActionsComponent | null;
 };
 declare const provideGridConfig: (valueOverride?: Partial<GridConfig> | undefined) => _angular_core.Provider[];
 declare const injectGridConfig: {
@@ -1135,20 +1825,16 @@ declare const fromGridPosition: (pos: GridItemPosition) => {
 
 declare class GridComponent {
     grid: GridDirective;
-    private ghostRef;
     private gridConfig;
     private locale;
-    protected isReadOnly: _angular_core.Signal<boolean>;
-    protected dragHandleComponent: _angular_core.Signal<_angular_core.Type<unknown> | undefined>;
-    protected actionsComponent: _angular_core.Signal<_angular_core.Type<unknown> | undefined>;
+    protected actionsComponent: _angular_core.Signal<_ethlete_components.GridItemActionsComponent | null>;
     protected registeredItems: _angular_core.Signal<{
         item: _ethlete_components.GridItemConfig;
         reg: _ethlete_components.GridComponentRegistration;
     }[]>;
     protected ariaLabel: _angular_core.Signal<string>;
-    protected gridColumns: _angular_core.Signal<number>;
-    protected gridGap: _angular_core.Signal<string>;
-    protected gridRowHeight: _angular_core.Signal<string>;
+    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)">;
     constructor();
     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"; }; }]>;
@@ -1161,18 +1847,33 @@ declare class GridItemComponent {
     private parentSurfaceProvider;
     gridDrag: GridDragDirective;
     gridResize: GridResizeDirective;
+    private surfaceThemes;
     ariaLabel: _angular_core.InputSignal<string>;
     removed: _angular_core.OutputEmitterRef<void>;
-    private surfaceThemes;
-    private gridConfig;
-    private locale;
     protected isReadOnly: _angular_core.Signal<boolean>;
-    protected dragHandleAriaLabel: _angular_core.Signal<string>;
     private resolvedSurface;
     constructor();
+    protected blockPointerDownWhenReadOnly(event: PointerEvent): void;
     applyKeyboardShortcut(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemComponent, "et-grid-item, [et-grid-item]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["[etGridItemDragHandle]", "*", "[etGridItemAction]"], true, [{ directive: typeof GridItemDirective; inputs: { "itemId": "itemId"; "minColSpan": "minColSpan"; "maxColSpan": "maxColSpan"; "minRowSpan": "minRowSpan"; "maxRowSpan": "maxRowSpan"; }; outputs: {}; }, { directive: typeof GridDragDirective; inputs: {}; outputs: {}; }, { directive: typeof GridResizeDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemComponent, "et-grid-item, [et-grid-item]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*", "[etGridItemAction]"], true, [{ directive: typeof GridItemDirective; inputs: { "itemId": "itemId"; "minColSpan": "minColSpan"; "maxColSpan": "maxColSpan"; "minRowSpan": "minRowSpan"; "maxRowSpan": "maxRowSpan"; }; outputs: {}; }, { directive: typeof GridDragDirective; inputs: {}; outputs: {}; }, { directive: typeof GridResizeDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GridItemToolbarComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemToolbarComponent, "et-grid-item-toolbar, [et-grid-item-toolbar]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GridItemDefaultActionsComponent {
+    private grid;
+    private gridConfig;
+    private locale;
+    itemId: _angular_core.InputSignal<string>;
+    data: _angular_core.InputSignal<unknown>;
+    protected removeAriaLabel: _angular_core.Signal<string>;
+    protected remove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItemDefaultActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridItemDefaultActionsComponent, "et-grid-item-default-actions", never, { "itemId": { "alias": "itemId"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -1223,14 +1924,52 @@ declare const GRID_ERROR_CODES: {
     readonly MISSING_GRID_ITEM: 1901;
     readonly DUPLICATE_ITEM_ID: 1902;
     readonly INVALID_LAYOUT_STATE: 1903;
+    readonly UNKNOWN_ITEM_TYPE: 1904;
 };
 
-declare const GridImports: readonly [typeof GridComponent, typeof GridItemComponent, typeof GridDebugComponent];
+declare const GridImports: readonly [typeof GridComponent, typeof GridItemComponent, typeof GridItemToolbarComponent, typeof GridItemDefaultActionsComponent, typeof GridDebugComponent];
 
 type IconDefinition = {
     name: string;
+    /**
+     * Optional style variant (e.g. `'solid'`, `'light'`, `'regular'`). Lets the same icon
+     * `name` exist in several styles without encoding the style into the name. Icons
+     * registered without a variant are matched by their bare name.
+     */
+    variant?: string;
     data: string;
 };
+/**
+ * Augmentable registry for the literal set of icon names an app uses. Empty by default,
+ * which keeps `etIcon` typed as plain `string`. The `@ethlete/components:icons` generator
+ * writes an augmentation for this interface, or you can augment it manually:
+ *
+ * ```ts
+ * declare module '@ethlete/components' {
+ *   interface EthleteIconNameRegistry {
+ *     name: 'shield' | 'plus';
+ *   }
+ * }
+ * ```
+ */
+interface EthleteIconNameRegistry {
+}
+/**
+ * Augmentable registry for the literal set of icon variants an app uses. Empty by default,
+ * which keeps the `variant` input typed as plain `string`. See {@link EthleteIconNameRegistry}.
+ */
+interface EthleteIconVariantRegistry {
+}
+type RegisteredIconName = EthleteIconNameRegistry extends {
+    name: infer N extends string;
+} ? N : string;
+type RegisteredIconVariant = EthleteIconVariantRegistry extends {
+    name: infer V extends string;
+} ? V : string;
+/** Variant the {@link IconDirective} falls back to when `etIcon` is used without an explicit `variant`. */
+declare const DEFAULT_ICON_VARIANT = "solid";
+/** Composite registry key for an icon `name` plus an optional `variant`. */
+declare const iconRegistryKey: (name: string, variant?: string | null) => string;
 declare const ICONS_TOKEN: InjectionToken<Record<string, IconDefinition>>;
 declare const provideIcons: (...icons: IconDefinition[]) => {
     provide: InjectionToken<Record<string, IconDefinition>>;
@@ -1247,12 +1986,20 @@ declare const CHEVRON_ICON: IconDefinition;
 
 declare const CLIPBOARD_CHECK_ICON: IconDefinition;
 
+declare const FILE_ICON: IconDefinition;
+
 declare const FLOPPY_DISK_ICON: IconDefinition;
 
 declare const FOCUS_FRAME_ICON: IconDefinition;
 
 declare const GRID_2X2_ICON: IconDefinition;
 
+declare const HEADING_1_ICON: IconDefinition;
+
+declare const HEADING_2_ICON: IconDefinition;
+
+declare const HEADING_3_ICON: IconDefinition;
+
 declare const ICON_ERROR_CODES: {
     readonly NO_ICONS_PROVIDED: 1800;
     readonly ICON_NOT_FOUND: 1801;
@@ -1263,78 +2010,806 @@ declare const ICON_ERROR_CODES: {
     readonly DUPLICATE_ICON_NAME: 1806;
 };
 
-declare const ICON_DIRECTIVE_TOKEN: InjectionToken<IconDirective>;
-declare class IconDirective {
-    private icons;
-    private sanitizer;
-    iconNameToUse: _angular_core.InputSignal<string>;
-    allowHardcodedColor: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    iconSrc: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
-    hostClasses: _angular_core.Signal<string>;
+declare const ICON_DIRECTIVE_TOKEN: InjectionToken<IconDirective>;
+declare class IconDirective {
+    private icons;
+    private sanitizer;
+    iconNameToUse: InputSignal<RegisteredIconName>;
+    variant: InputSignal<RegisteredIconVariant | undefined>;
+    allowHardcodedColor: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private resolvedIcon;
+    iconSrc: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
+    hostClasses: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconDirective, "[etIcon]", never, { "iconNameToUse": { "alias": "etIcon"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "allowHardcodedColor": { "alias": "allowHardcodedColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const ITALIC_ICON: IconDefinition;
+
+declare const LINK_ICON: IconDefinition;
+
+declare const LIST_BULLETED_ICON: IconDefinition;
+
+declare const LIST_NUMBERED_ICON: IconDefinition;
+
+declare const LOCK_ICON: IconDefinition;
+
+declare const PENCIL_ICON: IconDefinition;
+
+declare const PLUS_ICON: IconDefinition;
+
+declare const ROTATE_RIGHT_ICON: IconDefinition;
+
+declare const STRIKETHROUGH_ICON: IconDefinition;
+
+declare const TIMES_ICON: IconDefinition;
+
+declare const TRIANGLE_EXCLAMATION_ICON: IconDefinition;
+
+declare const UPLOAD_ICON: IconDefinition;
+
+declare const ICON_IMPORTS: readonly [typeof IconDirective];
+
+declare class BrandLoaderComponent {
+    readonly PATH = "M15.905 6.21401C15.7794 6.8902 16.2818 7.51877 16.9517 7.51877H23.8598L22.9201 12.3378H15.6817C15.1048 12.3378 14.6071 12.7569 14.5001 13.3378C14.4861 13.4188 14.4768 13.4997 14.4768 13.5811C14.4768 14.2426 15.0071 14.8092 15.6817 14.8092H23.9435L22.9201 19.9997H6.79183L7.2198 17.814H7.64313C7.94085 17.814 8.20601 17.6907 8.40139 17.495C8.59212 17.2954 8.71307 17.0235 8.71307 16.7235C8.71307 16.1188 8.23858 15.6331 7.64778 15.6288H2.73534C2.14919 15.6288 1.67004 15.1426 1.67004 14.5378C1.67004 14.2383 1.791 13.9621 1.98172 13.7664C2.17711 13.5711 2.44227 13.4473 2.73534 13.4473H8.07111L8.96428 8.88115H9.39226C9.68533 8.88115 9.95049 8.75686 10.1459 8.5621C10.3366 8.3621 10.4576 8.08591 10.4576 7.78543C10.4576 7.18543 9.9784 6.69543 9.39226 6.69543H4.48447C3.89367 6.69543 3.41452 6.20448 3.41452 5.60496C3.41452 5.30448 3.53547 5.02877 3.7262 4.82829C3.92158 4.63353 4.19139 4.50924 4.48447 4.50924H10.2436C10.5366 4.50924 10.8064 4.3902 10.9972 4.1902C11.1879 3.99496 11.3089 3.72401 11.3089 3.41877C11.3089 2.81401 10.8344 2.32829 10.2436 2.32829H1.06994C0.479149 2.32829 0 1.83829 0 1.23305C0 0.933054 0.12095 0.656864 0.31168 0.461626C0.507061 0.266864 0.776873 0.142578 1.06994 0.142578H26.4369L25.4135 5.33305H16.9517C16.4446 5.33305 16.0027 5.70496 15.905 6.21401Z";
+    readonly OUTLINE_PATH = "M1.07 0.14 L26.44 0.14 L25.41 5.33 L16.95 5.33 C16.44 5.33 16.0 5.70 15.91 6.21 C15.78 6.89 16.28 7.52 16.95 7.52 L23.86 7.52 L22.92 12.34 L15.68 12.34 C15.10 12.34 14.61 12.76 14.50 13.34 C14.49 13.42 14.48 13.50 14.48 13.58 C14.48 14.24 15.01 14.81 15.68 14.81 L23.94 14.81 L22.92 20.0 L6.79 20.0 L7.22 17.81 L7.64 17.81 C7.94 17.81 8.21 17.69 8.40 17.50 C8.59 17.30 8.71 17.02 8.71 16.72 C8.71 16.12 8.24 15.63 7.65 15.63 L2.74 15.63 C2.15 15.63 1.67 15.14 1.67 14.54 C1.67 14.24 1.79 13.96 1.98 13.77 C2.18 13.57 2.44 13.45 2.74 13.45 L8.07 13.45 L8.96 8.88 L9.39 8.88 C9.69 8.88 9.95 8.76 10.15 8.56 C10.34 8.36 10.46 8.09 10.46 7.79 C10.46 7.19 9.98 6.70 9.39 6.70 L4.48 6.70 C3.89 6.70 3.41 6.20 3.41 5.60 C3.41 5.30 3.54 5.03 3.73 4.83 C3.92 4.63 4.19 4.51 4.48 4.51 L10.24 4.51 C10.54 4.51 10.81 4.39 10.997 4.19 C11.188 3.99 11.31 3.72 11.31 3.42 C11.31 2.81 10.83 2.33 10.24 2.33 L1.07 2.33 C0.48 2.33 0 1.84 0 1.23 C0 0.93 0.12 0.66 0.31 0.46 C0.51 0.27 0.78 0.14 1.07 0.14 Z";
+    readonly SHAPE_CLIP_ID: string;
+    shapeClip: string;
+    readonly FILL_CLIP_ID: string;
+    fillClip: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrandLoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BrandLoaderComponent, "et-brand-loader", never, {}, {}, never, never, true, never>;
+}
+
+declare class ProgressBarComponent {
+    value: _angular_core.InputSignalWithTransform<number, unknown>;
+    indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clampedValue: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "et-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SpinnerComponent {
+    diameter: _angular_core.InputSignalWithTransform<number, unknown>;
+    strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    track: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    value: _angular_core.InputSignalWithTransform<number, unknown>;
+    determinate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    circleRadius: _angular_core.Signal<number>;
+    normalizedStrokeWidth: _angular_core.Signal<number>;
+    viewBox: _angular_core.Signal<string>;
+    strokeCircumference: _angular_core.Signal<number>;
+    circleStrokeWidth: _angular_core.Signal<number>;
+    clampedValue: _angular_core.Signal<number>;
+    determinateDashOffset: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    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 MenuContextTriggerDirective {
+    private menu;
+    private document;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    private repositionSubscription;
+    constructor();
+    isOpen(): boolean;
+    protected handleContextMenu(event: MouseEvent): void;
+    private attachRepositionListener;
+    private detachRepositionListener;
+    private isEventOnZone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContextTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContextTriggerDirective, "[etMenuContextTrigger]", ["etMenuContextTrigger"], {}, {}, never, never, true, never>;
+}
+
+type OverlayStrategyContext = {
+    overlayRef: OverlayRef<object, unknown>;
+    runtimeRef: OverlayRuntimeRef<object, unknown>;
+    /** The mounted container component's host element (the runtime pane element). */
+    containerEl: HTMLElement;
+    /** The runtime host element wrapping backdrop and pane. */
+    hostEl: HTMLElement;
+    backdropEl: HTMLElement | null;
+    /** The container's animated lifecycle, driving enter/leave transitions. */
+    lifecycle: AnimatedLifecycleDirective;
+    config: OverlayBreakpointConfig;
+    previousConfig?: OverlayBreakpointConfig;
+    origin?: HTMLElement | Event;
+};
+type OverlayStrategy = {
+    /** Unique identifier for the strategy */
+    id: string;
+    /** Configuration for the overlay when this strategy is applied */
+    config: OverlayBreakpointConfig;
+    /**
+     * Called when the overlay transitions FROM another strategy TO this strategy.
+     * Only called during breakpoint changes, not on initial open.
+     * @example Fullscreen dialog → Regular dialog on viewport resize
+     */
+    onSwitchedTo?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay transitions FROM this strategy TO another strategy.
+     * Only called during breakpoint changes, not on close.
+     * Use this to cleanup strategy-specific state when transitioning layouts.
+     * @example Regular dialog → Fullscreen dialog on viewport resize
+     */
+    onSwitchedAwayFrom?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay is first opened with this strategy.
+     * Use this for initial setup and enter animations.
+     * The hook is responsible for starting the enter transition (e.g. `context.lifecycle.enter()`).
+     */
+    onBeforeEnter?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called after the overlay has completed its enter animation.
+     */
+    onAfterEnter?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called when the overlay is about to close (beforeClosed).
+     * The hook is responsible for starting the leave transition (e.g. `context.lifecycle.leave()`).
+     */
+    onBeforeLeave?: (context: OverlayStrategyContext) => void;
+    /**
+     * Called after the overlay has been closed (afterClosed).
+     * Use this for final cleanup.
+     */
+    onAfterLeave?: (context: OverlayStrategyContext) => void;
+};
+type OverlayStrategyBreakpoint = {
+    /**
+     * Breakpoint to apply the strategy for. If a number is provided, it will be used as a pixel value.
+     * Always uses the min-width media query.
+     *
+     * @default 'xs' // 0px
+     */
+    breakpoint?: Breakpoint | number;
+    /** Overlay strategy to be applied when the breakpoint is active. */
+    strategy: OverlayStrategy;
+};
+type OverlayDragToDismissConfig = {
+    /** Direction in which the overlay can be dragged. */
+    direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';
+    /**
+     * The minimum distance in pixels that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px
+     */
+    minDistanceToDismiss?: number;
+    /**
+     * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px/s
+     */
+    minVelocityToDismiss?: number;
+};
+type OverlayBreakpointConfig = {
+    /** Min-width of the overlay. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Max-width of the overlay. If a number is provided, assumes pixel units. */
+    maxWidth?: number | string;
+    /** Min-height of the overlay. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-height of the overlay. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Width of the overlay. */
+    width?: number | string;
+    /** Height of the overlay. */
+    height?: number | string;
+    /** Position strategy to be used for the overlay. */
+    positionStrategy?: (origin?: HTMLElement) => OverlayRuntimePositionStrategy;
+    /** Custom class for the overlay container (the runtime pane element hosting the overlay content). */
+    containerClass?: string | string[];
+    /** Custom class for the runtime host element wrapping backdrop and pane. */
+    hostClass?: string | string[];
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Custom class for the document (`<html>` element). */
+    documentClass?: string | string[];
+    /** Custom class for the `<body>` element */
+    bodyClass?: string | string[];
+    /** Determine if and in what direction the overlay should be able to be dragged to dismiss it. */
+    dragToDismiss?: OverlayDragToDismissConfig;
+    /**
+     * Whether a backdrop element is rendered behind the overlay. Only applied at mount time (the
+     * initially matched strategy) — it cannot change during breakpoint switches. An explicit
+     * `hasBackdrop` on the overlay config always wins over this strategy default.
+     *
+     * @default undefined // falls back to the overlay config / modal behavior
+     */
+    hasBackdrop?: boolean;
+    /**
+     * Whether the transform origin should be set using the config's `origin` property value.
+     *
+     * @default false
+     */
+    applyTransformOrigin?: boolean;
+    /**
+     * Renders a floating-ui-positioned arrow on the overlay container that points at the origin.
+     * Only meaningful for anchored positioning. The arrow inherits the pane background; combine with
+     * an `offset` so the pane leaves room for it.
+     *
+     * @default false
+     */
+    arrow?: boolean;
+};
+
+type OverlayAutoFocusTarget = 'container' | 'first-heading' | 'first-tabbable';
+type OverlayRole = 'dialog' | 'alertdialog';
+type OverlayMode = 'modal' | 'non-modal';
+type OverlayConfig = {
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+    id?: string;
+    /**
+     * The element or event the overlay was opened from. Used as the anchor reference
+     * for anchored positioning and as the transform origin for strategy animations.
+     * When omitted and strategies are used, falls back to the currently focused element.
+     */
+    origin?: HTMLElement | Event;
+    role?: OverlayRole;
+    hasBackdrop?: boolean;
+    disableClose?: boolean;
+    /**
+     * Bindings applied to the overlay component, using Angular's native binding API
+     * (`inputBinding`, `outputBinding`, `twoWayBinding`).
+     */
+    bindings?: Binding[];
+    ariaDescribedBy?: string | null;
+    ariaLabelledBy?: string | null;
+    ariaLabel?: string | null;
+    autoFocus?: OverlayAutoFocusTarget | string | false;
+    restoreFocus?: boolean;
+    providers?: StaticProvider[];
+    hostClass?: string | string[];
+    backdropClass?: string | string[];
+    panelClass?: string | string[];
+    mode?: OverlayMode;
+    closeOnOutsidePointer?: boolean;
+    closeOnEscape?: boolean;
+    /**
+     * Breakpoint-driven overlay strategies (dialog, sheets, full-screen, …).
+     * When set, position, sizing and classes are controlled by the active strategy.
+     */
+    strategies?: () => OverlayStrategyBreakpoint[];
+    /**
+     * Disables the default overlay animations so custom ones can be applied.
+     *
+     * @default false
+     */
+    customAnimated?: boolean;
+};
+
+declare const createOverlayRef: <TComponent extends object, TResult = unknown>(config: OverlayConfig) => {
+    readonly id: string;
+    readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+    config: OverlayConfig;
+    headerTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
+    /** @internal Set (or clear) the active header template. */
+    setHeaderTemplate: (template: TemplateRef<unknown> | null) => void;
+    componentInstance: () => TComponent | null;
+    close: (result?: TResult) => void;
+    closeVia: (source: OverlayRuntimeCloseSource, result?: TResult) => void;
+    updatePositionStrategy: (strategy: OverlayRuntimePositionStrategy) => void;
+    attachComponentInstanceOverride: (getter: () => TComponent | null) => void;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<TResult | undefined>;
+    afterClosed: () => Observable<TResult | undefined>;
+    attachRuntime: (runtimeRef: OverlayRuntimeRef<TComponent, TResult>) => void;
+};
+type OverlayRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRef<TComponent, TResult>>;
+declare const OVERLAY_REF: InjectionToken<{
+    readonly id: string;
+    readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+    config: OverlayConfig;
+    headerTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
+    /** @internal Set (or clear) the active header template. */
+    setHeaderTemplate: (template: TemplateRef<unknown> | null) => void;
+    componentInstance: () => object | null;
+    close: (result?: unknown) => void;
+    closeVia: (source: OverlayRuntimeCloseSource, result?: unknown) => void;
+    updatePositionStrategy: (strategy: OverlayRuntimePositionStrategy) => void;
+    attachComponentInstanceOverride: (getter: () => object | null) => void;
+    afterOpened: () => Observable<void>;
+    beforeClosed: () => Observable<unknown>;
+    afterClosed: () => Observable<unknown>;
+    attachRuntime: (runtimeRef: OverlayRuntimeRef<object, unknown>) => void;
+}>;
+
+declare class OverlayAnchorDirective {
+    private overlay;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayAnchorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayAnchorDirective, "[etOverlayAnchor]", ["etOverlayAnchor"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayTriggerDirective {
+    private overlay;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    toggle(): void;
+    isOpen(): boolean;
+    expanded(): boolean | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTriggerDirective, "[etOverlayTrigger]", ["etOverlayTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayDirective {
+    private destroyRef;
+    private overlayManager;
+    mode: _angular_core.InputSignal<OverlayMode>;
+    role: _angular_core.InputSignal<OverlayRole | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    disableClose: _angular_core.InputSignal<boolean>;
+    autoFocus: _angular_core.InputSignal<string | false | undefined>;
+    restoreFocus: _angular_core.InputSignal<boolean>;
+    hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
+    closeOnEscape: _angular_core.InputSignal<boolean>;
+    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
+    hostClass: _angular_core.InputSignal<string | string[] | undefined>;
+    backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
+    panelClass: _angular_core.InputSignal<string | string[] | undefined>;
+    placement: _angular_core.InputSignal<Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    autoResize: _angular_core.InputSignal<boolean>;
+    shift: _angular_core.InputSignal<boolean>;
+    autoHide: _angular_core.InputSignal<boolean>;
+    autoCloseIfReferenceHidden: _angular_core.InputSignal<boolean>;
+    mirrorWidth: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    registeredAnchor: _angular_core.WritableSignal<OverlayAnchorDirective | null>;
+    /** @internal */
+    registeredSurface: _angular_core.WritableSignal<OverlaySurfaceDirective | null>;
+    /** @internal */
+    registeredTrigger: _angular_core.WritableSignal<OverlayTriggerDirective | null>;
+    /** @internal */
+    overlayRef: _angular_core.WritableSignal<OverlayRef<OverlayTemplateHostComponent, unknown> | null>;
+    isMounted: _angular_core.Signal<boolean>;
+    private originElement;
+    constructor();
+    show(): void;
+    hide(result?: unknown): void;
+    toggle(): void;
+    /** @internal */
+    unregisterTrigger(trigger: OverlayTriggerDirective): void;
+    /** @internal */
+    unregisterAnchor(anchor: OverlayAnchorDirective): void;
+    /** @internal */
+    unregisterSurface(surface: OverlaySurfaceDirective): void;
+    private mountOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayDirective, "[etOverlay]", ["etOverlay"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePointer": { "alias": "closeOnOutsidePointer"; "required": false; "isSignal": true; }; "hostClass": { "alias": "hostClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fallbackPlacements": { "alias": "fallbackPlacements"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoCloseIfReferenceHidden": { "alias": "autoCloseIfReferenceHidden"; "required": false; "isSignal": true; }; "mirrorWidth": { "alias": "mirrorWidth"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+type OverlaySurfaceContext = {
+    $implicit: OverlayDirective;
+    overlay: OverlayDirective;
+    close: (result?: unknown) => void;
+};
+declare class OverlaySurfaceDirective {
+    private overlay;
+    templateRef: TemplateRef<OverlaySurfaceContext>;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySurfaceDirective, "ng-template[etOverlaySurface]", ["etOverlaySurface"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayTemplateHostComponent {
+    protected template: _angular_core.InputSignal<TemplateRef<OverlaySurfaceContext>>;
+    protected context: _angular_core.InputSignal<OverlaySurfaceContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTemplateHostComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayTemplateHostComponent, "et-overlay-template-host", never, { "template": { "alias": "template"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MenuPanelDirective {
+    /** @internal */
+    menu: MenuDirective | null;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    protected labelledBy: _angular_core.Signal<string | null>;
+    protected busy: _angular_core.Signal<true | null>;
+    constructor();
+    /** @internal */
+    focus(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    protected handlePointerEnter(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuPanelDirective, "[etMenuPanel]", ["etMenuPanel"], {}, {}, never, never, true, never>;
+}
+
+declare class MenuSearchDirective {
+    private menu;
+    private document;
+    elementRef: ElementRef<HTMLInputElement>;
+    private destroyRef;
+    query: _angular_core.ModelSignal<string>;
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    error: _angular_core.InputSignal<string | null>;
+    /** @internal Id of the element rendering the error message, set by the component displaying it. */
+    errorElementId: _angular_core.WritableSignal<string | null>;
+    constructor();
+    /** @internal */
+    isFocused(): boolean;
+    /** @internal */
+    focus(options?: {
+        select?: boolean;
+    }): void;
+    /** @internal Focuses the input and appends a character typed while an item had focus. */
+    appendCharacter(character: string): void;
+    clear(): void;
+    protected handleInput(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSearchDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSearchDirective, "input[etMenuSearch]", ["etMenuSearch"], { "query": { "alias": "query"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "query": "queryChange"; }, never, never, true, never>;
+}
+
+type MenuSurfaceContext = {
+    $implicit: MenuDirective;
+    menu: MenuDirective;
+    close: (result?: unknown) => void;
+};
+declare class MenuSurfaceDirective {
+    private menu;
+    templateRef: TemplateRef<MenuSurfaceContext>;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSurfaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSurfaceDirective, "ng-template[etMenuSurface]", ["etMenuSurface"], {}, {}, never, never, true, never>;
+}
+
+declare class MenuTriggerDirective {
+    /** @internal The menu this trigger opens - for submenu trigger items, that is the submenu. */
+    menu: MenuDirective | null;
+    elementRef: ElementRef<HTMLElement>;
+    private destroyRef;
+    /** @internal The same-element menu item this trigger is combined with, if any. Set by the item. */
+    hostItem: MenuItemDirective | null;
+    constructor();
+    /** @internal */
+    setHostItem(item: MenuItemDirective): void;
+    isOpen(): boolean;
+    protected expanded(): boolean | null;
+    protected controls(): string | null;
+    protected handleClick(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[etMenuTrigger]", ["etMenuTrigger"], {}, {}, never, never, true, never>;
+}
+
+type MenuCloseReason = 'item' | 'escape' | 'tab' | 'outside' | 'api';
+type MenuOpenSource = 'click' | 'hover' | 'keyboard' | 'api';
+type MenuAnchorPoint = {
+    x: number;
+    y: number;
+};
+declare class MenuDirective {
+    private destroyRef;
+    private document;
+    private overlayManager;
+    parent: MenuDirective | null;
+    placement: _angular_core.InputSignal<"auto" | Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<"auto" | OffsetOptions | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    /** Render an arrow pointing at the trigger. Trigger-anchored root menus only — submenus and context menus never render one. */
+    arrow: _angular_core.InputSignal<boolean>;
+    arrowPadding: _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 resolvedArrow;
+    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; }; "arrow": { "alias": "arrow"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "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();
-    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>;
+    /** @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 const ITALIC_ICON: IconDefinition;
-
-declare const LINK_ICON: IconDefinition;
-
-declare const LIST_BULLETED_ICON: IconDefinition;
-
-declare const LIST_NUMBERED_ICON: IconDefinition;
+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 const LOCK_ICON: IconDefinition;
+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 const PENCIL_ICON: IconDefinition;
+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 PLUS_ICON: IconDefinition;
+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 const STRIKETHROUGH_ICON: IconDefinition;
+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 TIMES_ICON: IconDefinition;
+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 {
+    private provideColor;
+    private errorColorTheme;
+    variant: _angular_core.InputSignal<MenuItemVariant>;
+    constructor();
+    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"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }]>;
+}
 
-declare const TRIANGLE_EXCLAMATION_ICON: IconDefinition;
+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 const ICON_IMPORTS: readonly [typeof IconDirective];
+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 BrandLoaderComponent {
-    readonly PATH = "M15.905 6.21401C15.7794 6.8902 16.2818 7.51877 16.9517 7.51877H23.8598L22.9201 12.3378H15.6817C15.1048 12.3378 14.6071 12.7569 14.5001 13.3378C14.4861 13.4188 14.4768 13.4997 14.4768 13.5811C14.4768 14.2426 15.0071 14.8092 15.6817 14.8092H23.9435L22.9201 19.9997H6.79183L7.2198 17.814H7.64313C7.94085 17.814 8.20601 17.6907 8.40139 17.495C8.59212 17.2954 8.71307 17.0235 8.71307 16.7235C8.71307 16.1188 8.23858 15.6331 7.64778 15.6288H2.73534C2.14919 15.6288 1.67004 15.1426 1.67004 14.5378C1.67004 14.2383 1.791 13.9621 1.98172 13.7664C2.17711 13.5711 2.44227 13.4473 2.73534 13.4473H8.07111L8.96428 8.88115H9.39226C9.68533 8.88115 9.95049 8.75686 10.1459 8.5621C10.3366 8.3621 10.4576 8.08591 10.4576 7.78543C10.4576 7.18543 9.9784 6.69543 9.39226 6.69543H4.48447C3.89367 6.69543 3.41452 6.20448 3.41452 5.60496C3.41452 5.30448 3.53547 5.02877 3.7262 4.82829C3.92158 4.63353 4.19139 4.50924 4.48447 4.50924H10.2436C10.5366 4.50924 10.8064 4.3902 10.9972 4.1902C11.1879 3.99496 11.3089 3.72401 11.3089 3.41877C11.3089 2.81401 10.8344 2.32829 10.2436 2.32829H1.06994C0.479149 2.32829 0 1.83829 0 1.23305C0 0.933054 0.12095 0.656864 0.31168 0.461626C0.507061 0.266864 0.776873 0.142578 1.06994 0.142578H26.4369L25.4135 5.33305H16.9517C16.4446 5.33305 16.0027 5.70496 15.905 6.21401Z";
-    readonly OUTLINE_PATH = "M1.07 0.14 L26.44 0.14 L25.41 5.33 L16.95 5.33 C16.44 5.33 16.0 5.70 15.91 6.21 C15.78 6.89 16.28 7.52 16.95 7.52 L23.86 7.52 L22.92 12.34 L15.68 12.34 C15.10 12.34 14.61 12.76 14.50 13.34 C14.49 13.42 14.48 13.50 14.48 13.58 C14.48 14.24 15.01 14.81 15.68 14.81 L23.94 14.81 L22.92 20.0 L6.79 20.0 L7.22 17.81 L7.64 17.81 C7.94 17.81 8.21 17.69 8.40 17.50 C8.59 17.30 8.71 17.02 8.71 16.72 C8.71 16.12 8.24 15.63 7.65 15.63 L2.74 15.63 C2.15 15.63 1.67 15.14 1.67 14.54 C1.67 14.24 1.79 13.96 1.98 13.77 C2.18 13.57 2.44 13.45 2.74 13.45 L8.07 13.45 L8.96 8.88 L9.39 8.88 C9.69 8.88 9.95 8.76 10.15 8.56 C10.34 8.36 10.46 8.09 10.46 7.79 C10.46 7.19 9.98 6.70 9.39 6.70 L4.48 6.70 C3.89 6.70 3.41 6.20 3.41 5.60 C3.41 5.30 3.54 5.03 3.73 4.83 C3.92 4.63 4.19 4.51 4.48 4.51 L10.24 4.51 C10.54 4.51 10.81 4.39 10.997 4.19 C11.188 3.99 11.31 3.72 11.31 3.42 C11.31 2.81 10.83 2.33 10.24 2.33 L1.07 2.33 C0.48 2.33 0 1.84 0 1.23 C0 0.93 0.12 0.66 0.31 0.46 C0.51 0.27 0.78 0.14 1.07 0.14 Z";
-    readonly SHAPE_CLIP_ID: string;
-    shapeClip: string;
-    readonly FILL_CLIP_ID: string;
-    fillClip: string;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrandLoaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BrandLoaderComponent, "et-brand-loader", never, {}, {}, never, never, true, never>;
+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 ProgressBarComponent {
-    value: _angular_core.InputSignalWithTransform<number, unknown>;
-    indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    clampedValue: _angular_core.Signal<number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "et-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+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 SpinnerComponent {
-    diameter: _angular_core.InputSignalWithTransform<number, unknown>;
-    strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
-    track: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    value: _angular_core.InputSignalWithTransform<number, unknown>;
-    determinate: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    circleRadius: _angular_core.Signal<number>;
-    normalizedStrokeWidth: _angular_core.Signal<number>;
-    viewBox: _angular_core.Signal<string>;
-    strokeCircumference: _angular_core.Signal<number>;
-    circleStrokeWidth: _angular_core.Signal<number>;
-    clampedValue: _angular_core.Signal<number>;
-    determinateDashOffset: _angular_core.Signal<number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
-    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 MenuComponent {
+    private ownColorProvider;
+    private contextColorProvider;
+    protected menu: MenuDirective | null;
+    protected errorColorTheme: _ethlete_core.ColorTheme;
+    private prefersReducedMotion;
+    private elementRef;
+    private destroyRef;
+    private renderer;
+    private headerElement;
+    private bodyElement;
+    private headerDimensions;
+    private bodyDimensions;
+    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 lastBlockSize;
+    private resizeAnimation;
+    constructor();
+    private animateToCurrentBlockSize;
+    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.AutoSurfaceDirective; 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();
@@ -1564,156 +3039,225 @@ declare class NotificationComponent {
 
 declare const NOTIFICATION_IMPORTS: readonly [typeof NotificationComponent, typeof NotificationDirective, typeof NotificationActionDirective, typeof NotificationDismissDirective];
 
-declare class OverlayAnchorDirective {
-    private overlay;
-    private destroyRef;
-    elementRef: ElementRef<HTMLElement>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayAnchorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayAnchorDirective, "[etOverlayAnchor]", ["etOverlayAnchor"], {}, {}, never, never, true, never>;
-}
-
-type OverlayAutoFocusTarget = 'container' | 'first-heading' | 'first-tabbable';
-type OverlayRole = 'dialog' | 'alertdialog';
-type OverlayMode = 'modal' | 'non-modal';
-type OverlayPositionStrategy = OverlayRuntimePositionStrategy;
-type OverlayConfig = {
-    viewContainerRef?: ViewContainerRef;
-    injector?: Injector;
-    id?: string;
-    origin?: HTMLElement;
-    role?: OverlayRole;
-    positionStrategy?: OverlayPositionStrategy;
-    hasBackdrop?: boolean;
-    disableClose?: boolean;
-    inputBindings?: Record<string, unknown>;
-    ariaDescribedBy?: string | null;
-    ariaLabelledBy?: string | null;
-    ariaLabel?: string | null;
-    autoFocus?: OverlayAutoFocusTarget | string | false;
-    restoreFocus?: boolean;
-    providers?: StaticProvider[];
-    hostClass?: string | string[];
-    backdropClass?: string | string[];
-    panelClass?: string | string[];
-    mode?: OverlayMode;
-    closeOnOutsidePointer?: boolean;
-    closeOnEscape?: boolean;
-};
-
-declare const createOverlayRef: <TComponent extends object, TResult = unknown>(config: OverlayConfig) => {
-    readonly id: string;
-    config: OverlayConfig;
-    readonly componentInstance: TComponent | null;
-    close(result?: TResult): void;
-    afterOpened(): Observable<void>;
-    beforeClosed(): Observable<TResult | undefined>;
-    afterClosed(): Observable<TResult | undefined>;
-    attachRuntime(runtimeRef: OverlayRuntimeRef<TComponent, TResult>): void;
+declare const getClosestOverlay: (element: ElementRef<HTMLElement>, openOverlays: OverlayRef<object, unknown>[]) => OverlayRef<object, unknown> | null;
+type ResolveClosestOverlayOptions = {
+    overlayRef: OverlayRef<object, unknown> | null;
+    element: ElementRef<HTMLElement>;
+    openOverlays: OverlayRef<object, unknown>[];
 };
-type OverlayRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRef<TComponent, TResult>>;
-declare const OVERLAY_REF: InjectionToken<{
-    readonly id: string;
-    config: OverlayConfig;
-    readonly componentInstance: object | null;
-    close(result?: unknown): void;
-    afterOpened(): Observable<void>;
-    beforeClosed(): Observable<unknown>;
-    afterClosed(): Observable<unknown>;
-    attachRuntime(runtimeRef: OverlayRuntimeRef<object, unknown>): void;
-}>;
+/** Returns the given ref or resolves the overlay the element is rendered inside of. Throws if neither exists. */
+declare const resolveClosestOverlay: (options: ResolveClosestOverlayOptions) => OverlayRef<object, unknown>;
 
-declare class OverlayTemplateHostComponent {
-    private animatedLifecycleInstance;
-    protected template: _angular_core.InputSignal<TemplateRef<OverlaySurfaceContext>>;
-    protected context: _angular_core.InputSignal<OverlaySurfaceContext>;
-    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTemplateHostComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayTemplateHostComponent, "et-overlay-template-host", never, { "template": { "alias": "template"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }]>;
+declare const OVERLAY_BODY_TOKEN: InjectionToken<OverlayBodyComponent>;
+type OverlayBodyDividerType = 'static' | 'dynamic' | false;
+declare class OverlayBodyComponent implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private scrollObserver;
+    private overlayManager;
+    dividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    dividersEnabled: _angular_core.Signal<boolean>;
+    dynamicDividersEnabled: _angular_core.Signal<boolean>;
+    containerScrollState: _angular_core.Signal<_ethlete_core.ElementScrollState>;
+    canScroll: _angular_core.Signal<boolean>;
+    isAtStart: _angular_core.Signal<boolean>;
+    isAtEnd: _angular_core.Signal<boolean>;
+    enableDividerAnimations: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    scrollToTop(behavior?: ScrollBehavior): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayBodyComponent, "[et-overlay-body], et-overlay-body", never, { "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.ScrollObserverDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class OverlayTriggerDirective {
-    private overlay;
-    private destroyRef;
-    elementRef: ElementRef<HTMLElement>;
+declare class OverlayCloseDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    closeResult: _angular_core.InputSignal<unknown>;
+    closeResultAlt: _angular_core.InputSignal<unknown>;
     constructor();
-    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>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayCloseDirective, "[et-overlay-close], [etOverlayClose]", ["etOverlayClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "closeResult": { "alias": "etOverlayClose"; "required": false; "isSignal": true; }; "closeResultAlt": { "alias": "et-overlay-close"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class OverlayDirective {
+/**
+ * Merges overlay configs from least to most specific (e.g. definition → opener → per-open).
+ *
+ * - `bindings` and `providers` are concatenated in layer order — a later binding or provider
+ *   for the same input/token wins, matching Angular semantics.
+ * - `hostClass`, `backdropClass` and `panelClass` are normalized to arrays, concatenated and deduped.
+ * - Every other key is taken from the last layer that sets it to a value other than `undefined`
+ *   (an explicit `null`, e.g. on the aria fields, does override earlier layers).
+ */
+declare const mergeOverlayConfigs: (...configs: (OverlayConfig | undefined)[]) => OverlayConfig;
+
+declare class OverlayContainerComponent {
+    private ownColorProvider;
+    private ownSurfaceProvider;
+    private parentColorProvider;
+    private parentSurfaceProvider;
     private destroyRef;
-    mode: _angular_core.InputSignal<OverlayMode>;
-    role: _angular_core.InputSignal<OverlayRole | undefined>;
-    open: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    disableClose: _angular_core.InputSignal<boolean>;
-    autoFocus: _angular_core.InputSignal<string | false | undefined>;
-    restoreFocus: _angular_core.InputSignal<boolean>;
-    hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
-    closeOnEscape: _angular_core.InputSignal<boolean>;
-    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
-    hostClass: _angular_core.InputSignal<string | string[] | undefined>;
-    backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
-    panelClass: _angular_core.InputSignal<string | string[] | undefined>;
-    placement: _angular_core.InputSignal<Placement>;
-    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
-    offset: _angular_core.InputSignal<OffsetOptions | null>;
-    viewportPadding: _angular_core.InputSignal<Padding | null>;
-    autoResize: _angular_core.InputSignal<boolean>;
-    shift: _angular_core.InputSignal<boolean>;
-    autoHide: _angular_core.InputSignal<boolean>;
-    autoCloseIfReferenceHidden: _angular_core.InputSignal<boolean>;
-    mirrorWidth: _angular_core.InputSignal<boolean>;
-    private overlayManager;
-    /** @internal */
-    registeredAnchor: _angular_core.WritableSignal<OverlayAnchorDirective | null>;
-    /** @internal */
-    registeredSurface: _angular_core.WritableSignal<OverlaySurfaceDirective | null>;
-    /** @internal */
-    registeredTrigger: _angular_core.WritableSignal<OverlayTriggerDirective | null>;
-    /** @internal */
-    overlayRef: _angular_core.WritableSignal<OverlayRef<OverlayTemplateHostComponent, unknown> | null>;
-    isMounted: _angular_core.Signal<boolean>;
-    private originElement;
+    private elementRef;
+    protected overlayRef: {
+        readonly id: string;
+        readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+        config: _ethlete_components.OverlayConfig;
+        headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+        setHeaderTemplate: (template: _angular_core.TemplateRef<unknown> | null) => void;
+        componentInstance: () => object | null;
+        close: (result?: unknown) => void;
+        closeVia: (source: _ethlete_core.OverlayRuntimeCloseSource, result?: unknown) => void;
+        updatePositionStrategy: (strategy: _ethlete_core.OverlayRuntimePositionStrategy) => void;
+        attachComponentInstanceOverride: (getter: () => object | null) => void;
+        afterOpened: () => rxjs.Observable<void>;
+        beforeClosed: () => rxjs.Observable<unknown>;
+        afterClosed: () => rxjs.Observable<unknown>;
+        attachRuntime: (runtimeRef: _ethlete_core.OverlayRuntimeRef<object, unknown>) => void;
+    };
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private renderer;
+    rootBoundary: {
+        value: _angular_core.Signal<HTMLElement>;
+        override: _angular_core.WritableSignal<HTMLElement | null>;
+    };
+    component: _angular_core.InputSignal<Type<object>>;
+    componentBindings: _angular_core.InputSignal<Binding[] | undefined>;
+    renderArrow: _angular_core.InputSignal<boolean>;
+    private contentOutlet;
+    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
+    contentComponentRef: _angular_core.WritableSignal<ComponentRef<object> | null>;
     constructor();
-    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>;
-}
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayContainerComponent, "et-overlay-container", never, { "component": { "alias": "component"; "required": true; "isSignal": true; }; "componentBindings": { "alias": "componentBindings"; "required": false; "isSignal": true; }; "renderArrow": { "alias": "renderArrow"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/** The name of the model the overlay component must expose to participate in query-param sync. */
+declare const OVERLAY_QUERY_PARAM_INPUT_NAME = "overlayQueryParam";
+/** The shape a component must have to be usable with {@link defineQueryParamOverlay}. */
+type QueryParamOverlayHost = {
+    overlayQueryParam: ModelSignal<any>;
+};
+/** Extracts the query param value type from the component's `overlayQueryParam` model. */
+type QueryParamOverlayValue<TComponent> = TComponent extends {
+    overlayQueryParam: ModelSignal<infer TValue>;
+} ? Extract<TValue, string> : string;
+type OverlayDefinitionConfig<TComponent extends object> = OverlayConfig & {
+    /** The overlay component. */
+    component: Type<TComponent>;
+};
+type QueryParamOverlayDefinitionConfig<TComponent extends object> = OverlayDefinitionConfig<TComponent> & {
+    /** The query param key that drives the overlay's open/close lifecycle. */
+    queryParamKey: string;
+};
+type OverlayDefinition<TComponent extends object = object, TResult = unknown> = {
+    kind: 'overlay';
+    /** The overlay component. */
+    component: Type<TComponent>;
+    /** The base overlay config. Opener- and per-open configs are merged on top of it additively. */
+    config: OverlayConfig;
+    /**
+     * Returns the typed overlay ref. Must be called in the injection context of a component
+     * opened via this definition.
+     * @throws RuntimeError if called outside of an open overlay.
+     */
+    injectRef: () => OverlayRef<TComponent, TResult>;
+};
+type QueryParamOverlayDefinition<TComponent extends object = object, TResult = unknown> = Omit<OverlayDefinition<TComponent, TResult>, 'kind'> & {
+    kind: 'queryParamOverlay';
+    /** The query param key that drives the overlay's open/close lifecycle. */
+    queryParamKey: string;
+};
+/**
+ * Defines an overlay at module scope: the component plus its base config (strategies, classes,
+ * bindings, providers, …), without any dependency injection. Consumers turn the definition into
+ * something that can open the overlay via `createOverlayOpener`, and the overlay component
+ * itself accesses its typed ref via `definition.injectRef()`.
+ *
+ * @example
+ * export const productOverlay = defineOverlay<ProductOverlayComponent, ProductResult>({
+ *   component: ProductOverlayComponent,
+ *   strategies: dialogOverlayStrategy({ maxWidth: '480px' }),
+ * });
+ */
+declare const defineOverlay: <TComponent extends object, TResult = unknown>(config: OverlayDefinitionConfig<TComponent>) => OverlayDefinition<TComponent, TResult>;
+/**
+ * Defines an overlay whose lifecycle is driven by a URL query param: it opens while the param is
+ * present and closes (clearing the param) when dismissed. The component must expose an
+ * `overlayQueryParam` {@link https://angular.dev/api/core/model | model} — it receives the param
+ * value and is kept in two-way sync with the URL.
+ *
+ * Because opens are triggered by URL state, there is no per-open config; `bindings` and
+ * `providers` set on the definition (or on the opener) are applied on every open.
+ *
+ * @example
+ * export const productOverlay = defineQueryParamOverlay({
+ *   component: ProductOverlayComponent, // exposes `overlayQueryParam = model<string>()`
+ *   queryParamKey: 'product',
+ *   strategies: dialogOverlayStrategy({ maxWidth: '480px' }),
+ * });
+ */
+declare const defineQueryParamOverlay: <TComponent extends QueryParamOverlayHost, TResult = unknown>(config: QueryParamOverlayDefinitionConfig<TComponent>) => QueryParamOverlayDefinition<TComponent, TResult>;
 
-type OverlaySurfaceContext = {
-    $implicit: OverlayDirective;
-    overlay: OverlayDirective;
-    close: (result?: unknown) => void;
+declare const OVERLAY_ERROR_CODES: {
+    readonly MISSING_OVERLAY_SURFACE: 1200;
+    readonly TRIGGER_OUTSIDE_OVERLAY: 1201;
+    readonly ANCHOR_OUTSIDE_OVERLAY: 1202;
+    readonly SURFACE_OUTSIDE_OVERLAY: 1203;
+    readonly MULTIPLE_LAYOUT_CLASSES: 1204;
+    readonly NO_CLOSEST_OVERLAY: 1205;
+    readonly NESTED_OVERLAY_MAIN: 1206;
+    readonly REF_OUTSIDE_OVERLAY: 1207;
 };
-declare class OverlaySurfaceDirective {
-    private overlay;
-    templateRef: TemplateRef<OverlaySurfaceContext>;
-    private destroyRef;
+
+declare const OVERLAY_FOOTER_TOKEN: InjectionToken<OverlayFooterDirective>;
+declare class OverlayFooterDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayFooterDirective, "[etOverlayFooter], et-overlay-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_HEADER_TOKEN: InjectionToken<OverlayHeaderDirective>;
+declare class OverlayHeaderDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayHeaderDirective, "[etOverlayHeader], et-overlay-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_HEADER_TEMPLATE_TOKEN: InjectionToken<OverlayHeaderTemplateDirective>;
+declare class OverlayHeaderTemplateDirective implements OnInit, OnDestroy {
+    private overlayRef;
+    private elementRef;
+    template: TemplateRef<unknown>;
+    private overlayManager;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySurfaceDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySurfaceDirective, "ng-template[etOverlaySurface]", ["etOverlaySurface"], {}, {}, never, never, true, never>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayHeaderTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayHeaderTemplateDirective, "ng-template[etOverlayHeaderTemplate]", never, {}, {}, never, never, true, never>;
 }
 
-declare const OVERLAY_ERROR_CODES: {
-    readonly MISSING_OVERLAY_SURFACE: 1200;
-    readonly TRIGGER_OUTSIDE_OVERLAY: 1201;
-    readonly ANCHOR_OUTSIDE_OVERLAY: 1202;
-    readonly SURFACE_OUTSIDE_OVERLAY: 1203;
-};
+declare const OVERLAY_MAIN_TOKEN: InjectionToken<OverlayMainDirective>;
+declare class OverlayMainDirective implements OnInit {
+    private parent;
+    private elementRef;
+    private overlayRef;
+    private overlayManager;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayMainDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayMainDirective, "[etOverlayMain], et-overlay-main", never, { "enabled": { "alias": "etOverlayMain"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
 type OverlayManager = {
     open: <TComponent extends object, TResult = unknown>(component: Type<TComponent>, config?: OverlayConfig) => OverlayRef<TComponent, TResult>;
@@ -1728,7 +3272,682 @@ declare const injectOverlayManager: {
     (options: _angular_core.InjectOptions): OverlayManager | null;
 };
 
+/** Per-open config overrides. The component and `strategies` are fixed by the definition. */
+type OverlayOpenConfig = Omit<OverlayConfig, 'strategies'>;
+type OverlayLifecycleConfig<TResult = unknown> = {
+    /** A callback function to be executed once the overlay has been closed */
+    afterClosed?: (result: TResult | null) => void;
+    /** A callback function to be executed before the overlay is closed */
+    beforeClosed?: (result: TResult | null) => void;
+    /** A callback function to be executed once the overlay has been opened */
+    afterOpened?: () => void;
+};
+/**
+ * Lifecycle callbacks plus overlay config overrides applied on every open. The config is merged
+ * additively on top of the definition's config (`bindings`, `providers` and class lists are
+ * concatenated; scalars override).
+ *
+ * Note for query-param overlays: an `origin` set here anchors every URL-driven open, including
+ * deep links where the originating element may not exist — omitting it is usually right (the
+ * overlay then falls back to the currently focused element).
+ */
+type OverlayOpenerConfig<TResult = unknown> = OverlayLifecycleConfig<TResult> & OverlayOpenConfig;
+type OverlayOpener<TComponent extends object = object, TResult = unknown> = {
+    /** Open the overlay. Per-open config is merged additively on top of the definition and opener configs. */
+    open: (config?: OverlayOpenConfig) => OverlayRef<TComponent, TResult>;
+};
+type QueryParamOverlayOpener<TQueryParam extends string = string> = {
+    /** Open the overlay by writing the given value to the query param. */
+    open: (value: TQueryParam) => void;
+    /** Close the overlay by removing the query param. */
+    close: () => void;
+};
+type CreateOverlayOpenerFn = {
+    <TComponent extends object, TResult>(definition: QueryParamOverlayDefinition<TComponent, TResult>, config?: OverlayOpenerConfig<TResult>): QueryParamOverlayOpener<QueryParamOverlayValue<TComponent>>;
+    <TComponent extends object, TResult>(definition: OverlayDefinition<TComponent, TResult>, config?: OverlayOpenerConfig<TResult>): OverlayOpener<TComponent, TResult>;
+};
+/**
+ * Creates an opener for the given overlay definition. Must be called in an injection context.
+ *
+ * - For a `defineOverlay` definition the opener exposes `open(config?)`, returning the typed
+ *   `OverlayRef`.
+ * - For a `defineQueryParamOverlay` definition the opener drives the overlay through the URL:
+ *   `open(value)` writes the query param and `close()` clears it. It also reacts to external
+ *   URL changes (deep links, browser navigation) for as long as the injection context lives.
+ *
+ * @example
+ * readonly product = createOverlayOpener(productOverlay, {
+ *   afterClosed: (result) => console.log(result),
+ * });
+ */
+declare const createOverlayOpener: CreateOverlayOpenerFn;
+
+/**
+ * Blocks body scrolling while a modal overlay is open.
+ * Register once via `provideOverlay()` (or call `injectOverlayScrollBlocker()` in an environment initializer).
+ */
+declare const provideOverlayScrollBlocker: () => _angular_core.Provider[];
+declare const injectOverlayScrollBlocker: {
+    (): void;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): void;
+    (options: _angular_core.InjectOptions): void | null;
+};
+
+declare class OverlayTitleDirective implements OnInit {
+    private overlayRef;
+    private elementRef;
+    private overlayManager;
+    private renderer;
+    id: _angular_core.InputSignal<string>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTitleDirective, "[et-overlay-title], [etOverlayTitle]", ["etOverlayTitle"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare const OVERLAY_IMPORTS: readonly [typeof OverlayDirective, typeof OverlayTriggerDirective, typeof OverlayAnchorDirective, typeof OverlaySurfaceDirective];
+declare const OVERLAY_CONTENT_IMPORTS: readonly [typeof OverlayCloseDirective, typeof OverlayTitleDirective, typeof OverlayHeaderDirective, typeof OverlayBodyComponent, typeof OverlayFooterDirective, typeof OverlayMainDirective];
+declare const provideOverlay: () => _angular_core.EnvironmentProviders[];
+
+/**
+ * Opens a query-param overlay declaratively by navigating its query param — the counterpart to
+ * `createOverlayOpener` for links. Takes the overlay definition itself, so the query param key
+ * is never duplicated as a string.
+ *
+ * @example
+ * <a [etQueryParamOverlayLink]="productOverlay" etQueryParamOverlayLinkValue="42">Open product 42</a>
+ */
+declare class QueryParamOverlayLinkDirective {
+    private routerLink;
+    /** The query-param overlay definition this link opens. */
+    definition: _angular_core.InputSignal<Pick<QueryParamOverlayDefinition, "queryParamKey">>;
+    /** The query param value the overlay opens with. */
+    value: _angular_core.InputSignal<string | number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryParamOverlayLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryParamOverlayLinkDirective, "[etQueryParamOverlayLink]", never, { "definition": { "alias": "etQueryParamOverlayLink"; "required": true; "isSignal": true; }; "value": { "alias": "etQueryParamOverlayLinkValue"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RouterLink; inputs: {}; outputs: {}; }]>;
+}
+
+declare const OVERLAY_BACK_OR_CLOSE_TOKEN: InjectionToken<OverlayBackOrCloseDirective>;
+declare class OverlayBackOrCloseDirective {
+    private overlayRef;
+    private elementRef;
+    private router;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayBackOrCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayBackOrCloseDirective, "[etOverlayBackOrClose]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OverlayRouteHeaderTemplateOutletComponent {
+    protected overlay: {
+        readonly id: string;
+        readonly elements: _ethlete_core.OverlayRuntimeElements | null;
+        config: _ethlete_components.OverlayConfig;
+        headerTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+        setHeaderTemplate: (template: _angular_core.TemplateRef<unknown> | null) => void;
+        componentInstance: () => object | null;
+        close: (result?: unknown) => void;
+        closeVia: (source: _ethlete_core.OverlayRuntimeCloseSource, result?: unknown) => void;
+        updatePositionStrategy: (strategy: _ethlete_core.OverlayRuntimePositionStrategy) => void;
+        attachComponentInstanceOverride: (getter: () => object | null) => void;
+        afterOpened: () => rxjs.Observable<void>;
+        beforeClosed: () => rxjs.Observable<unknown>;
+        afterClosed: () => rxjs.Observable<unknown>;
+        attachRuntime: (runtimeRef: _ethlete_core.OverlayRuntimeRef<object, unknown>) => void;
+    };
+    protected router: _ethlete_components.OverlayRouter;
+    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouteHeaderTemplateOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayRouteHeaderTemplateOutletComponent, "et-overlay-route-header-template-outlet", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_CONFIG_TOKEN: InjectionToken<OverlayRouterConfig>;
+type OverlayRoute = {
+    /** The component to render. */
+    component: Type<unknown>;
+    /**
+     * The route of the page.
+     *
+     * @example
+     * "/" // The root route
+     * "/two" // The route "two"
+     */
+    path: `/${string}`;
+    /** The inputs to pass to the component. Signal values are unwrapped. */
+    inputs?: Record<string, unknown>;
+    /**
+     * Overrides the animation direction used when navigating to or away from this route.
+     * Useful for routes that conceptually sit "before" the others, like a sidebar page that
+     * should slide in from the left. An explicit direction passed to `navigate()` always wins.
+     */
+    navigationDirection?: {
+        /** Direction to play when this route becomes active. */
+        to?: OverlayRouterNavigationDirection;
+        /** Direction to play when navigating away from this route. */
+        from?: OverlayRouterNavigationDirection;
+    };
+};
+type OverlayRouterConfig = {
+    /** The routes to be able to navigate to. */
+    routes: OverlayRoute[];
+    /**
+     * The route on which to start.
+     * @default routes[0].path // The first route, or "/" if none is defined
+     */
+    initialRoute?: string;
+    /**
+     * Mirror the active overlay route into the browser URL as a query param, enabling deep-linking and
+     * browser back/forward integration. Requires the Angular `Router` to be available.
+     *
+     * @default false
+     */
+    syncUrl?: boolean;
+};
+type OverlayRouterNavigationDirection = 'forward' | 'backward';
+type OverlayRouterNavigateConfig = {
+    navigationDirection?: OverlayRouterNavigationDirection;
+};
+type OverlayRouterTransitionType = 'slide' | 'fade' | 'overlay' | 'vertical' | 'none';
+type OverlayRouterResolvedPath = {
+    route: string;
+    type: 'back' | 'replace-current' | 'absolute' | 'forward';
+};
+type OverlayRouter = {
+    /** The current route, but delayed by one frame to ensure that the needed animation classes are applied. */
+    currentRoute: Signal<string>;
+    /** Routes registered at runtime in addition to the configured ones. */
+    extraRoutes: WritableSignal<OverlayRoute[]>;
+    /** The transition to play when navigating between routes. */
+    transitionType: WritableSignal<OverlayRouterTransitionType>;
+    /** The direction of the current navigation. */
+    navigationDirection: WritableSignal<OverlayRouterNavigationDirection>;
+    /** Whether an in-memory history entry exists to go back to. */
+    canGoBack: Signal<boolean>;
+    /** All navigable routes (configured + extra) with signal inputs unwrapped. */
+    routes: Signal<OverlayRoute[]>;
+    /** The route currently being displayed. */
+    currentPage: Signal<OverlayRoute | null>;
+    navigate: (route: string | (string | number)[], config?: OverlayRouterNavigateConfig) => void;
+    back: () => boolean;
+    resolvePath: (route: string | (string | number)[]) => OverlayRouterResolvedPath;
+    addRoute: (route: OverlayRoute) => void;
+    removeRoute: (path: string) => void;
+    /** @internal Returns `true` when the route actually changed. */
+    updateCurrentRoute: (route: string) => boolean;
+    /** @internal */
+    navigateToInitialRoute: () => void;
+};
+declare const provideOverlayRouterService: () => Provider[];
+declare const injectOverlayRouter: {
+    (): OverlayRouter;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayRouter;
+    (options: _angular_core.InjectOptions): OverlayRouter | null;
+};
+declare const OVERLAY_ROUTER_TOKEN: InjectionToken<OverlayRouter>;
+declare const provideOverlayRouterConfig: (config: OverlayRouterConfig) => Provider[];
+/**
+ * Provides both the overlay router config and the overlay router itself, so a consumer only needs
+ * a single entry in the overlay's `providers` instead of wiring the router separately.
+ *
+ * @example
+ * overlayManager.open(MyOverlay, {
+ *   strategies: dialogOverlayStrategy(),
+ *   providers: [provideOverlayRouter({ routes: [...] })],
+ * });
+ */
+declare const provideOverlayRouter: (config: OverlayRouterConfig) => Provider[];
+
+declare const OVERLAY_ROUTER_LINK_TOKEN: InjectionToken<OverlayRouterLinkDirective>;
+declare class OverlayRouterLinkDirective {
+    private elementRef;
+    private router;
+    path: _angular_core.InputSignal<string | (string | number)[]>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    navigationDirection: _angular_core.InputSignal<OverlayRouterNavigationDirection | null>;
+    isActive: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayRouterLinkDirective, "[etOverlayRouterLink]", never, { "path": { "alias": "etOverlayRouterLink"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "navigationDirection": { "alias": "navigationDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN: InjectionToken<OverlayRouterOutletDisabledTemplateDirective>;
+declare class OverlayRouterOutletDisabledTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterOutletDisabledTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayRouterOutletDisabledTemplateDirective, "ng-template[etOverlayRouterOutletDisabledTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_ROUTER_OUTLET_TOKEN: InjectionToken<OverlayRouterOutletComponent>;
+declare class OverlayRouterOutletComponent {
+    private injector;
+    private overlayRef;
+    private elementRef;
+    private document;
+    protected router: _ethlete_components.OverlayRouter;
+    private renderer;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    sharedRouteTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    outletDisabledTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    pageWrappers: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly hasSidebar: boolean;
+    wasDisabled: _angular_core.WritableSignal<boolean>;
+    keepDisabledTransition: _angular_core.Signal<boolean>;
+    activePageElement: _angular_core.Signal<HTMLElement | null>;
+    protected transitionType: _angular_core.Signal<_ethlete_components.OverlayRouterTransitionType>;
+    constructor();
+    scrollActivePageTo(options?: ScrollToOptions | undefined): void;
+    disabledPageAnimationStateChange(state: AnimatedLifecycleState): void;
+    /**
+     * Moves focus into the freshly navigated page, mirroring the overlay's own open-time focus behaviour
+     * (first-tabbable by default, so buttons/inputs win over headings). Falls back to the page wrapper when
+     * the page has nothing tabbable. Respects the overlay's `autoFocus` config, including `false`.
+     */
+    private focusActivePage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayRouterOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayRouterOutletComponent, "et-overlay-router-outlet", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["sharedRouteTemplate", "outletDisabledTemplate"], ["*"], true, never>;
+}
+
+declare class OverlaySharedRouteTemplateOutletComponent {
+    protected routerOutlet: _ethlete_components.OverlayRouterOutletComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySharedRouteTemplateOutletComponent, "et-overlay-shared-route-template-outlet", never, {}, {}, never, never, true, never>;
+}
+
+declare const OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN: InjectionToken<OverlaySharedRouteTemplateDirective>;
+declare class OverlaySharedRouteTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlaySharedRouteTemplateDirective, "ng-template[etOverlaySharedRouteTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class OverlaySidebarPageComponent {
+    headerTemplate: _angular_core.InputSignal<OverlayHeaderTemplateDirective | null>;
+    bodyTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    pageDividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySidebarPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySidebarPageComponent, "et-overlay-sidebar-page", never, { "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": true; "isSignal": true; }; "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof OverlayMainDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class OverlaySidebarComponent {
+    protected sidebar: _ethlete_components.SidebarOverlay;
+    pageDividers: _angular_core.InputSignal<OverlayBodyDividerType>;
+    sidebarContent: _angular_core.Signal<TemplateRef<unknown>>;
+    sidebarHeaderContent: _angular_core.Signal<_ethlete_components.OverlayHeaderTemplateDirective | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlaySidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlaySidebarComponent, "et-overlay-sidebar", never, { "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, ["sidebarHeaderContent"], ["*"], true, never>;
+}
+
+declare const SIDEBAR_OVERLAY_CONFIG: InjectionToken<SidebarOverlayConfig>;
+type SidebarOverlayConfig = {
+    /**
+     * On mobile devices, the sidebar is shown as a separate page that can be navigated to.
+     * This is the route to that sidebar page.
+     *
+     * @default "/sidebar"
+     */
+    sidebarPageRoute?: `/${string}`;
+    /**
+     * The width from which the sidebar renders inline (rather than collapsing into a page). Compared
+     * against the overlay's own pane width — not the viewport — so a narrow dialog collapses its
+     * sidebar even on a wide screen. Can be a breakpoint name or a pixel number. Works best with an
+     * overlay that has a defined width.
+     *
+     * @default "md"
+     */
+    renderSidebarFrom?: Breakpoint | number;
+};
+type SidebarOverlay = {
+    /** Whether the sidebar renders inline (`true`) or is collapsed into a navigable page (`false`). */
+    renderSidebar: Signal<boolean>;
+    sidebarContentTemplate: WritableSignal<TemplateRef<unknown> | null>;
+    sidebarHeaderTemplate: WritableSignal<OverlayHeaderTemplateDirective | null>;
+    sidebarPageDividers: WritableSignal<OverlayBodyDividerType>;
+};
+declare const provideSidebarOverlayService: () => Provider[];
+declare const injectSidebarOverlay: {
+    (): SidebarOverlay;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): SidebarOverlay;
+    (options: _angular_core.InjectOptions): SidebarOverlay | null;
+};
+declare const SIDEBAR_OVERLAY_TOKEN: InjectionToken<SidebarOverlay>;
+declare const provideSidebarOverlayConfig: (config: SidebarOverlayConfig) => Provider[];
+/**
+ * Provides both the sidebar config and the sidebar overlay service in one call, mirroring
+ * {@link provideOverlayRouter}. Requires an overlay router to also be provided.
+ */
+declare const provideSidebarOverlay: (config?: SidebarOverlayConfig) => Provider[];
+
+type AnchoredOverlayStrategyOptions = {
+    containerClass?: string | string[];
+    hostClass?: string | string[];
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+    placement?: Placement;
+    fallbackPlacements?: Placement[];
+    offset?: OffsetOptions | null;
+    arrowPadding?: Padding | null;
+    viewportPadding?: Padding | null;
+    shift?: boolean | OverlayRuntimeShiftOptions;
+    autoResize?: boolean;
+    autoHide?: boolean;
+    autoCloseIfReferenceHidden?: boolean;
+    mirrorWidth?: boolean;
+    /** Render a floating-ui-positioned arrow on the container pointing at the origin. */
+    arrow?: boolean;
+};
+type CenteredOverlayStrategyOptions = {
+    containerClass?: string | string[];
+    hostClass?: string | string[];
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+};
+type AnchoredPositionOptions = Pick<AnchoredOverlayStrategyOptions, 'placement' | 'fallbackPlacements' | 'offset' | 'arrowPadding' | 'viewportPadding' | 'shift' | 'autoResize' | 'autoHide' | 'autoCloseIfReferenceHidden' | 'mirrorWidth'>;
+declare const buildAnchoredRuntimePositionStrategy: (options?: AnchoredPositionOptions) => (origin?: HTMLElement) => OverlayRuntimePositionStrategy;
+declare const anchoredOverlayStrategy: (options?: AnchoredOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+declare const centeredOverlayStrategy: (options?: CenteredOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+
+type AnchoredDialogOverlayStrategyOptions = Partial<OverlayBreakpointConfig> & AnchoredPositionOptions;
+declare const provideAnchoredDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectAnchoredDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideAnchoredDialogStrategy: () => _angular_core.Provider[];
+declare const injectAnchoredDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const anchoredDialogOverlayStrategy: (options?: AnchoredDialogOverlayStrategyOptions) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideBottomSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectBottomSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideBottomSheetStrategy: () => _angular_core.Provider[];
+declare const injectBottomSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const bottomSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideDialogStrategy: () => _angular_core.Provider[];
+declare const injectDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const dialogOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideFullscreenDialogStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectFullscreenDialogStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideFullscreenDialogStrategy: () => _angular_core.Provider[];
+declare const injectFullscreenDialogStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => OverlayStrategy;
+    } | null;
+};
+declare const fullScreenDialogOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare class OverlayOriginCloneComponent {
+    animatedLifecycle: AnimatedLifecycleDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayOriginCloneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayOriginCloneComponent, "et-overlay-origin-clone", never, {}, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type ViewportTransformData = {
+    viewportWidth: number;
+    viewportHeight: number;
+    rect: DOMRect;
+    scaleUpX: number;
+    scaleUpY: number;
+    viewportCenterX: number;
+    viewportCenterY: number;
+    buttonCenterX: number;
+    buttonCenterY: number;
+    cloneTranslateX: number;
+    cloneTranslateY: number;
+    containerTranslateX: number;
+    containerTranslateY: number;
+    scaleX: number;
+    scaleY: number;
+};
+type FullscreenAnimationCancellable = {
+    unsubscribe: () => void;
+};
+type FullscreenAnimationState = {
+    readonly originElement: HTMLElement | null;
+    readonly cloneComponentRef: ComponentRef<OverlayOriginCloneComponent> | null;
+    readonly subscriptions: FullscreenAnimationCancellable[];
+    readonly isOriginHidden: boolean;
+};
+type FullscreenAnimationDeps = {
+    readonly injector: EnvironmentInjector;
+    readonly document: Document;
+    readonly appRef: ApplicationRef;
+    readonly renderer: AngularRenderer;
+};
+declare const cleanupFullscreenAnimationStyles: (options: {
+    containerEl: HTMLElement;
+    renderer: AngularRenderer;
+    state: FullscreenAnimationState | null;
+}) => void;
+declare const startFullscreenEnterAnimation: (options: {
+    context: OverlayStrategyContext;
+    deps: FullscreenAnimationDeps;
+    applyTransformOrigin: boolean;
+    skipAnimation: boolean;
+}) => FullscreenAnimationState;
+declare const startFullscreenLeaveAnimation: (options: {
+    context: OverlayStrategyContext;
+    state: FullscreenAnimationState;
+    deps: FullscreenAnimationDeps;
+    applyTransformOrigin: boolean;
+}) => FullscreenAnimationState;
+declare const cleanupFullscreenAnimation: (state: FullscreenAnimationState, deps: FullscreenAnimationDeps) => void;
+declare const abortFullscreenAnimation: (options: {
+    context: OverlayStrategyContext;
+    state: FullscreenAnimationState;
+    deps: FullscreenAnimationDeps;
+}) => void;
+
+declare const provideLeftSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectLeftSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideLeftSheetStrategy: () => _angular_core.Provider[];
+declare const injectLeftSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const leftSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+type DragToDismissContext = {
+    element: HTMLElement;
+    overlayRef: OverlayRef<object, unknown>;
+    config: OverlayDragToDismissConfig;
+    renderer: AngularRenderer;
+};
+type DragToDismissRef = {
+    unsubscribe: () => void;
+};
+/**
+ * Enables drag-to-dismiss functionality on an overlay element.
+ * Returns a cleanup function to disable the feature.
+ */
+declare const enableDragToDismiss: (context: DragToDismissContext) => DragToDismissRef;
+
+declare const isHtmlElement: (element: unknown) => element is HTMLElement;
+declare const isTouchEvent: (event: Event) => event is TouchEvent;
+declare const isPointerEvent: (event: Event) => event is PointerEvent;
+declare const findNextRelevantHtmlElement: (element: HTMLElement | null, depth?: number) => HTMLElement | null;
+declare const getOriginCoordinatesAndDimensions: (origin: HTMLElement | Event | undefined) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    element: HTMLElement;
+} | null;
+
+declare const OVERLAY_CONFIG_CLASS_KEYS: Set<string>;
+declare const mergeOverlayBreakpointConfigs: (...configs: OverlayBreakpointConfig[]) => OverlayBreakpointConfig;
+
+type OverlayStrategyControllerMountConfig = {
+    positionStrategy: OverlayRuntimePositionStrategy;
+    paneClass: string[];
+    hostClass: string[];
+    backdropClass: string[];
+    animationDelegate: OverlayRuntimeAnimationDelegate;
+    renderArrow: boolean;
+    hasBackdrop: boolean | undefined;
+};
+type OverlayStrategyController = {
+    /** Values the overlay manager merges into the runtime mount config before mounting. */
+    initialMountConfig: OverlayStrategyControllerMountConfig;
+    /** Wires strategy lifecycle hooks and breakpoint switching. Must be called right after mounting. */
+    attach: (runtimeRef: OverlayRuntimeRef<object, unknown>, overlayRef: OverlayRef<object, unknown>) => void;
+};
+declare const createOverlayStrategyController: (config: OverlayConfig, parentInjector: EnvironmentInjector) => OverlayStrategyController;
+
+declare const transformingBottomSheetToDialogOverlayStrategy: (customConfig?: {
+    bottomSheet?: OverlayBreakpointConfig;
+    dialog?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+declare const transformingFullScreenDialogToRightSheetOverlayStrategy: (customConfig?: {
+    fullScreenDialog?: OverlayBreakpointConfig;
+    rightSheet?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+declare const transformingFullScreenDialogToDialogOverlayStrategy: (customConfig?: {
+    fullScreenDialog?: OverlayBreakpointConfig;
+    dialog?: OverlayBreakpointConfig;
+    breakpoint?: Breakpoint | number;
+}) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideRightSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectRightSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideRightSheetStrategy: () => _angular_core.Provider[];
+declare const injectRightSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const rightSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
+
+declare const provideTopSheetStrategyDefaults: (valueOverride?: Partial<OverlayBreakpointConfig> | undefined) => _angular_core.Provider[];
+declare const injectTopSheetStrategyDefaults: {
+    (): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayBreakpointConfig;
+    (options: _angular_core.InjectOptions): OverlayBreakpointConfig | null;
+};
+declare const provideTopSheetStrategy: () => _angular_core.Provider[];
+declare const injectTopSheetStrategy: {
+    (): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    };
+    (options: _angular_core.InjectOptions): {
+        build: (config?: Partial<OverlayBreakpointConfig>) => _ethlete_components.OverlayStrategy;
+    } | null;
+};
+declare const topSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
 
 declare class ScrollableActiveChildDirective {
     private scrollable;
@@ -1935,8 +4154,8 @@ declare class ScrollableDragDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableDragDirective, "[etScrollableDrag]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const ScrollableErrorCode: {
-    readonly MISSING_SCROLL_CONTAINER: 1800;
+declare const SCROLLABLE_ERROR_CODES: {
+    readonly MISSING_SCROLL_CONTAINER: 2100;
 };
 
 declare class ScrollableIgnoreChildDirective {
@@ -2075,6 +4294,7 @@ declare class StreamConsentComponent {
     private config;
     private locale;
     private surfaceThemes;
+    protected readonly HEADING_ID: string;
     cardSurface: _angular_core.Signal<string | null>;
     heading: _angular_core.Signal<string>;
     description: _angular_core.Signal<string>;
@@ -2384,8 +4604,8 @@ type PipManager = {
 declare class PipBackDirective {
     private chrome;
     private tokenEntry;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     private pipManager;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     back(event: Event): void;
     private resolveEntry;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipBackDirective, never>;
@@ -2564,8 +4784,8 @@ declare class PipCloseDirective {
     private chrome;
     private pipWindow;
     private tokenEntry;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     private pipManager;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     close(event: Event): void;
     private resolveEntry;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipCloseDirective, never>;
@@ -2604,28 +4824,31 @@ declare class PipTitleBarDirective {
 declare const PIP_WINDOW_ASPECT_RATIO_TOKEN: InjectionToken<Signal<number>>;
 
 declare class StreamPipChromeComponent implements PipChromeRef {
+    pipManager: _ethlete_components.PipManager;
+    private provideSurface;
+    private surfaceThemes;
     stageRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     pipWindowRef: _angular_core.Signal<PipWindowComponent | undefined>;
     gridBtnRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
-    pipManager: _ethlete_components.PipManager;
     state: _ethlete_components.PipChromeState;
     animations: _ethlete_components.PipChromeAnimations;
     readonly CLOSE_KIND: "close";
     controlsColor: _angular_core.Signal<string | undefined>;
     readonly WINDOW_CONTROL_BUTTON_SIZE: "sm";
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPipChromeComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamPipChromeComponent, "et-stream-pip-chrome", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamPipChromeComponent, "et-stream-pip-chrome", never, {}, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class PipPlayerComponent {
     private document;
     private el;
     protected pipCell: PipCellDirective | null;
-    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
-    showThumbnail: _angular_core.InputSignal<boolean | undefined>;
     private streamManager;
     private pipManager;
     private renderer;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
+    showThumbnail: _angular_core.InputSignal<boolean | undefined>;
     isReady: _angular_core.WritableSignal<boolean>;
     resolvedEntry: _angular_core.Signal<StreamPipEntry>;
     thumbnailUrl: _angular_core.Signal<string | null>;
@@ -2663,11 +4886,11 @@ declare const injectPipSlotPlaceholderConfig: {
 declare class PipSlotPlaceholderComponent {
     private slotPlayerId;
     private parentSurfaceProvider;
-    private bringBackDir;
     private pipManager;
     private config;
     private locale;
     private surfaceThemes;
+    private bringBackDir;
     cardSurface: _angular_core.Signal<string | null>;
     isInPip: _angular_core.Signal<boolean>;
     message: _angular_core.Signal<string>;
@@ -2710,10 +4933,10 @@ declare class StreamPlayerSlotDirective {
     private playerComponent;
     private provideSurface;
     private parentSurfaceProvider;
-    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
     private surfaceThemes;
     private styleManager;
+    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
     private resolvedSurface;
     slot: _ethlete_components.StreamPlayerSlotHandle;
     constructor();
@@ -3476,7 +5699,7 @@ declare const StreamImports: readonly [typeof StreamConsentComponent, typeof Str
 declare class TabBarTriggerDirective {
     private elementRef;
     private scrollable;
-    protected tabBar: _ethlete_components.TabBarDirective;
+    protected tabBar: _ethlete_components.TabBarDirective | null;
     disabled: _angular_core.InputSignal<boolean>;
     readonly ID: string;
     justActivated: _angular_core.WritableSignal<boolean>;
@@ -3559,6 +5782,7 @@ declare const TAB_BAR_TRIGGER_TOKEN: InjectionToken<TabBarTriggerDirective>;
 
 declare class NavTabLinkDirective {
     private routerLinkActive;
+    private navTabs;
     private tabBar;
     private destroyRef;
     trigger: TabBarTriggerDirective;
@@ -3570,17 +5794,24 @@ declare class NavTabLinkDirective {
 }
 
 declare class NavTabsOutletDirective {
-    private tabBar;
+    private nearestTabBar;
+    private registry;
     readonly ID: string;
+    private tabBar;
     activeTriggerId: _angular_core.Signal<string | null>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsOutletDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavTabsOutletDirective, "[etNavTabsOutlet]", never, {}, {}, never, never, true, never>;
 }
 
 declare class NavTabsDirective {
     private routerEvent;
+    private registry;
+    private tabBar;
+    private destroyRef;
     /** @internal */
     navigationVersion: _angular_core.Signal<number>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavTabsDirective, "[etNavTabs]", never, {}, {}, never, never, true, never>;
 }
@@ -3615,10 +5846,10 @@ declare class NavTabsComponent {
 }
 
 declare const TAB_ERROR_CODES: {
-    readonly MISSING_TAB_BAR: 1800;
-    readonly MISSING_TAB_GROUP: 1801;
-    readonly MISSING_TAB_PANEL: 1802;
-    readonly MISSING_NAV_TABS: 1803;
+    readonly MISSING_TAB_BAR: 2000;
+    readonly MISSING_TAB_GROUP: 2001;
+    readonly MISSING_TAB_PANEL: 2002;
+    readonly MISSING_NAV_TABS: 2003;
 };
 
 declare class TabPanelDirective {
@@ -3643,6 +5874,8 @@ declare class TabGroupDirective {
     private sessionMemoryAvailable;
     /** @internal */
     panels: _angular_core.WritableSignal<TabPanelDirective[]>;
+    /** @internal Set by composing components (e.g. et-tab-group) that render panel content themselves instead of registering [etTabPanel] directives. */
+    managesPanelsInternally: _angular_core.WritableSignal<boolean>;
     restoredSessionMemoryKey: _angular_core.WritableSignal<string>;
     constructor();
     /** @internal */
@@ -3674,6 +5907,7 @@ declare class TabLabelDirective {
 }
 
 declare class TabComponent {
+    private tabGroup;
     label: _angular_core.InputSignal<string>;
     icon: _angular_core.InputSignal<string | null>;
     disabled: _angular_core.InputSignal<boolean>;
@@ -3682,6 +5916,7 @@ declare class TabComponent {
     implicitLabelRef: _angular_core.Signal<TemplateRef<unknown>>;
     /** @internal */
     contentRef: _angular_core.Signal<TemplateRef<unknown>>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "et-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["customLabel"], ["*"], true, never>;
 }
@@ -3693,6 +5928,7 @@ declare class TabGroupComponent {
     protected triggerElements: _angular_core.Signal<TabBarTriggerDirective[]>;
     /** @internal */
     tabGroupId: string;
+    constructor();
     protected isPanelHidden(index: number): boolean;
     protected shouldRenderPanel(index: number): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupComponent, never>;
@@ -3708,6 +5944,7 @@ declare class ToggletipDirective {
     private elementRef;
     private colorProvider;
     private surfaceProvider;
+    private overlayManager;
     content: _angular_core.InputSignal<ToggletipContent | null>;
     ariaLabel: _angular_core.InputSignal<string | null>;
     ariaLabelledBy: _angular_core.InputSignal<string | null>;
@@ -3718,7 +5955,6 @@ declare class ToggletipDirective {
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     disabled: _angular_core.InputSignal<boolean>;
     open: _angular_core.ModelSignal<boolean>;
-    private overlayManager;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<ToggletipComponent, unknown> | null>;
     private toggletipId;
@@ -3741,24 +5977,18 @@ declare class ToggletipDirective {
 
 declare class ToggletipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
     protected injector: Injector;
     toggletipId: _angular_core.InputSignal<string>;
     protected contentId: _angular_core.InputSignal<string>;
     content: _angular_core.InputSignal<ToggletipContent>;
     colorProvider: _angular_core.InputSignal<ProvideColorDirective | null>;
-    surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
-    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective | undefined>;
-    private surfaceThemes;
     hasTemplate: _angular_core.Signal<boolean>;
     contentText: _angular_core.Signal<string | null>;
     contentTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
-    resolvedSurface: _angular_core.Signal<string | null>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggletipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggletipComponent, "et-toggletip", never, { "toggletipId": { "alias": "toggletipId"; "required": true; "isSignal": true; }; "contentId": { "alias": "contentId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; "surfaceProvider": { "alias": "surfaceProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggletipComponent, "et-toggletip", never, { "toggletipId": { "alias": "toggletipId"; "required": true; "isSignal": true; }; "contentId": { "alias": "contentId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: { "surfaceProvider": "surfaceProvider"; }; outputs: {}; }]>;
 }
 
 declare class ToggletipCloseDirective {
@@ -3789,22 +6019,16 @@ declare const TOGGLETIP_IMPORTS: readonly [typeof ToggletipDirective, typeof Tog
 
 declare class TooltipComponent {
     private ownColorProvider;
-    private ownSurfaceProvider;
     private triggerColorProvider;
-    private triggerSurfaceProvider;
     tooltipId: _angular_core.InputSignal<string>;
     content: _angular_core.InputSignal<TooltipContent>;
     colorProvider: _angular_core.InputSignal<ProvideColorDirective | null>;
-    surfaceProvider: _angular_core.InputSignal<ProvideSurfaceDirective | null>;
-    animatedLifecycle: _angular_core.Signal<AnimatedLifecycleDirective | undefined>;
-    private surfaceThemes;
     hasTemplate: _angular_core.Signal<boolean>;
     contentText: _angular_core.Signal<string | null>;
     contentTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
-    resolvedSurface: _angular_core.Signal<string | null>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "et-tooltip", never, { "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; "surfaceProvider": { "alias": "surfaceProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "et-tooltip", never, { "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "colorProvider": { "alias": "colorProvider"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: { "surfaceProvider": "surfaceProvider"; }; outputs: {}; }]>;
 }
 
 type TooltipContent = string | TemplateRef<unknown>;
@@ -3814,6 +6038,9 @@ declare class TooltipDirective {
     private elementRef;
     private colorProvider;
     private surfaceProvider;
+    private overlayManager;
+    private focusVisibleTracker;
+    private renderer;
     content: _angular_core.InputSignal<TooltipContent | null>;
     ariaDescription: _angular_core.InputSignal<string | null>;
     placement: _angular_core.InputSignal<Placement>;
@@ -3823,9 +6050,6 @@ declare class TooltipDirective {
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     showDelay: _angular_core.InputSignal<number>;
     disabled: _angular_core.InputSignal<boolean>;
-    private overlayManager;
-    private focusVisibleTracker;
-    private renderer;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<TooltipComponent, unknown> | null>;
     private hasHover;
@@ -3851,5 +6075,5 @@ declare const TOOLTIP_ERROR_CODES: {
 
 declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
 
-export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BOLD_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, FACEBOOK_PLAYER_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_TOKEN, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridImports, GridItemComponent, GridItemDirective, GridItemRef, GridResizeDirective, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, INPUT_IMPORTS, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, ITALIC_ICON, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LINK_ICON, LIST_BULLETED_ICON, LIST_NUMBERED_ICON, LOCK_ICON, LabelDirective, NAV_TABS_TOKEN, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NavTabImports, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, OVERLAY_ERROR_CODES, OVERLAY_IMPORTS, OVERLAY_REF, OverlayAnchorDirective, OverlayDirective, OverlaySurfaceDirective, OverlayTriggerDirective, PENCIL_ICON, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLUS_ICON, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, RICH_TEXT_EDITOR_IMPORTS, RadioComponent, RadioGroupComponent, RichTextEditorComponent, RichTextEditorDirective, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SOOP_PLAYER_TOKEN, STREAM_CONSENT_TOKEN, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableErrorCode, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamImports, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_PANEL_TOKEN, TAB_SIZES, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabImports, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TextButtonComponent, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, createGridAdapter, createNotificationRef, createOverlayRef, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, fromGridPosition, injectFormSupport, injectGridConfig, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, provideFormSupport, provideGridConfig, provideIcons, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlayManager, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, toGridPosition };
-export type { ButtonIconAlignment, ButtonSize, FacebookVideoPlayer, FacebookWindow, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OverlayAutoFocusTarget, OverlayConfig, OverlayManager, OverlayMode, OverlayPositionStrategy, OverlayRef, OverlayRole, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, ToggletipContent, TooltipContent, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };
+export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BOLD_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_BREAKPOINTS, DEFAULT_ICON_VARIANT, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DROPZONE_ENTRY_STATUSES, DROPZONE_ERROR_CODES, DROPZONE_FILES_ERROR_KIND, DROPZONE_FILE_CONSTRAINTS, DROPZONE_FILE_REJECTION_REASONS, DROPZONE_IMPORTS, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, DropzoneComponent, DropzoneDirective, FACEBOOK_PLAYER_TOKEN, FILE_ICON, 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, 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, QueryParamOverlayLinkDirective, RICH_TEXT_EDITOR_IMPORTS, ROTATE_RIGHT_ICON, RadioComponent, RadioGroupComponent, RichTextEditorComponent, RichTextEditorDirective, RichTextEditorFloatingToolbarComponent, SCROLLABLE_ERROR_CODES, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SIDEBAR_OVERLAY_CONFIG, SIDEBAR_OVERLAY_TOKEN, SNAP_HYSTERESIS, SOOP_PLAYER_TOKEN, SPLIT_BUTTON_ERROR_CODES, 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, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, SplitButtonActionDirective, SplitButtonComponent, SplitButtonDirective, SplitButtonTriggerDirective, 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, UPLOAD_ICON, 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, createDefaultDropzoneArgs, createDropzoneUpload, createExistingDropzoneEntry, createFileDropzoneEntry, createGridAdapter, createNotificationRef, createOverlayOpener, createOverlayRef, createOverlayStrategyController, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, defaultDropzoneRejectionMessage, defineOverlay, defineQueryParamOverlay, deserializeGridLayout, dialogOverlayStrategy, disposeDropzoneEntry, dropzoneFiles, enableDragToDismiss, findCollision, findNextRelevantHtmlElement, findScrollableAncestor, formatFileSize, 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, isFileAccepted, isHtmlElement, isPointerEvent, isTouchEvent, itemsCollide, leftSheetOverlayStrategy, mapLayoutToBreakpoint, mergeOverlayBreakpointConfigs, mergeOverlayConfigs, 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, AnyDropzoneUploadConfig, AutoPlaceOptions, AutoScrollPointer, AutoScroller, ButtonIconAlignment, ButtonSize, CenteredOverlayStrategyOptions, ClampPositionOptions, CompactLayoutOptions, CreateExistingDropzoneEntryOptions, CreateFileDropzoneEntryOptions, DragToDismissContext, DragToDismissRef, DropzoneEntry, DropzoneEntrySource, DropzoneEntryStatus, DropzoneExistingFileInfo, DropzoneFileConstraints, DropzoneFileRejection, DropzoneFileRejectionReason, DropzoneFileValidationChannel, DropzoneUploadConfig, 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, OverlayDefinition, OverlayDefinitionConfig, OverlayDragToDismissConfig, OverlayLifecycleConfig, OverlayManager, OverlayMode, OverlayOpenConfig, OverlayOpener, OverlayOpenerConfig, OverlayRef, OverlayRole, OverlayRoute, OverlayRouter, OverlayRouterConfig, OverlayRouterNavigateConfig, OverlayRouterNavigationDirection, OverlayRouterResolvedPath, OverlayRouterTransitionType, OverlayStrategy, OverlayStrategyBreakpoint, OverlayStrategyContext, OverlayStrategyController, OverlayStrategyControllerMountConfig, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, PixelRect, QueryParamOverlayDefinition, QueryParamOverlayDefinitionConfig, QueryParamOverlayHost, QueryParamOverlayOpener, QueryParamOverlayValue, 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 };