@ethlete/components 0.1.0-beta.4

package/types/ethlete-components.d.ts

@@ -0,0 +1,3702 @@
+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 * as _ethlete_core from '@ethlete/core';
+import { AnimatableDirective, DragHandleDirective, ResizeEdge, ResizeMoveEvent, OverlayRuntimePositionStrategy, OverlayRuntimeRef, AnimatedLifecycleDirective, ScrollObserverDirective, ScrollToElementOptions, ConsentHandler, ProvideColorDirective, ProvideSurfaceDirective } from '@ethlete/core';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { ValidationError, FormCheckboxControl, FormValueControl } from '@angular/forms/signals';
+import * as _ethlete_components from '@ethlete/components';
+import * as _angular_platform_browser from '@angular/platform-browser';
+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 {
+    private styleManager;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonStylesDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonStylesDirective, "[etButtonStyles]", never, {}, {}, never, never, true, never>;
+}
+
+declare const BUTTON_TYPES: {
+    readonly BUTTON: "button";
+    readonly SUBMIT: "submit";
+    readonly RESET: "reset";
+};
+type ButtonType = (typeof BUTTON_TYPES)[keyof typeof BUTTON_TYPES];
+declare class ButtonDirective {
+    private elementRef;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    type: _angular_core.InputSignal<ButtonType>;
+    pressed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    emitAriaPressed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly IS_BUTTON: boolean;
+    readonly IS_ANCHOR: boolean;
+    isInactive: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[etButton]", ["etButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "emitAriaPressed": { "alias": "emitAriaPressed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FocusRingDirective {
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private styleManager;
+    protected active: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FocusRingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FocusRingDirective, "[etFocusRing]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const BUTTON_SIZES: {
+    readonly XS: "xs";
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+    readonly XL: "xl";
+};
+type ButtonSize = (typeof BUTTON_SIZES)[keyof typeof BUTTON_SIZES];
+declare const BUTTON_ICON_ALIGNMENTS: {
+    readonly START: "start";
+    readonly END: "end";
+};
+type ButtonIconAlignment = (typeof BUTTON_ICON_ALIGNMENTS)[keyof typeof BUTTON_ICON_ALIGNMENTS];
+declare const BUTTON_VARIANTS: {
+    readonly FILLED: "filled";
+    readonly OUTLINE: "outline";
+    readonly TONAL: "tonal";
+    readonly TRANSPARENT: "transparent";
+};
+type ButtonVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];
+declare const BUTTON_SPINNER_CONFIG: Record<ButtonSize, {
+    diameter: number;
+    strokeWidth: number;
+}>;
+declare class ButtonComponent {
+    protected buttonDir: ButtonDirective;
+    variant: _angular_core.InputSignal<ButtonVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
+    iconAlignment: _angular_core.InputSignal<ButtonIconAlignment>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    spinnerConfig: _angular_core.Signal<{
+        diameter: number;
+        strokeWidth: number;
+    }>;
+    pressedVariant: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "[et-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+}
+
+type FabVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];
+declare class FabComponent {
+    protected buttonDir: ButtonDirective;
+    variant: _angular_core.InputSignal<FabVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
+    expanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    iconAlignment: _angular_core.InputSignal<ButtonIconAlignment>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    spinnerConfig: _angular_core.Signal<{
+        diameter: number;
+        strokeWidth: number;
+    }>;
+    expandedAttr: _angular_core.Signal<true | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FabComponent, "[et-fab]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+}
+
+type IconButtonVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];
+declare class IconButtonComponent {
+    protected buttonDir: ButtonDirective;
+    variant: _angular_core.InputSignal<IconButtonVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    spinnerConfig: _angular_core.Signal<{
+        diameter: number;
+        strokeWidth: number;
+    }>;
+    pressedVariant: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "[et-icon-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }, { directive: typeof ButtonStylesDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+}
+
+declare class TextButtonComponent {
+    protected buttonDir: ButtonDirective;
+    size: _angular_core.InputSignal<ButtonSize>;
+    iconAlignment: _angular_core.InputSignal<ButtonIconAlignment>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    spinnerConfig: _angular_core.Signal<{
+        diameter: number;
+        strokeWidth: number;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextButtonComponent, "[et-text-button]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[etIcon]"], true, [{ directive: typeof ButtonDirective; inputs: { "disabled": "disabled"; "loading": "loading"; "type": "type"; }; 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 WINDOW_CONTROL_BUTTON_SIZES: {
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+};
+type WindowControlButtonSize = (typeof WINDOW_CONTROL_BUTTON_SIZES)[keyof typeof WINDOW_CONTROL_BUTTON_SIZES];
+declare const WINDOW_CONTROL_BUTTON_KINDS: {
+    readonly DEFAULT: "default";
+    readonly CLOSE: "close";
+};
+type WindowControlButtonKind = (typeof WINDOW_CONTROL_BUTTON_KINDS)[keyof typeof WINDOW_CONTROL_BUTTON_KINDS];
+declare class WindowControlButtonComponent {
+    protected buttonDir: ButtonDirective;
+    size: _angular_core.InputSignal<WindowControlButtonSize>;
+    kind: _angular_core.InputSignal<WindowControlButtonKind>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    protected spinnerConfig: _angular_core.Signal<{
+        readonly diameter: 12;
+        readonly strokeWidth: 2;
+    } | {
+        readonly diameter: 14;
+        readonly strokeWidth: 2;
+    } | {
+        readonly diameter: 16;
+        readonly strokeWidth: 2.5;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowControlButtonComponent, never>;
+    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 FORM_FIELD_ERROR_CODES: {
+    readonly MISSING_CONTROL: 1800;
+};
+
+declare const FORM_FIELD_CONTROL_TYPES: {
+    readonly TEXT_INPUT: "text-input";
+    readonly CHECKBOX: "checkbox";
+    readonly RADIO: "radio";
+    readonly SWITCH: "switch";
+    readonly SEGMENTED_BUTTON: "segmented-button";
+    readonly SELECTION_LIST: "selection-list";
+};
+type FormFieldControlType = (typeof FORM_FIELD_CONTROL_TYPES)[keyof typeof FORM_FIELD_CONTROL_TYPES];
+type FormFieldControl = {
+    touched: Signal<boolean>;
+    invalid: Signal<boolean>;
+    errors: Signal<readonly ValidationError.WithOptionalFieldTree[]>;
+    name: Signal<string>;
+    required?: Signal<boolean>;
+    disabled?: Signal<boolean>;
+    effectiveDisabled?: Signal<boolean>;
+    describedBy: WritableSignal<string | null>;
+    controlType: Signal<FormFieldControlType>;
+    focused?: Signal<boolean>;
+    hasValue?: Signal<boolean>;
+    activate(): void;
+};
+type HintComponentBase = object;
+declare const FORM_FIELD_TOKEN: InjectionToken<FormFieldDirectiveBase>;
+type FormFieldDirectiveBase = {
+    registerControl(control: FormFieldControl): void;
+    unregisterControl(control: FormFieldControl): void;
+    registerHint(hint: HintComponentBase): void;
+    unregisterHint(hint: HintComponentBase): void;
+    unregisterLabel(label: LabelDirectiveBase): void;
+    registeredControl: WritableSignal<FormFieldControl | null>;
+    registeredHint: WritableSignal<HintComponentBase | null>;
+    registeredLabel: WritableSignal<LabelDirectiveBase | null>;
+    activate(): void;
+};
+type LabelDirectiveBase = {
+    id: Signal<string>;
+};
+
+declare class FormFieldDirective implements FormFieldDirectiveBase {
+    /** @internal */
+    registeredControl: _angular_core.WritableSignal<FormFieldControl | null>;
+    /** @internal */
+    registeredHint: _angular_core.WritableSignal<object | null>;
+    /** @internal */
+    registeredLabel: _angular_core.WritableSignal<LabelDirectiveBase | null>;
+    private readonly FALLBACK_ID;
+    errorId: _angular_core.Signal<string>;
+    hintId: _angular_core.Signal<string>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    errors: _angular_core.Signal<readonly _angular_forms_signals.ValidationError.WithOptionalFieldTree[]>;
+    controlType: _angular_core.Signal<_ethlete_components.FormFieldControlType>;
+    focused: _angular_core.Signal<boolean>;
+    hasValue: _angular_core.Signal<boolean>;
+    usesTextFieldShell: _angular_core.Signal<boolean>;
+    shouldFloatLabel: _angular_core.Signal<boolean>;
+    describedById: _angular_core.Signal<string | null>;
+    constructor();
+    /** @internal */
+    registerControl(control: FormFieldControl): void;
+    /** @internal */
+    unregisterControl(control: FormFieldControl): void;
+    /** @internal */
+    registerHint(hint: HintComponentBase): void;
+    /** @internal */
+    unregisterHint(hint: HintComponentBase): void;
+    /** @internal */
+    unregisterLabel(label: LabelDirectiveBase): void;
+    activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormFieldDirective, "[etFormField]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SUPPORT_CONTENT_STATE$1: {
+    readonly NONE: "none";
+    readonly HINT: "hint";
+    readonly ERROR: "error";
+};
+type SupportContentState$1 = (typeof SUPPORT_CONTENT_STATE$1)[keyof typeof SUPPORT_CONTENT_STATE$1];
+declare const provideFormSupport: () => _angular_core.Provider[];
+declare const injectFormSupport: {
+    (): {
+        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<SupportContentState$1>;
+        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 ValidationError.WithOptionalFieldTree[]>;
+        supportHeight: _angular_core.Signal<number>;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        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<SupportContentState$1>;
+        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 ValidationError.WithOptionalFieldTree[]>;
+        supportHeight: _angular_core.Signal<number>;
+    };
+    (options: _angular_core.InjectOptions): {
+        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<SupportContentState$1>;
+        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 ValidationError.WithOptionalFieldTree[]>;
+        supportHeight: _angular_core.Signal<number>;
+    } | null;
+};
+
+declare class LabelDirective implements LabelDirectiveBase {
+    private formField;
+    private destroyRef;
+    id: _angular_core.WritableSignal<string>;
+    requiredMarkerVisible: _angular_core.Signal<boolean>;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    activateControl(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelDirective, "et-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class CheckboxDirective implements FormCheckboxControl, FormFieldControl {
+    private formField;
+    private destroyRef;
+    private el;
+    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>;
+    ariaChecked: _angular_core.Signal<boolean | "mixed">;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"checkbox">;
+    labelId: _angular_core.Signal<string | null>;
+    describedById: _angular_core.Signal<string | null>;
+    constructor();
+    toggle(): void;
+    activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CheckboxDirective, "[etCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "indeterminate": "indeterminateChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class CheckboxComponent {
+    private checkboxDir;
+    private checkmarkEl;
+    private indeterminateEl;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    protected frozenCheckmarkColor: _angular_core.WritableSignal<string | null>;
+    protected frozenIndeterminateColor: _angular_core.WritableSignal<string | null>;
+    isChecked: _angular_core.Signal<boolean>;
+    isIndeterminate: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "et-checkbox", never, {}, {}, never, never, true, [{ directive: typeof CheckboxDirective; inputs: { "checked": "checked"; "indeterminate": "indeterminate"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const CHECKBOX_IMPORTS: readonly [typeof CheckboxComponent, typeof CheckboxDirective];
+
+declare class ChoiceFieldComponent {
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    support: {
+        errorColorTheme: _ethlete_core.ColorTheme;
+        formFieldDir: FormFieldDirective;
+        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>;
+    };
+    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: {}; }]>;
+}
+
+declare class HintComponent implements HintComponentBase {
+    private formField;
+    private destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HintComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HintComponent, "et-hint", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const CHOICE_FIELD_IMPORTS: readonly [typeof ChoiceFieldComponent, typeof FormFieldDirective, typeof LabelDirective, typeof HintComponent];
+
+declare class DescriptionComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionComponent, "et-description", never, {}, {}, never, ["*"], true, never>;
+}
+
+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";
+    readonly ERROR: "error";
+};
+type SupportContentState = (typeof SUPPORT_CONTENT_STATE)[keyof typeof SUPPORT_CONTENT_STATE];
+declare const SUPPORT_TRANSITION_DIRECTION: {
+    readonly FROM_ABOVE: "from-above";
+    readonly FROM_BELOW: "from-below";
+    readonly TO_ABOVE: "to-above";
+    readonly TO_BELOW: "to-below";
+};
+type SupportTransitionDirection = (typeof SUPPORT_TRANSITION_DIRECTION)[keyof typeof SUPPORT_TRANSITION_DIRECTION];
+declare class FormFieldComponent {
+    private provideColor;
+    private provideSurface;
+    private parentSurfaceProvider;
+    protected formFieldDir: FormFieldDirective;
+    appearance: _angular_core.InputSignal<FormFieldAppearance>;
+    fill: _angular_core.InputSignal<FormFieldFill>;
+    labelMode: _angular_core.InputSignal<FormFieldLabelMode>;
+    size: _angular_core.InputSignal<FormFieldSize>;
+    protected errorContent: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    protected hintContent: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    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;
+    private supportPresentation;
+    private resolvedSurface;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    semanticSupportState: _angular_core.Signal<SupportContentState>;
+    protected displaysError: _angular_core.Signal<boolean>;
+    protected hasFloatingTextLabel: _angular_core.Signal<boolean>;
+    protected hasInlineLabel: _angular_core.Signal<boolean>;
+    protected prefixOffset: _angular_core.Signal<string | null>;
+    protected shouldRenderSupport: _angular_core.Signal<boolean>;
+    protected shouldRenderError: _angular_core.Signal<boolean>;
+    protected shouldRenderHint: _angular_core.Signal<boolean>;
+    protected errorActive: _angular_core.Signal<boolean>;
+    protected errorState: _angular_core.Signal<"leaving" | "active">;
+    protected errorDirection: _angular_core.Signal<SupportTransitionDirection>;
+    protected visibleErrors: _angular_core.Signal<readonly ValidationError.WithOptionalFieldTree[]>;
+    protected hintActive: _angular_core.Signal<boolean>;
+    protected hintState: _angular_core.Signal<"leaving" | "active">;
+    protected hintDirection: _angular_core.Signal<SupportTransitionDirection>;
+    protected supportHeight: _angular_core.Signal<number>;
+    constructor();
+    protected handleFramePointerDown(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "et-form-field", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "labelMode": { "alias": "labelMode"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[etInputPrefix]", "et-label", "*", "[etInputSuffix]", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }, { directive: typeof _ethlete_core.ColorInteractiveHasFocusDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InputPrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputPrefixDirective, "[etInputPrefix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InputSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputSuffixDirective, "[etInputSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare const FORM_FIELD_IMPORTS: readonly [typeof FormFieldComponent, typeof FormFieldDirective, typeof LabelDirective, typeof HintComponent, typeof InputPrefixDirective, typeof InputSuffixDirective];
+
+declare const INPUT_TEXT_ALIGNMENTS: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+};
+type InputTextAlignment = (typeof INPUT_TEXT_ALIGNMENTS)[keyof typeof INPUT_TEXT_ALIGNMENTS];
+
+declare const INPUT_TYPES: {
+    readonly TEXT: "text";
+    readonly EMAIL: "email";
+    readonly PASSWORD: "password";
+    readonly TEL: "tel";
+    readonly URL: "url";
+    readonly SEARCH: "search";
+};
+type InputType = (typeof INPUT_TYPES)[keyof typeof INPUT_TYPES];
+declare class InputDirective implements FormValueControl<string>, FormFieldControl {
+    private formField;
+    private destroyRef;
+    value: _angular_core.ModelSignal<string>;
+    touched: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    hidden: _angular_core.InputSignal<boolean>;
+    invalid: _angular_core.InputSignal<boolean>;
+    errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    required: _angular_core.InputSignal<boolean>;
+    name: _angular_core.InputSignal<string>;
+    type: _angular_core.InputSignal<InputType>;
+    placeholder: _angular_core.InputSignal<string>;
+    autocomplete: _angular_core.InputSignal<string>;
+    textAlign: _angular_core.InputSignal<InputTextAlignment>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    hasValue: _angular_core.Signal<boolean>;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"text-input">;
+    focused: _angular_core.WritableSignal<boolean>;
+    labelId: _angular_core.Signal<string | null>;
+    describedById: _angular_core.Signal<string | null>;
+    /** @internal */
+    focusTarget: _angular_core.WritableSignal<HTMLElement | null>;
+    constructor();
+    activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputDirective, "[etInput]", 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; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "textAlign": { "alias": "textAlign"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class InputComponent {
+    protected inputDir: InputDirective;
+    private nativeInput;
+    constructor();
+    syncNativeValue(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "et-input", never, {}, {}, never, never, true, [{ directive: typeof InputDirective; inputs: { "type": "type"; "placeholder": "placeholder"; "autocomplete": "autocomplete"; "textAlign": "textAlign"; "value": "value"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const INPUT_IMPORTS: readonly [typeof InputComponent, typeof InputDirective];
+
+declare const SELECTION_LIST_TOKEN: InjectionToken<SelectionListDirectiveBase<unknown>>;
+declare const SELECTION_LIST_MULTIPLE: InjectionToken<boolean>;
+type SelectionListItem<TValue = unknown> = {
+    value: Signal<TValue>;
+    checked: WritableSignal<boolean>;
+    disabled: Signal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+};
+type SelectionListDirectiveBase<TValue = unknown> = {
+    value: WritableSignal<TValue | TValue[] | null>;
+    multiple: Signal<boolean>;
+    disabled: Signal<boolean>;
+    required: Signal<boolean>;
+    name: Signal<string>;
+    items: Signal<SelectionListItem<TValue>[]>;
+    allSelected: Signal<boolean>;
+    someSelected: Signal<boolean>;
+    registerItem(item: SelectionListItem<TValue>): void;
+    unregisterItem(item: SelectionListItem<TValue>): void;
+    select(item: SelectionListItem<TValue>): void;
+    focusItem(item: SelectionListItem<TValue>): void;
+    markTouched(): void;
+    toggleAll(): void;
+};
+
+declare class SelectionListDirective implements SelectionListDirectiveBase, FormFieldControl {
+    private formField;
+    private destroyRef;
+    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<SelectionListItem[]>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    role: _angular_core.Signal<"group" | "radiogroup">;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"selection-list">;
+    describedById: _angular_core.Signal<string | null>;
+    labelId: _angular_core.Signal<string | null>;
+    allSelected: _angular_core.Signal<boolean>;
+    someSelected: _angular_core.Signal<boolean>;
+    constructor();
+    registerItem(item: SelectionListItem): void;
+    unregisterItem(item: SelectionListItem): void;
+    markTouched(): void;
+    select(item: SelectionListItem): void;
+    focusItem(item: SelectionListItem): void;
+    toggleAll(): void;
+    activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectionListDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectionListDirective, "[etSelectionList]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class CheckboxGroupComponent {
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    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>;
+    };
+    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: {}; }]>;
+}
+
+declare class SelectionListControlDirective {
+    list: _ethlete_components.SelectionListDirectiveBase<unknown>;
+    checked: _angular_core.Signal<boolean>;
+    indeterminate: _angular_core.Signal<boolean>;
+    labelId: _angular_core.WritableSignal<string>;
+    ariaChecked: _angular_core.Signal<boolean | "mixed">;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectionListControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectionListControlDirective, "[etSelectionListControl]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectionOptionDirective {
+    private list;
+    private destroyRef;
+    private el;
+    value: _angular_core.InputSignal<unknown>;
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    role: _angular_core.Signal<"radio" | "option">;
+    labelId: _angular_core.WritableSignal<string>;
+    private listItem;
+    tabindex: _angular_core.Signal<0 | -1>;
+    constructor();
+    select(): void;
+    markTouched(): void;
+    focusNext(event: Event): void;
+    focusPrevious(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectionOptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectionOptionDirective, "[etSelectionOption]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+declare class CheckboxOptionComponent {
+    optionDirective: SelectionOptionDirective;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxOptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxOptionComponent, "et-checkbox-option", never, {}, {}, never, ["*", "et-description"], true, [{ directive: typeof SelectionOptionDirective; inputs: { "value": "value"; "checked": "checked"; "disabled": "disabled"; }; outputs: { "checkedChange": "checkedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RadioGroupComponent {
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    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>;
+    };
+    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: {}; }]>;
+}
+
+declare class RadioComponent {
+    optionDirective: SelectionOptionDirective;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent, "et-radio", never, {}, {}, never, ["*", "et-description"], true, [{ directive: typeof SelectionOptionDirective; inputs: { "value": "value"; "checked": "checked"; "disabled": "disabled"; }; outputs: { "checkedChange": "checkedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SegmentedButtonGroupComponent {
+    private errorContentRef;
+    private hintContentRef;
+    private errorAnimatableRef;
+    private hintAnimatableRef;
+    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>;
+    };
+    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: {}; }]>;
+}
+
+declare class SegmentedButtonComponent {
+    optionDirective: SelectionOptionDirective;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    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: {}; }]>;
+}
+
+declare class SwitchDirective implements FormFieldControl {
+    private formField;
+    private destroyRef;
+    private el;
+    checked: _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>;
+    shouldDisplayError: _angular_core.Signal<boolean>;
+    describedBy: _angular_core.WritableSignal<string | null>;
+    controlType: _angular_core.WritableSignal<"switch">;
+    labelId: _angular_core.Signal<string | null>;
+    describedById: _angular_core.Signal<string | null>;
+    constructor();
+    toggle(): void;
+    activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SwitchDirective, "[etSwitch]", never, { "checked": { "alias": "checked"; "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"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class SwitchComponent {
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "et-switch", never, {}, {}, never, never, true, [{ directive: typeof SwitchDirective; inputs: { "checked": "checked"; "disabled": "disabled"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "checkedChange": "checkedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const SWITCH_IMPORTS: readonly [typeof SwitchComponent, typeof SwitchDirective];
+
+type GridBreakpointName = string;
+type GridItemPosition = {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+};
+type GridItemConstraints = {
+    minColSpan: number;
+    maxColSpan: number;
+    minRowSpan: number;
+    maxRowSpan: number;
+};
+type GridItemConfig<TType extends string = string, TData = unknown> = {
+    id: string;
+    type: TType;
+    data: TData;
+    layout: Record<GridBreakpointName, GridItemPosition>;
+};
+type GridBreakpointConfig = {
+    name: GridBreakpointName;
+    columns: number;
+    minWidth: number;
+};
+type GridSerializedState = {
+    columns: Record<GridBreakpointName, number>;
+    rowHeight: number;
+    items: GridItemConfig[];
+};
+type GridLayoutEntry = {
+    id: string;
+    position: GridItemPosition;
+};
+type GridComponentRegistration<TData = unknown> = {
+    component: Type<{
+        data: InputSignal<TData>;
+    }>;
+    type: string;
+    constraints?: {
+        minColSpan?: number;
+        maxColSpan?: number;
+        minRowSpan?: number;
+        maxRowSpan?: number;
+    };
+    configComponent?: Type<unknown>;
+};
+/**
+ * Injectable reference provided to configComponent instances.
+ * Gives the config form access to the item's current data and the ability to save or cancel.
+ */
+declare abstract class GridItemRef<TData = unknown> {
+    abstract readonly data: Signal<TData | undefined>;
+    abstract save(data: TData): void;
+    abstract close(): void;
+}
+
+type ResizeItemOptions = {
+    id: string;
+    newColSpan: number;
+    newRowSpan: number;
+    newCol?: number;
+    newRow?: number;
+};
+type GridDragState = {
+    itemId: string;
+    originPosition: GridItemPosition;
+    targetPosition: GridItemPosition;
+};
+declare class GridDirective {
+    private injector;
+    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;
+    private layoutOverrides;
+    dragState: _angular_core.WritableSignal<GridDragState | null>;
+    private constraintsRegistry;
+    private resizeBaseLayout;
+    private itemElements;
+    private ghostElement;
+    private rectSnapshot;
+    containerWidth: _angular_core.Signal<number>;
+    activeBreakpoint: _angular_core.Signal<string>;
+    activeColumns: _angular_core.Signal<number>;
+    items: _angular_core.Signal<GridItemConfig[]>;
+    baseLayout: _angular_core.Signal<GridLayoutEntry[]>;
+    layout: _angular_core.Signal<GridLayoutEntry[]>;
+    ghostPosition: _angular_core.Signal<GridItemPosition | null>;
+    constructor();
+    registerConstraints(id: string, constraints: GridItemConstraints): void;
+    registerItem(id: string, options: {
+        el: HTMLElement;
+        constraints: GridItemConstraints;
+    }): void;
+    unregisterItem(id: string): void;
+    setGhostElement(el: HTMLElement | null): void;
+    getConstraints(id: string): GridItemConstraints;
+    snapshotRects(): void;
+    animateLayoutTransition(options?: {
+        excludeIds?: Set<string>;
+        scaleIds?: Set<string>;
+    }): void;
+    beginDrag(itemId: string): void;
+    updateDragTarget(targetPosition: GridItemPosition): void;
+    commitDrag(): void;
+    addItem(type: string, data: unknown): void;
+    removeItem(id: string): void;
+    moveItem(id: string, newPosition: GridItemPosition): void;
+    resizeItem(options: ResizeItemOptions): void;
+    commitResize(): void;
+    getSerializedState(): GridSerializedState;
+    restoreState(state: GridSerializedState): void;
+    private placeItem;
+    private shrinkNeighbors;
+    private updateLayoutForCurrentBreakpoint;
+    private updateItemLayout;
+    private emitLayoutChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDirective, "[etGrid]", ["etGrid"], { "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "initialItems": { "alias": "initialItems"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; }, never, never, true, never>;
+}
+
+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>;
+    hostStyles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    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>;
+}
+
+declare class GridDragDirective {
+    protected grid: _ethlete_components.GridDirective;
+    private gridItem;
+    private injector;
+    private elementRef;
+    dragHandle: DragHandleDirective;
+    private renderer;
+    private dragStartClient;
+    private dragPixelOffset;
+    hostStyles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    constructor();
+    private applyFixed;
+    private releaseFixed;
+    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"; }; }]>;
+}
+
+declare class GridResizeDirective {
+    private grid;
+    private gridItem;
+    isResizing: _angular_core.WritableSignal<boolean>;
+    resizeEdges: _angular_core.Signal<ResizeEdge[]>;
+    private resizeStartPos;
+    beginResize(): void;
+    updateResize(event: ResizeMoveEvent): void;
+    finishResize(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridResizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridResizeDirective, "[etGridResize]", never, {}, {}, never, never, true, never>;
+}
+
+declare const GRID_TOKEN: InjectionToken<GridDirective>;
+
+type GridConfig = {
+    registrations: GridComponentRegistration[];
+    interactiveAriaLabel: string;
+    readonlyAriaLabel: string;
+    dragHandleAriaLabel: string;
+    transformer: (text: string, locale: string) => string;
+};
+declare const provideGridConfig: (valueOverride?: Partial<GridConfig> | undefined) => _angular_core.Provider[];
+declare const injectGridConfig: {
+    (): GridConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): GridConfig;
+    (options: _angular_core.InjectOptions): GridConfig | null;
+};
+
+type GridAdapter<TExternal> = {
+    fromExternal(items: TExternal[]): GridItemConfig[];
+    toExternal(items: GridItemConfig[]): TExternal[];
+};
+declare const createGridAdapter: <TExternal>(fromItem: (item: TExternal) => GridItemConfig, toItem: (item: GridItemConfig) => TExternal) => GridAdapter<TExternal>;
+/** Map a backend position shaped as `{x, y, cols, rows}` to a `GridItemPosition`. */
+declare const toGridPosition: (pos: {
+    x: number;
+    y: number;
+    cols: number;
+    rows: number;
+}) => GridItemPosition;
+/** Map a `GridItemPosition` to a backend position shaped as `{x, y, cols, rows}`. */
+declare const fromGridPosition: (pos: GridItemPosition) => {
+    x: number;
+    y: number;
+    cols: number;
+    rows: number;
+};
+
+declare class GridComponent {
+    grid: GridDirective;
+    private ghostRef;
+    private gridConfig;
+    private locale;
+    protected ariaLabel: _angular_core.Signal<string>;
+    hostStyles: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    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"; }; }]>;
+}
+
+declare class GridItemComponent {
+    private grid;
+    private gridItem;
+    gridDrag: GridDragDirective;
+    gridResize: GridResizeDirective;
+    ariaLabel: _angular_core.InputSignal<string>;
+    removed: _angular_core.OutputEmitterRef<void>;
+    private gridConfig;
+    private locale;
+    protected isReadOnly: _angular_core.Signal<boolean>;
+    protected dragHandleAriaLabel: _angular_core.Signal<string>;
+    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: {}; }]>;
+}
+
+declare const GRID_ERROR_CODES: {
+    readonly MISSING_GRID: 1900;
+    readonly MISSING_GRID_ITEM: 1901;
+    readonly DUPLICATE_ITEM_ID: 1902;
+    readonly INVALID_LAYOUT_STATE: 1903;
+};
+
+declare const GridImports: readonly [typeof GridComponent, typeof GridItemComponent];
+
+type IconDefinition = {
+    name: string;
+    data: string;
+};
+declare const ICONS_TOKEN: InjectionToken<Record<string, IconDefinition>>;
+declare const provideIcons: (...icons: IconDefinition[]) => {
+    provide: InjectionToken<Record<string, IconDefinition>>;
+    useValue: Record<string, IconDefinition>;
+};
+
+declare const ARROW_OUT_UP_RIGHT_ICON: IconDefinition;
+
+declare const ARROW_RIGHT_ICON: IconDefinition;
+
+declare const CHEVRON_ICON: IconDefinition;
+
+declare const CLIPBOARD_CHECK_ICON: IconDefinition;
+
+declare const FLOPPY_DISK_ICON: IconDefinition;
+
+declare const FOCUS_FRAME_ICON: IconDefinition;
+
+declare const GRID_2X2_ICON: IconDefinition;
+
+declare const ICON_ERROR_CODES: {
+    readonly NO_ICONS_PROVIDED: 1800;
+    readonly ICON_NOT_FOUND: 1801;
+    readonly INVALID_SVG: 1802;
+    readonly MISSING_XMLNS: 1803;
+    readonly MISSING_DIMENSIONS: 1804;
+    readonly HARDCODED_COLOR: 1805;
+    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>;
+    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>;
+}
+
+declare const LOCK_ICON: IconDefinition;
+
+declare const PENCIL_ICON: IconDefinition;
+
+declare const PLUS_ICON: IconDefinition;
+
+declare const TIMES_ICON: IconDefinition;
+
+declare const TRIANGLE_EXCLAMATION_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 NotificationActionDirective {
+    private notification;
+    constructor();
+    runAction(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationActionDirective, "[etNotificationAction]", ["etNotificationAction"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationDismissDirective {
+    private notification;
+    constructor();
+    dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDismissDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDismissDirective, "[etNotificationDismiss]", ["etNotificationDismiss"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationItemDirective {
+    private elementRef;
+    private stack;
+    ref: _angular_core.InputSignal<{
+        id: string;
+        entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+        update: (partial: Partial<_ethlete_components.NotificationConfig>) => void;
+        dismiss: () => void;
+        pauseTimer: () => void;
+        resumeTimer: () => void;
+        afterDismissed: () => rxjs.Observable<void>;
+        markDismissed: () => void;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationItemDirective, "[etNotificationItem]", never, { "ref": { "alias": "etNotificationItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type RegisteredNotificationItem = {
+    id: string;
+    el: HTMLElement;
+};
+declare class NotificationStackDirective {
+    protected context: _ethlete_components.NotificationStackContext;
+    private destroyRef;
+    private injector;
+    private renderer;
+    /** @internal */
+    registeredItems: _angular_core.WritableSignal<RegisteredNotificationItem[]>;
+    displayRefs: _angular_core.Signal<{
+        id: string;
+        entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+        update: (partial: Partial<_ethlete_components.NotificationConfig>) => void;
+        dismiss: () => void;
+        pauseTimer: () => void;
+        resumeTimer: () => void;
+        afterDismissed: () => rxjs.Observable<void>;
+        markDismissed: () => void;
+    }[]>;
+    constructor();
+    /** @internal */
+    registerItem(id: string, el: HTMLElement): void;
+    /** @internal */
+    unregisterItem(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationStackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationStackDirective, "[etNotificationStack]", ["etNotificationStack"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationDirective {
+    private animatedLifecycle;
+    ref: _angular_core.InputSignal<{
+        id: string;
+        entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+        update: (partial: Partial<_ethlete_components.NotificationConfig>) => void;
+        dismiss: () => void;
+        pauseTimer: () => void;
+        resumeTimer: () => void;
+        afterDismissed: () => rxjs.Observable<void>;
+        markDismissed: () => void;
+    }>;
+    entry: _angular_core.Signal<_ethlete_components.NotificationEntry>;
+    status: _angular_core.Signal<_ethlete_components.NotificationStatus>;
+    isLoading: _angular_core.Signal<boolean>;
+    isSuccess: _angular_core.Signal<boolean>;
+    isError: _angular_core.Signal<boolean>;
+    isInfo: _angular_core.Signal<boolean>;
+    title: _angular_core.Signal<string>;
+    message: _angular_core.Signal<string | undefined>;
+    action: _angular_core.Signal<_ethlete_components.NotificationAction | undefined>;
+    progress: _angular_core.Signal<number | undefined>;
+    ariaRole: _angular_core.Signal<"status" | "alert">;
+    /** @internal */
+    registeredAction: _angular_core.WritableSignal<NotificationActionDirective | null>;
+    /** @internal */
+    registeredDismiss: _angular_core.WritableSignal<NotificationDismissDirective | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NotificationDirective, "[etNotification]", ["etNotification"], { "ref": { "alias": "ref"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const NOTIFICATION_STATUS: {
+    readonly LOADING: "loading";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly INFO: "info";
+};
+type NotificationStatus = (typeof NOTIFICATION_STATUS)[keyof typeof NOTIFICATION_STATUS];
+type NotificationAction = {
+    label: string;
+    handler: () => void;
+};
+type NotificationConfig = {
+    status: NotificationStatus;
+    title: string;
+    message?: string;
+    action?: NotificationAction;
+    /**
+     * Auto-dismiss duration in milliseconds.
+     * `0` or `undefined` uses the manager's `defaultDuration` for the current status.
+     * Set explicitly to override the default (e.g. `duration: 0` to prevent auto-dismiss
+     * for a status that defaults to non-zero).
+     */
+    duration?: number;
+    /** Optional progress value (0–100). When set, a progress bar is shown below the notification body. */
+    progress?: number;
+};
+type NotificationManagerConfig = {
+    /** Position of the notification stack on screen. @default 'bottom-end' */
+    position: 'bottom-center' | 'bottom-start' | 'bottom-end' | 'top-center' | 'top-start' | 'top-end';
+    /** Maximum number of simultaneously visible notifications. @default 3 */
+    maxVisible: number;
+    /**
+     * Default auto-dismiss duration (ms) per status.
+     * `0` means no auto-dismiss.
+     * @default `{ success: 4000, info: 4000, loading: 0, error: 0 }`
+     */
+    defaultDuration: Partial<Record<NotificationStatus, number>>;
+    /**
+     * Maps each notification status to a color key used by `ProvideColorDirective`.
+     * When set, the notification host element receives the corresponding color class
+     * so that `et-button` and other colored components render correctly inside the notification.
+     */
+    statusColorMapping?: Partial<Record<NotificationStatus, string>>;
+    /**
+     * Color key applied to control elements (e.g. the dismiss button).
+     * Uses the notification's status color when not set.
+     */
+    controlsColor?: string;
+    /**
+     * Accessible label for the dismiss button.
+     * @default 'Dismiss'
+     */
+    dismissLabel: string;
+};
+declare const DEFAULT_NOTIFICATION_MANAGER_CONFIG: NotificationManagerConfig;
+declare const provideNotificationManagerConfig: (valueOverride?: Partial<NotificationManagerConfig> | undefined) => _angular_core.Provider[];
+declare const injectNotificationManagerConfig: {
+    (): NotificationManagerConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): NotificationManagerConfig;
+    (options: _angular_core.InjectOptions): NotificationManagerConfig | null;
+};
+
+declare const NOTIFICATION_ERROR_CODES: {
+    readonly ACTION_OUTSIDE_NOTIFICATION: 1700;
+    readonly DISMISS_OUTSIDE_NOTIFICATION: 1701;
+};
+
+type NotificationEntry = {
+    id: string;
+    config: NotificationConfig;
+    isDismissing: boolean;
+    isDismissed: boolean;
+};
+declare const createNotificationRef: (config: NotificationConfig, { managerConfig, beforeChange }: {
+    managerConfig: NotificationManagerConfig;
+    beforeChange?: () => void;
+}) => {
+    id: string;
+    entry: _angular_core.Signal<NotificationEntry>;
+    update: (partial: Partial<NotificationConfig>) => void;
+    dismiss: () => void;
+    pauseTimer: () => void;
+    resumeTimer: () => void;
+    afterDismissed: () => rxjs.Observable<void>;
+    markDismissed: () => void;
+};
+type NotificationRef = ReturnType<typeof createNotificationRef>;
+
+type NotificationManager = {
+    open: (config: NotificationConfig) => NotificationRef;
+    dismissAll: () => void;
+    notifications: Signal<NotificationRef[]>;
+    visibleNotifications: Signal<NotificationRef[]>;
+};
+declare const provideNotificationManagerInstance: () => _angular_core.Provider[];
+declare const injectNotificationManager: {
+    (): NotificationManager;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): NotificationManager;
+    (options: _angular_core.InjectOptions): NotificationManager | null;
+};
+declare const provideNotificationManager: (config?: Partial<NotificationManagerConfig>) => _angular_core.Provider[];
+
+type NotificationStackContext = {
+    visibleNotifications: Signal<NotificationRef[]>;
+    position: NotificationManagerConfig['position'];
+    /** @internal Set by the stack component. Called by the manager before any mutation. */
+    captureBeforeState: (() => void) | null;
+};
+declare const NOTIFICATION_STACK_CONTEXT_TOKEN: InjectionToken<NotificationStackContext>;
+
+declare class NotificationComponent {
+    protected notification: NotificationDirective;
+    private animatedLifecycle;
+    private provideTheme;
+    private provideSurface;
+    private managerConfig;
+    private surfaceThemes;
+    private surfaceContextTracker;
+    private resolvedColor;
+    private resolvedSurface;
+    protected controlsColor: _angular_core.Signal<string | null>;
+    protected dismissLabel: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "et-notification", never, {}, {}, never, never, true, [{ directive: typeof NotificationDirective; inputs: { "ref": "ref"; }; outputs: {}; }, { directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }]>;
+}
+
+declare const NOTIFICATION_IMPORTS: readonly [typeof NotificationComponent, typeof NotificationDirective, typeof NotificationActionDirective, typeof NotificationDismissDirective];
+
+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;
+};
+type OverlayRef<TComponent extends object = object, TResult = unknown> = ReturnType<typeof createOverlayRef<TComponent, TResult>>;
+declare const OVERLAY_REF: InjectionToken<{
+    readonly id: string;
+    config: OverlayConfig;
+    readonly componentInstance: object | null;
+    close(result?: unknown): void;
+    afterOpened(): Observable<void>;
+    beforeClosed(): Observable<unknown>;
+    afterClosed(): Observable<unknown>;
+    attachRuntime(runtimeRef: OverlayRuntimeRef<object, unknown>): void;
+}>;
+
+declare class OverlayTemplateHostComponent {
+    private animatedLifecycleInstance;
+    protected template: _angular_core.InputSignal<TemplateRef<OverlaySurfaceContext>>;
+    protected context: _angular_core.InputSignal<OverlaySurfaceContext>;
+    animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTemplateHostComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayTemplateHostComponent, "et-overlay-template-host", never, { "template": { "alias": "template"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.AnimatedLifecycleDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class OverlayTriggerDirective {
+    private overlay;
+    private destroyRef;
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    toggle(): void;
+    isOpen(): boolean;
+    expanded(): boolean | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTriggerDirective, "[etOverlayTrigger]", ["etOverlayTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare class OverlayDirective {
+    private destroyRef;
+    mode: _angular_core.InputSignal<OverlayMode>;
+    role: _angular_core.InputSignal<OverlayRole | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    disableClose: _angular_core.InputSignal<boolean>;
+    autoFocus: _angular_core.InputSignal<string | false | undefined>;
+    restoreFocus: _angular_core.InputSignal<boolean>;
+    hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
+    closeOnEscape: _angular_core.InputSignal<boolean>;
+    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
+    hostClass: _angular_core.InputSignal<string | string[] | undefined>;
+    backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
+    panelClass: _angular_core.InputSignal<string | string[] | undefined>;
+    placement: _angular_core.InputSignal<Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    viewportPadding: _angular_core.InputSignal<Padding | null>;
+    autoResize: _angular_core.InputSignal<boolean>;
+    shift: _angular_core.InputSignal<boolean>;
+    autoHide: _angular_core.InputSignal<boolean>;
+    autoCloseIfReferenceHidden: _angular_core.InputSignal<boolean>;
+    mirrorWidth: _angular_core.InputSignal<boolean>;
+    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;
+    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 const OVERLAY_ERROR_CODES: {
+    readonly MISSING_OVERLAY_SURFACE: 1200;
+    readonly TRIGGER_OUTSIDE_OVERLAY: 1201;
+    readonly ANCHOR_OUTSIDE_OVERLAY: 1202;
+    readonly SURFACE_OUTSIDE_OVERLAY: 1203;
+};
+
+type OverlayManager = {
+    open: <TComponent extends object, TResult = unknown>(component: Type<TComponent>, config?: OverlayConfig) => OverlayRef<TComponent, TResult>;
+    openOverlays: ReturnType<typeof computed<OverlayRef<object, unknown>[]>>;
+};
+declare const provideOverlayManager: () => _angular_core.Provider[];
+declare const injectOverlayManager: {
+    (): OverlayManager;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): OverlayManager;
+    (options: _angular_core.InjectOptions): OverlayManager | null;
+};
+
+declare const OVERLAY_IMPORTS: readonly [typeof OverlayDirective, typeof OverlayTriggerDirective, typeof OverlayAnchorDirective, typeof OverlaySurfaceDirective];
+
+declare class ScrollableActiveChildDirective {
+    private scrollable;
+    private destroyRef;
+    private elementRef;
+    isActiveChildEnabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private isActiveChildEnabledSignal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableActiveChildDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableActiveChildDirective, "[etScrollableActiveChild]", never, { "isActiveChildEnabled": { "alias": "etScrollableActiveChild"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const SCROLLABLE_SCROLL_MODES: {
+    readonly CONTAINER: "container";
+    readonly ELEMENT: "element";
+};
+type ScrollableScrollMode = (typeof SCROLLABLE_SCROLL_MODES)[keyof typeof SCROLLABLE_SCROLL_MODES];
+declare const SCROLLABLE_DIRECTIONS: {
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};
+type ScrollableDirection = (typeof SCROLLABLE_DIRECTIONS)[keyof typeof SCROLLABLE_DIRECTIONS];
+declare const SCROLLABLE_ITEM_SIZES: {
+    readonly AUTO: "auto";
+    readonly SAME: "same";
+    readonly HALF: "half";
+    readonly THIRD: "third";
+    readonly QUARTER: "quarter";
+    readonly FULL: "full";
+};
+type ScrollableItemSize = (typeof SCROLLABLE_ITEM_SIZES)[keyof typeof SCROLLABLE_ITEM_SIZES];
+declare const SCROLLABLE_SCROLL_ORIGINS: {
+    readonly AUTO: "auto";
+    readonly CENTER: "center";
+    readonly START: "start";
+    readonly END: "end";
+};
+type ScrollableScrollOrigin = (typeof SCROLLABLE_SCROLL_ORIGINS)[keyof typeof SCROLLABLE_SCROLL_ORIGINS];
+declare const SCROLLABLE_BUTTON_POSITIONS: {
+    readonly INSIDE: "inside";
+    readonly FOOTER: "footer";
+};
+type ScrollableButtonPosition = (typeof SCROLLABLE_BUTTON_POSITIONS)[keyof typeof SCROLLABLE_BUTTON_POSITIONS];
+declare const SCROLLABLE_MASK_VARIANTS: {
+    readonly GRADIENT: "gradient";
+    readonly BORDER: "border";
+};
+type ScrollableMaskVariant = (typeof SCROLLABLE_MASK_VARIANTS)[keyof typeof SCROLLABLE_MASK_VARIANTS];
+declare const SCROLLABLE_LOADING_TEMPLATE_POSITIONS: {
+    readonly START: "start";
+    readonly END: "end";
+};
+type ScrollableLoadingTemplatePosition = (typeof SCROLLABLE_LOADING_TEMPLATE_POSITIONS)[keyof typeof SCROLLABLE_LOADING_TEMPLATE_POSITIONS];
+type ScrollableIntersectionChange = {
+    element: HTMLElement;
+    intersectionRatio: number;
+    isIntersecting: boolean;
+    index: number;
+};
+type ScrollableScrollState = {
+    isAtStart: boolean;
+    isAtEnd: boolean;
+    canScroll: boolean;
+};
+type ScrollableNavigationItem = {
+    isActive: boolean;
+    activeOffset: number;
+    element: HTMLElement;
+};
+type ScrollableNavigation = {
+    items: ScrollableNavigationItem[];
+    activeIndex: number;
+};
+
+declare class ScrollableDirective {
+    itemSize: _angular_core.InputSignalWithTransform<ScrollableItemSize, _ethlete_core.BreakpointInput<ScrollableItemSize>>;
+    direction: _angular_core.InputSignalWithTransform<ScrollableDirection, _ethlete_core.BreakpointInput<ScrollableDirection>>;
+    scrollMode: _angular_core.InputSignalWithTransform<ScrollableScrollMode, _ethlete_core.BreakpointInput<ScrollableScrollMode>>;
+    scrollOrigin: _angular_core.InputSignal<ScrollableScrollOrigin>;
+    scrollMargin: _angular_core.InputSignalWithTransform<number, unknown>;
+    renderScrollbars: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    scrollContainerRef: _angular_core.WritableSignal<ElementRef<HTMLElement> | null>;
+    private childIntersectionsActivated;
+    private allScrollableChildren;
+    scrollableChildren: Signal<HTMLElement[]>;
+    /** @internal */
+    scrollObserverRef: _angular_core.WritableSignal<ScrollObserverDirective | null>;
+    containerScrollState: Signal<_ethlete_core.ElementScrollState>;
+    isAtStart: Signal<boolean>;
+    isAtEnd: Signal<boolean>;
+    canScroll: Signal<boolean>;
+    childIntersections: Signal<_ethlete_core.IntersectionObserverEntryWithDetails[]>;
+    scrollableDimensions: Signal<_ethlete_core.NullableElementDimensions>;
+    private activeChildren;
+    /** @internal */
+    loadingTemplateRef: _angular_core.WritableSignal<ScrollableLoadingTemplateRef | null>;
+    loadingTemplate: Signal<ScrollableLoadingTemplateRef | null>;
+    /** @internal */
+    masksDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    buttonsDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    navigationDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    snapDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    dragDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    darkenDirective: _angular_core.WritableSignal<unknown>;
+    /** @internal */
+    hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: Signal<unknown>) => void;
+        pushMany: (map: Record<string, Signal<unknown>>) => void;
+    };
+    /** @internal */
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: Signal<unknown>) => void;
+        pushMany: (map: Record<string, Signal<unknown>>) => void;
+    };
+    gapValue: Signal<string | null>;
+    /** @internal */
+    hostStyleBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: Signal<unknown>) => void;
+        pushMany: (map: Record<string, Signal<unknown>>) => void;
+    };
+    constructor();
+    /** @internal */
+    unregisterActiveChild(child: ScrollableActiveChildRef): void;
+    activateChildIntersections(): void;
+    scrollOneContainerSize(scrollDirection: 'start' | 'end'): void;
+    scrollOneItemSize(scrollDirection: 'start' | 'end'): void;
+    getElementScrollCoordinates(options: Omit<ScrollToElementOptions, 'container'> & {
+        ignoreForcedOrigin?: boolean;
+    }): ScrollToOptions;
+    scrollToElement(options: Omit<ScrollToElementOptions, 'container'> & {
+        ignoreForcedOrigin?: boolean;
+    }): void;
+    scrollToElementByIndex(options: Omit<ScrollToElementOptions, 'container'> & {
+        index: number;
+        ignoreForcedOrigin?: boolean;
+    }): void;
+    scrollToStartDirection(): void;
+    scrollToEndDirection(): void;
+    getActiveChildren(): Signal<ScrollableActiveChildRef[]>;
+    getScrollContainerRef(): Signal<ElementRef<HTMLElement> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableDirective, "[etScrollable]", ["etScrollable"], { "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "scrollMode": { "alias": "scrollMode"; "required": false; "isSignal": true; }; "scrollOrigin": { "alias": "scrollOrigin"; "required": false; "isSignal": true; }; "scrollMargin": { "alias": "scrollMargin"; "required": false; "isSignal": true; }; "renderScrollbars": { "alias": "renderScrollbars"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ScrollableActiveChildRef = {
+    elementRef: ElementRef<HTMLElement>;
+    isActiveChildEnabled: Signal<boolean>;
+};
+type ScrollableLoadingTemplateRef = {
+    templateRef: TemplateRef<unknown>;
+    repeat: Signal<unknown[]>;
+};
+
+declare class ScrollableButtonsDirective {
+    protected scrollable: ScrollableDirective;
+    position: _angular_core.InputSignal<ScrollableButtonPosition>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableButtonsDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollableButtonsDirective, "et-scrollable-buttons, [et-scrollable-buttons]", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollableDarkenDirective {
+    private scrollable;
+    private nonFullIntersecting;
+    /** @internal */
+    nonFullIntersectingClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableDarkenDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableDarkenDirective, "[etScrollableDarken]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScrollableDragDirective {
+    private scrollable;
+    enabled: _angular_core.InputSignal<boolean>;
+    cursorDragScrollState: {
+        isDragging: _angular_core.Signal<boolean>;
+        currentDragAmount: _angular_core.Signal<{
+            x: number;
+            y: number;
+        }>;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableDragDirective, never>;
+    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 class ScrollableIgnoreChildDirective {
+    enabled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableIgnoreChildDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableIgnoreChildDirective, "[etScrollableIgnoreChild]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollableLoadingTemplateDirective {
+    private scrollable;
+    private templateRef;
+    repeatContentCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    repeat: _angular_core.Signal<unknown[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableLoadingTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableLoadingTemplateDirective, "ng-template[etScrollableLoadingTemplate]", never, { "repeatContentCount": { "alias": "repeatContentCount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollableMasksDirective {
+    private scrollable;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableMasksDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollableMasksDirective, "et-scrollable-masks, [et-scrollable-masks]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScrollableNavigationDirective {
+    protected scrollable: ScrollableDirective;
+    private navigationDotsContainer;
+    private firstNavigationDot;
+    private navigationDotDimensions;
+    private manualActiveNavigationIndex;
+    navigation: _angular_core.Signal<ScrollableNavigation>;
+    activeIndex: _angular_core.Signal<number>;
+    /** @internal */
+    dotsContainerStyleBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: _angular_core.Signal<unknown>) => void;
+        pushMany: (map: Record<string, _angular_core.Signal<unknown>>) => void;
+    };
+    constructor();
+    scrollToElementViaNavigation(elementIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableNavigationDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollableNavigationDirective, "et-scrollable-navigation, [et-scrollable-navigation]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScrollableSnapDirective {
+    private scrollable;
+    enabled: _angular_core.InputSignal<boolean>;
+    snapOrigin: _angular_core.InputSignal<ScrollableScrollOrigin>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableSnapDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScrollableSnapDirective, "[etScrollableSnap]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "snapOrigin": { "alias": "snapOrigin"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollableComponent {
+    scrollableDir: ScrollableDirective;
+    renderMasks: _angular_core.InputSignal<boolean>;
+    maskVariant: _angular_core.InputSignal<ScrollableMaskVariant>;
+    renderButtons: _angular_core.InputSignal<boolean>;
+    buttonPosition: _angular_core.InputSignal<ScrollableButtonPosition>;
+    renderNavigation: _angular_core.InputSignal<boolean>;
+    snap: _angular_core.InputSignal<boolean>;
+    cursorDragScroll: _angular_core.InputSignal<boolean>;
+    darkenNonIntersectingItems: _angular_core.InputSignal<boolean>;
+    stickyButtons: _angular_core.InputSignal<boolean>;
+    showLoadingTemplate: _angular_core.InputSignal<boolean>;
+    loadingTemplatePosition: _angular_core.InputSignal<ScrollableLoadingTemplatePosition>;
+    scrollableRole: _angular_core.InputSignal<string | null>;
+    scrollableClass: _angular_core.InputSignal<string | null>;
+    intersectionChange: _angular_core.OutputRef<ScrollableIntersectionChange[]>;
+    scrollStateChange: _angular_core.OutputRef<ScrollableScrollState>;
+    private scrollContainerEl;
+    private scrollObserver;
+    renderButtonsInside: _angular_core.Signal<boolean>;
+    renderButtonsInFooter: _angular_core.Signal<boolean>;
+    canAnimate: {
+        state: _angular_core.Signal<boolean>;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollableComponent, "et-scrollable", never, { "renderMasks": { "alias": "renderMasks"; "required": false; "isSignal": true; }; "maskVariant": { "alias": "maskVariant"; "required": false; "isSignal": true; }; "renderButtons": { "alias": "renderButtons"; "required": false; "isSignal": true; }; "buttonPosition": { "alias": "buttonPosition"; "required": false; "isSignal": true; }; "renderNavigation": { "alias": "renderNavigation"; "required": false; "isSignal": true; }; "snap": { "alias": "snap"; "required": false; "isSignal": true; }; "cursorDragScroll": { "alias": "cursorDragScroll"; "required": false; "isSignal": true; }; "darkenNonIntersectingItems": { "alias": "darkenNonIntersectingItems"; "required": false; "isSignal": true; }; "stickyButtons": { "alias": "stickyButtons"; "required": false; "isSignal": true; }; "showLoadingTemplate": { "alias": "showLoadingTemplate"; "required": false; "isSignal": true; }; "loadingTemplatePosition": { "alias": "loadingTemplatePosition"; "required": false; "isSignal": true; }; "scrollableRole": { "alias": "scrollableRole"; "required": false; "isSignal": true; }; "scrollableClass": { "alias": "scrollableClass"; "required": false; "isSignal": true; }; }, { "intersectionChange": "intersectionChange"; "scrollStateChange": "scrollStateChange"; }, never, ["*"], true, [{ directive: typeof ScrollableDirective; inputs: { "itemSize": "itemSize"; "direction": "direction"; "scrollMode": "scrollMode"; "scrollOrigin": "scrollOrigin"; "scrollMargin": "scrollMargin"; "renderScrollbars": "renderScrollbars"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+}
+
+declare const SCROLLABLE_IMPORTS: readonly [typeof ScrollableComponent, typeof ScrollableActiveChildDirective, typeof ScrollableIgnoreChildDirective, typeof ScrollableLoadingTemplateDirective];
+
+declare class StreamConsentAcceptDirective {
+    protected consent: _ethlete_components.StreamConsentDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamConsentAcceptDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StreamConsentAcceptDirective, "[etStreamConsentAccept]", never, {}, {}, never, never, true, never>;
+}
+
+declare const STREAM_CONSENT_TOKEN: InjectionToken<StreamConsentDirective>;
+declare const STREAM_USER_CONSENT_PROVIDER_TOKEN: InjectionToken<ConsentHandler | null>;
+declare const injectStreamUserConsentProvider: () => ConsentHandler | null;
+declare class StreamConsentDirective {
+    private handler;
+    private localGranted;
+    isGranted: _angular_core.Signal<boolean>;
+    grant(): void;
+    revoke(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamConsentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StreamConsentDirective, "[etStreamConsent]", never, {}, {}, never, never, true, never>;
+}
+
+type StreamConsentConfig = {
+    /** The heading displayed in the consent placeholder. */
+    heading: string;
+    /** The description text displayed below the heading. */
+    description: string;
+    /** The label for the accept button. */
+    acceptLabel: string;
+    /**
+     * The color theme name to apply on the accept button.
+     * When set, applies `[etProvideColor]` on the button element.
+     */
+    acceptButtonColor: string | null;
+    /**
+     * A function to transform text based on the current locale.
+     * Use `provideLocale()` to update the locale dynamically.
+     */
+    transformer: (text: string, locale: string) => string;
+};
+declare const provideStreamConsentConfig: (valueOverride?: Partial<StreamConsentConfig> | undefined) => _angular_core.Provider[];
+declare const injectStreamConsentConfig: {
+    (): StreamConsentConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StreamConsentConfig;
+    (options: _angular_core.InjectOptions): StreamConsentConfig | null;
+};
+
+declare class StreamConsentComponent {
+    private parentSurfaceProvider;
+    private config;
+    private locale;
+    private surfaceThemes;
+    cardSurface: _angular_core.Signal<string | null>;
+    heading: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string>;
+    acceptLabel: _angular_core.Signal<string>;
+    acceptButtonColor: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamConsentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamConsentComponent, "et-stream-consent", never, {}, {}, never, never, true, [{ directive: typeof StreamConsentDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type StreamPlayerErrorContext = {
+    readonly error: Signal<unknown>;
+    retry(): void;
+};
+declare const STREAM_PLAYER_ERROR_CONTEXT_TOKEN: InjectionToken<StreamPlayerErrorContext>;
+declare const STREAM_PLAYER_ERROR_TOKEN: InjectionToken<StreamPlayerErrorDirective>;
+declare class StreamPlayerErrorDirective {
+    context: StreamPlayerErrorContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPlayerErrorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StreamPlayerErrorDirective, "[etStreamPlayerError]", never, {}, {}, never, never, true, never>;
+}
+
+type StreamPlayerErrorConfig = {
+    /** The heading displayed in the error overlay. */
+    heading: string;
+    /** The description text displayed below the heading. */
+    description: string;
+    /** The label for the retry button. */
+    retryLabel: string;
+    /**
+     * The color theme name to apply on the retry button.
+     * When set, applies `[color]` on the button element.
+     */
+    retryButtonColor: string | null;
+    /**
+     * A function to transform text based on the current locale.
+     * Use `provideLocale()` to update the locale dynamically.
+     */
+    transformer: (text: string, locale: string) => string;
+};
+declare const provideStreamPlayerErrorConfig: (valueOverride?: Partial<StreamPlayerErrorConfig> | undefined) => _angular_core.Provider[];
+declare const injectStreamPlayerErrorConfig: {
+    (): StreamPlayerErrorConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StreamPlayerErrorConfig;
+    (options: _angular_core.InjectOptions): StreamPlayerErrorConfig | null;
+};
+
+declare class StreamPlayerErrorComponent {
+    private errorDirective;
+    private parentSurfaceProvider;
+    private config;
+    private locale;
+    private surfaceThemes;
+    cardSurface: _angular_core.Signal<string | null>;
+    heading: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string>;
+    retryLabel: _angular_core.Signal<string>;
+    retryButtonColor: _angular_core.Signal<string | null>;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPlayerErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamPlayerErrorComponent, "et-stream-player-error", never, {}, {}, never, never, true, [{ directive: typeof StreamPlayerErrorDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type StreamPlayerLoadingConfig = {
+    /** Diameter of the loading spinner in px. */
+    spinnerDiameter: number;
+    /** Stroke width of the loading spinner in px. */
+    spinnerStrokeWidth: number;
+};
+declare const provideStreamPlayerLoadingConfig: (valueOverride?: Partial<StreamPlayerLoadingConfig> | undefined) => _angular_core.Provider[];
+declare const injectStreamPlayerLoadingConfig: {
+    (): StreamPlayerLoadingConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StreamPlayerLoadingConfig;
+    (options: _angular_core.InjectOptions): StreamPlayerLoadingConfig | null;
+};
+
+declare class StreamPlayerLoadingComponent {
+    protected config: _ethlete_components.StreamPlayerLoadingConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPlayerLoadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamPlayerLoadingComponent, "et-stream-player-loading", never, {}, {}, never, never, true, never>;
+}
+
+type StreamPipChromeConfig = {
+    /**
+     * Optional color key applied to built-in PiP titlebar controls.
+     * Uses the button's neutral fallback styling when omitted.
+     */
+    controlsColor?: string;
+};
+
+/**
+ * Unique id for a stream player entry.
+ * Convention: `'{platform}-{resourceId}'`, e.g. `'youtube-dQw4w9WgXcQ'`.
+ */
+type StreamPlayerId = string;
+/**
+ * Token provided by player-slot directives/components (e.g. `YoutubePlayerSlotDirective`).
+ * Yields a reactive signal of the current player id the slot is bound to, or `null` when
+ * the slot has not yet initialised. Consumed by `PipSlotPlaceholderComponent` to
+ * auto-detect whether its hosting slot currently has its player in PIP mode.
+ */
+declare const STREAM_SLOT_PLAYER_ID_TOKEN: InjectionToken<Signal<string | null>>;
+type StreamSlotEntry = {
+    /**
+     * The player id this slot wants to display (e.g. `'youtube-dQw4w9WgXcQ'`).
+     * Multiple slots may share the same id — priority resolves which one is shown.
+     */
+    playerId: StreamPlayerId;
+    /**
+     * Whether this slot is considered high priority.
+     * Among all slots registered for the same player id, `priority = true`
+     * wins. If multiple high-priority slots exist, the last-registered wins.
+     */
+    priority: boolean;
+    /**
+     * The host element of the slot — used as the unique key in the manager.
+     * The player element will be moved into this element when the slot is active.
+     */
+    element: HTMLElement;
+    /**
+     * Optional callback invoked when the user presses the "back" action inside the
+     * PIP chrome while this slot's player is in PIP mode.
+     */
+    onPipBack?: () => void;
+};
+type StreamPlayerEntry = {
+    /** The stream player id (e.g. `'youtube-dQw4w9WgXcQ'`). */
+    id: StreamPlayerId;
+    /** The live DOM element of the player (lives in the body container by default). */
+    element: HTMLElement;
+    /**
+     * Called by the manager when the player is no longer needed (no slot claims it
+     * and it is not in PIP mode). Use this to destroy the underlying component ref.
+     */
+    onDestroy?: () => void;
+    /** Reactive thumbnail URL from the player, forwarded to PIP entries. */
+    thumbnail?: Signal<string | null>;
+};
+type StreamPipEntry = {
+    /** The player that is currently in PIP mode. */
+    playerId: StreamPlayerId;
+    /**
+     * Optional callback invoked when the user presses the "back" action inside
+     * the PIP chrome for this PIP entry.
+     */
+    onBack?: () => void;
+    /** Reactive thumbnail URL for the player, used to render preview tiles. */
+    thumbnail?: Signal<string | null>;
+    /** The chrome component to use while this entry is active in PIP. */
+    pipChromeComponent?: Type<unknown>;
+    /** Appearance config for the active PIP chrome. */
+    pipChromeConfig?: StreamPipChromeConfig;
+    /**
+     * The player's natural aspect ratio (width / height).
+     * Used by the PIP chrome to resize the floating window and letterbox grid cells.
+     * Defaults to `16 / 9` if not provided.
+     */
+    aspectRatio: number;
+};
+type StreamManager = {
+    /** Returns true if at least one registered slot exists for the given player id. */
+    hasSlotFor(playerId: StreamPlayerId): boolean;
+    /**
+     * Registers a stream player element with the manager. The element is appended
+     * to the body-level manager container. If a slot is already waiting for this
+     * player id, the player is immediately moved into it (FLIP-animated).
+     */
+    registerPlayer(entry: StreamPlayerEntry): void;
+    /**
+     * Unregisters a player and removes its element from the DOM.
+     * Only call this when the player is not in PIP mode — PipManager handles
+     * clean-up for orphaned players when PIP is closed.
+     */
+    unregisterPlayer(playerId: StreamPlayerId): void;
+    /**
+     * Registers a slot. If a player with a matching id already exists, it is
+     * immediately moved into the best available slot (FLIP-animated).
+     */
+    registerSlot(entry: StreamSlotEntry): void;
+    /**
+     * Unregisters the slot identified by `element`. If the player was in this
+     * slot and is not currently in PIP mode, it is moved to the next best slot
+     * or fully unregistered when no slots remain. If the player IS in PIP mode,
+     * it stays in PIP until deactivated.
+     */
+    unregisterSlot(element: HTMLElement): void;
+    /**
+     * Re-keys a player entry from `oldId` to `newId` without touching the DOM.
+     * Use this when the video id changes on an existing slot (e.g. playlist navigation)
+     * so the manager's internal tracking stays consistent.
+     */
+    transferPlayer(oldId: StreamPlayerId, newId: StreamPlayerId): void;
+    /**
+     * Returns the live DOM element for `playerId`, or `null` if the player is not
+     * registered.
+     */
+    getPlayerElement(playerId: StreamPlayerId): HTMLElement | null;
+    /**
+     * Returns the full `StreamPlayerEntry` for `playerId`, or `null` if not
+     * registered. Useful for reading `thumbnail` and other metadata.
+     */
+    getPlayerEntry(playerId: StreamPlayerId): StreamPlayerEntry | null;
+    /**
+     * Returns the `StreamSlotEntry` associated with `element`, or `null` if not
+     * registered.
+     */
+    getSlot(element: HTMLElement): StreamSlotEntry | null;
+    /**
+     * Returns the highest-priority slot registered for `playerId`, or `null` if
+     * none exists.
+     */
+    resolveBestSlot(playerId: StreamPlayerId): StreamSlotEntry | null;
+    /**
+     * Moves the player element into the manager's body container.
+     * Used by PipManager for `pipActivate` and `parkPlayerElement`.
+     */
+    movePlayerToContainer(playerId: StreamPlayerId): void;
+    /**
+     * Marks the player as being in (or leaving) PIP mode. PipManager calls this
+     * to keep the stream manager's internal routing decisions (e.g. `reassignPlayer`,
+     * `unregisterSlot`) consistent with PIP state.
+     */
+    setPlayerInPip(playerId: StreamPlayerId, inPip: boolean): void;
+    /** Returns `true` if the player is currently in PIP mode. */
+    isPlayerInPip(playerId: StreamPlayerId): boolean;
+    /**
+     * Marks the player as currently running a PIP-exit animation so that
+     * `reassignPlayer` does not interfere while the animation is in flight.
+     */
+    setPlayerAnimatingOut(playerId: StreamPlayerId, animating: boolean): void;
+};
+type PipManager = {
+    /** Currently active PIP entries (one per player in PIP mode). */
+    readonly pips: Signal<StreamPipEntry[]>;
+    /** The chrome component to use for the currently active PIP chrome. */
+    readonly pipChromeComponent: Signal<Type<unknown> | null>;
+    /** Appearance config for the currently active PIP chrome. */
+    readonly pipChromeConfig: Signal<StreamPipChromeConfig>;
+    /**
+     * The player id of the currently featured (visible) pip in single mode.
+     * `null` when in grid mode or when no chrome is active.
+     * Set by the chrome so that `pipDeactivate` can automatically choose
+     * `scaleFadeIn` for non-featured pips instead of FLIP.
+     */
+    readonly featuredPipId: Signal<StreamPlayerId | null>;
+    /**
+     * Called by the chrome to keep `featuredPipId` in sync.
+     * Pass `null` when switching to grid mode or when no pip is active.
+     */
+    setFeaturedPip(playerId: StreamPlayerId | null): void;
+    /**
+     * Increments each time `notifyBackPressed` is called. Useful for reactive
+     * consumers (e.g. `viewChild` effects in slot placeholders) that need to
+     * re-check `consumeBackPulse` without polling.
+     */
+    readonly backPulseCounter: Signal<number>;
+    /**
+     * Records that the user pressed the "back" button in the PIP chrome for this
+     * player. The matching `etPipBringBack` button will consume this on its first
+     * render and play an attention-pulse + scroll-into-view.
+     */
+    notifyBackPressed(playerId: StreamPlayerId): void;
+    /**
+     * Returns true (and clears the flag) if `notifyBackPressed` was called for this
+     * player since the last consume. Used by `etPipBringBack` on init.
+     */
+    consumeBackPulse(playerId: StreamPlayerId): boolean;
+    /**
+     * Moves the player currently in the slot identified by `element` into the
+     * body PIP container, activating PIP mode.
+     */
+    pipActivate(element: HTMLElement, options?: {
+        onBack?: () => void;
+        aspectRatio?: number;
+        pipChromeComponent?: Type<unknown>;
+        pipChromeConfig?: StreamPipChromeConfig;
+    }): void;
+    /**
+     * Deactivates PIP for `playerId` and moves the player back to the best
+     * available slot (highest priority / last registered). If no slot exists, the
+     * player is fully unregistered.
+     *
+     * Pass `{ skipAnimation: true }` to skip the exit animation.
+     */
+    pipDeactivate(playerId: StreamPlayerId, options?: {
+        skipAnimation?: boolean;
+        animation?: 'flip' | 'scaleFadeIn';
+    }): void;
+    /**
+     * Consumes and returns the rect captured just before `pipActivate` moved the player
+     * to the body container. Returns `null` if no rect was stored.
+     * Deleted on first read so the enter animation only fires once.
+     */
+    getInitialRect(playerId: StreamPlayerId): DOMRect | null;
+    /**
+     * Moves the player element back to the manager's body container without
+     * changing PIP state. Call this before a pip-player component is destroyed so
+     * the iframe remains connected to the document and `moveBefore` can preserve
+     * its state when another pip-player picks it up immediately after.
+     */
+    parkPlayerElement(playerId: StreamPlayerId): void;
+};
+
+declare class PipBackDirective {
+    private chrome;
+    private tokenEntry;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
+    private pipManager;
+    back(event: Event): void;
+    private resolveEntry;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipBackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipBackDirective, "[etPipBack]", never, { "entry": { "alias": "entry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PipBringBackDirective {
+    private slotPlayerId;
+    private el;
+    private pipManager;
+    private intersection;
+    private pendingPulse;
+    constructor();
+    pulse(): void;
+    bringBack(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipBringBackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipBringBackDirective, "[etPipBringBack]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PipWindowParamsDirective {
+    aspectRatio: _angular_core.Signal<number>;
+    private config;
+    minWidth: _angular_core.WritableSignal<number>;
+    maxWidth: _angular_core.WritableSignal<number>;
+    minHeight: _angular_core.WritableSignal<number>;
+    maxHeight: _angular_core.WritableSignal<number>;
+    desiredSize: _angular_core.WritableSignal<number>;
+    collapsePeek: _angular_core.WritableSignal<number>;
+    viewportPadding: _angular_core.WritableSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipWindowParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipWindowParamsDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type PipWindowSize = {
+    w: Signal<number | null>;
+    h: Signal<number | null>;
+    get(): {
+        w: number | null;
+        h: number | null;
+    };
+    update(fn: (prev: {
+        w: number | null;
+        h: number | null;
+    }) => {
+        w: number | null;
+        h: number | null;
+    }): void;
+    setResize(w: number, h: number): void;
+    clearResize(): void;
+};
+
+type PipWindowPosition = {
+    position: Signal<string>;
+    positionInitialized: WritableSignal<boolean>;
+    isCollapsed: WritableSignal<boolean>;
+    isDragging: Signal<boolean>;
+    isResizing: Signal<boolean>;
+    initPosition(): void;
+    checkAndCollapse(): void;
+    snapToViewport(): void;
+    animateExit(callback: () => void): void;
+    startModeTransition(duration?: number): void;
+};
+
+declare class PipTitleBarTemplateDirective {
+    template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipTitleBarTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipTitleBarTemplateDirective, "ng-template[etPipTitleBar]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PipWindowComponent {
+    protected params: PipWindowParamsDirective;
+    private resizeHandles;
+    private titleBar;
+    protected titleBarTemplate: _angular_core.Signal<PipTitleBarTemplateDirective>;
+    protected dragHandle: _angular_core.Signal<_ethlete_core.DragHandleDirective>;
+    protected titleBarH: _angular_core.Signal<number>;
+    sizeState: PipWindowSize;
+    forcedTitleBar: _angular_core.WritableSignal<boolean>;
+    posState: PipWindowPosition;
+    readonly RESIZE_EDGES: ResizeEdge[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipWindowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PipWindowComponent, "et-pip-window", never, {}, {}, ["titleBarTemplate"], ["*"], true, [{ directive: typeof PipWindowParamsDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type PipCellData = {
+    /** The underlying pip entry. */
+    pip: StreamPipEntry;
+    /** Shortcut to `pip.playerId`. */
+    playerId: StreamPlayerId;
+    /** CSS grid column (1-based). */
+    col: number;
+    /** CSS grid row (1-based). */
+    row: number;
+    /** Horizontal exit direction offset (used for CSS `--et-cell-exit-h`). */
+    exitH: number;
+    /** Vertical exit direction offset (used for CSS `--et-cell-exit-v`). */
+    exitV: number;
+    /** Whether this is the currently featured pip. */
+    isFeatured: boolean;
+    /** `''` when this cell should be inert (single mode, non-featured), `null` otherwise. */
+    inertAttr: '' | null;
+    /** `''` when the player inside this cell should be inert, `null` otherwise. */
+    playerInertAttr: '' | null;
+    /** `'button'` in grid mode (cells are interactive), `null` in single mode. */
+    gridRole: 'button' | null;
+    /** `0` in grid mode, `null` in single mode. */
+    gridTabIndex: 0 | null;
+};
+type PipChromeState = {
+    featuredId: WritableSignal<StreamPlayerId | null>;
+    multiView: WritableSignal<boolean>;
+    isExiting: WritableSignal<boolean>;
+    allPips: Signal<StreamPipEntry[]>;
+    /** The currently featured pip, or `undefined` when none is active. */
+    featuredPip: Signal<StreamPipEntry | undefined>;
+    gridCols: Signal<number>;
+    gridRows: Signal<number>;
+    /** Per-cell layout data — iterate over this in `@for` instead of calling methods. */
+    cells: Signal<PipCellData[]>;
+    /** True when more than one pip is active (shows the grid-toggle button). */
+    hasMultiplePips: Signal<boolean>;
+    /** True when the back button should be visible. */
+    showBackButton: Signal<boolean>;
+    /** Accessible label for the grid toggle button. */
+    gridToggleLabel: Signal<string>;
+    /** The natural aspect ratio of the currently featured pip. */
+    featuredAspectRatio: Signal<number>;
+    /**
+     * The aspect ratio to apply to the pip window.
+     * In single mode: tracks the featured pip's ratio.
+     * In grid mode: locked to the ratio at the time grid was entered; unlocks when a pip is removed.
+     */
+    windowAspectRatio: Signal<number>;
+    setFeatured(playerId: StreamPlayerId): void;
+    /** Closes all pip entries, optionally animating via the pip window. */
+    close(event: Event, pipWindow: PipWindowComponent | undefined): void;
+    /** @internal Map from playerId to the host HTMLElement. Populated by PipCellDirective. */
+    cellElements: Map<StreamPlayerId, HTMLElement>;
+    /** @internal */
+    registerCell(playerId: StreamPlayerId, el: HTMLElement): void;
+    /** @internal */
+    unregisterCell(playerId: StreamPlayerId): void;
+};
+declare const createPipChromeState: () => PipChromeState;
+
+declare class PipCellDirective {
+    private chrome;
+    cell: _angular_core.InputSignal<PipCellData>;
+    constructor();
+    selectCell(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipCellDirective, "[etPipCell]", never, { "cell": { "alias": "etPipCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type PipChromeAnimationRefs = {
+    stageRef: Signal<ElementRef<HTMLElement> | undefined>;
+    gridBtnRef: Signal<ElementRef<HTMLElement> | undefined>;
+    pipWindowRef: Signal<PipWindowComponent | undefined>;
+};
+type PipChromeAnimations = {
+    enterMultiView(): void;
+    exitMultiView(): void;
+    toggleMultiView(): void;
+    selectCell(playerId: StreamPlayerId): void;
+};
+declare const createPipChromeAnimations: (state: PipChromeState, refs: PipChromeAnimationRefs) => PipChromeAnimations;
+
+type PipChromeRef = {
+    state: PipChromeState;
+    animations: PipChromeAnimations;
+};
+declare const PIP_CHROME_REF_TOKEN: InjectionToken<PipChromeRef>;
+
+declare class PipCloseDirective {
+    private chrome;
+    private pipWindow;
+    private tokenEntry;
+    entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
+    private pipManager;
+    close(event: Event): void;
+    private resolveEntry;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipCloseDirective, "[etPipClose]", never, { "entry": { "alias": "entry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PipCollapseOverlayDirective {
+    dragHandle: _angular_core.InputSignal<DragHandleDirective>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipCollapseOverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipCollapseOverlayDirective, "[etPipCollapseOverlay]", never, { "dragHandle": { "alias": "dragHandle"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const PIP_ENTRY_TOKEN: InjectionToken<Signal<StreamPipEntry>>;
+
+declare class PipGridToggleDirective {
+    protected chrome: _ethlete_components.PipChromeRef | null;
+    toggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipGridToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipGridToggleDirective, "[etPipGridToggle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PipStageDirective {
+    protected chrome: _ethlete_components.PipChromeRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipStageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipStageDirective, "[etPipStage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PipTitleBarDirective {
+    dragHandle: DragHandleDirective;
+    private dims;
+    titleBarH: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipTitleBarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PipTitleBarDirective, "[etPipTitleBar]", never, {}, {}, never, never, true, [{ directive: typeof _ethlete_core.DragHandleDirective; inputs: { "disabled": "dragDisabled"; }; outputs: { "dragTapped": "dragTapped"; "dragStarted": "dragStarted"; "dragMoved": "dragMoved"; "dragEnded": "dragEnded"; }; }]>;
+}
+
+declare const PIP_WINDOW_ASPECT_RATIO_TOKEN: InjectionToken<Signal<number>>;
+
+declare class StreamPipChromeComponent implements PipChromeRef {
+    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";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPipChromeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamPipChromeComponent, "et-stream-pip-chrome", never, {}, {}, never, never, true, never>;
+}
+
+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;
+    isReady: _angular_core.WritableSignal<boolean>;
+    resolvedEntry: _angular_core.Signal<StreamPipEntry>;
+    thumbnailUrl: _angular_core.Signal<string | null>;
+    isThumbVisible: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PipPlayerComponent, "et-pip-player", never, { "entry": { "alias": "entry"; "required": false; "isSignal": true; }; "showThumbnail": { "alias": "showThumbnail"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type PipSlotPlaceholderConfig = {
+    /** The message displayed in the placeholder overlay. */
+    message: string;
+    /** The label for the "back to player" button. */
+    backLabel: string;
+    /**
+     * The color theme name to apply on the back button.
+     * When set, applies `[color]` on the button element.
+     */
+    backButtonColor: string | null;
+    /**
+     * A function to transform text based on the current locale.
+     * Use `provideLocale()` to update the locale dynamically.
+     */
+    transformer: (text: string, locale: string) => string;
+};
+declare const providePipSlotPlaceholderConfig: (valueOverride?: Partial<PipSlotPlaceholderConfig> | undefined) => _angular_core.Provider[];
+declare const injectPipSlotPlaceholderConfig: {
+    (): PipSlotPlaceholderConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): PipSlotPlaceholderConfig;
+    (options: _angular_core.InjectOptions): PipSlotPlaceholderConfig | null;
+};
+
+declare class PipSlotPlaceholderComponent {
+    private slotPlayerId;
+    private parentSurfaceProvider;
+    private bringBackDir;
+    private pipManager;
+    private config;
+    private locale;
+    private surfaceThemes;
+    cardSurface: _angular_core.Signal<string | null>;
+    isInPip: _angular_core.Signal<boolean>;
+    message: _angular_core.Signal<string>;
+    backLabel: _angular_core.Signal<string>;
+    backButtonColor: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PipSlotPlaceholderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PipSlotPlaceholderComponent, "et-pip-slot-placeholder", never, {}, {}, never, never, true, never>;
+}
+
+declare const providePipChromeManager: () => _angular_core.Provider[];
+declare const injectPipChromeManager: {
+    (): void;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): void;
+    (options: _angular_core.InjectOptions): void | null;
+};
+
+declare const providePipManager: () => _angular_core.Provider[];
+declare const injectPipManager: {
+    (): PipManager;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): PipManager;
+    (options: _angular_core.InjectOptions): PipManager | null;
+};
+
+type StreamPlayerParams = {
+    readonly playerId: Signal<StreamPlayerId>;
+    /** Natural aspect ratio (width / height) of the player. Defaults to 16/9 if absent. */
+    readonly ASPECT_RATIO?: number;
+    createBindings(): Binding[];
+};
+declare const STREAM_PLAYER_PARAMS_TOKEN: InjectionToken<StreamPlayerParams>;
+declare const STREAM_PLAYER_COMPONENT_TOKEN: InjectionToken<Type<unknown>>;
+declare const STREAM_PLAYER_SLOT_TOKEN: InjectionToken<StreamPlayerSlotDirective>;
+declare class StreamPlayerSlotDirective {
+    private params;
+    private playerComponent;
+    private provideSurface;
+    private parentSurfaceProvider;
+    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
+    private surfaceThemes;
+    private styleManager;
+    private resolvedSurface;
+    slot: _ethlete_components.StreamPlayerSlotHandle;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamPlayerSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StreamPlayerSlotDirective, never, never, { "streamSlotPriority": { "alias": "streamSlotPriority"; "required": false; "isSignal": true; }; "streamSlotOnPipBack": { "alias": "streamSlotOnPipBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }]>;
+}
+
+declare class DailymotionPlayerParamsDirective implements StreamPlayerParams {
+    videoId: _angular_core.InputSignal<string>;
+    startTime: _angular_core.InputSignalWithTransform<number, unknown>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DailymotionPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DailymotionPlayerParamsDirective, never, never, { "videoId": { "alias": "videoId"; "required": true; "isSignal": true; }; "startTime": { "alias": "startTime"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StreamPlayerCapabilities = {
+    canPlay: boolean;
+    canPause: boolean;
+    canMute: boolean;
+    canSeek: boolean;
+    canGetDuration: boolean;
+    isLiveCapable: boolean;
+    hasThumbnail: boolean;
+};
+type StreamPlayerState = {
+    isReady: boolean;
+    isLoading: boolean;
+    error: null | unknown;
+    isPlaying: boolean;
+    isMuted: boolean;
+    isEnded: boolean;
+    /** null until the player is ready and duration is available */
+    duration: number | null;
+    /** null for live streams */
+    currentTime: number | null;
+};
+declare const DEFAULT_STREAM_PLAYER_STATE: StreamPlayerState;
+
+type StreamPlayer = {
+    /** Capabilities of the player, e.g. whether it supports seeking. */
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    /**
+     * Current state of the player, e.g. whether it's playing or paused.
+     * Note that the state depends on the capabilities - e.g. a player that doesn't support seeking will always have currentTime = null.
+     */
+    state: Signal<StreamPlayerState>;
+    /**
+     * A reactive thumbnail URL for this player, or `null` if unavailable.
+     * Only populated when `CAPABILITIES.hasThumbnail` is true.
+     */
+    thumbnail: Signal<string | null>;
+    /** Start playback. No-op if already playing or if canPlay capability is false. */
+    play(): void;
+    /** Pause playback. No-op if already paused or if canPause capability is false. */
+    pause(): void;
+    /** Mute playback. No-op if already muted or if canMute capability is false. */
+    mute(): void;
+    /** Unmute playback. No-op if already unmuted or if canMute capability is false. */
+    unmute(): void;
+    /** Seek to time in seconds. No-op if canSeek capability is false. */
+    seek(seconds: number): void;
+    /** Reload the player resource, e.g. after a script load failure. */
+    retry(): void;
+};
+declare const STREAM_PLAYER_TOKEN: InjectionToken<StreamPlayer>;
+
+declare const DAILYMOTION_PLAYER_TOKEN: InjectionToken<DailymotionPlayerDirective>;
+declare class DailymotionPlayerDirective implements StreamPlayer {
+    private platformId;
+    private params;
+    private el;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DailymotionPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DailymotionPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class DailymotionPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DailymotionPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DailymotionPlayerSlotComponent, "et-dailymotion-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof DailymotionPlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class DailymotionPlayerComponent {
+    player: DailymotionPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DailymotionPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DailymotionPlayerComponent, "et-dailymotion-player", never, {}, {}, never, never, true, [{ directive: typeof DailymotionPlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof DailymotionPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class FacebookPlayerParamsDirective implements StreamPlayerParams {
+    videoId: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacebookPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FacebookPlayerParamsDirective, never, never, { "videoId": { "alias": "videoId"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const FACEBOOK_PLAYER_TOKEN: InjectionToken<FacebookPlayerDirective>;
+declare class FacebookPlayerDirective implements StreamPlayer {
+    private platformId;
+    private document;
+    private params;
+    private el;
+    private scriptLoader;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(seconds: number): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacebookPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FacebookPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type FacebookVideoPlayer = {
+    play(): void;
+    pause(): void;
+    seek(seconds: number): void;
+    mute(): void;
+    unmute(): void;
+    isMuted(): boolean;
+    getCurrentPosition(): number;
+    getDuration(): number;
+    subscribe(event: 'startedPlaying' | 'paused' | 'finishedPlaying' | 'startedBuffering' | 'finishedBuffering', handler: () => void): {
+        release(): void;
+    };
+};
+type FacebookWindow = Window & {
+    FB: {
+        Event: {
+            subscribe(event: string, handler: (msg: unknown) => void): void;
+            unsubscribe(event: string, handler: (msg: unknown) => void): void;
+        };
+        XFBML: {
+            parse(element?: Element): void;
+        };
+    };
+    fbAsyncInit?: () => void;
+};
+
+declare class FacebookPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacebookPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FacebookPlayerSlotComponent, "et-facebook-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof FacebookPlayerParamsDirective; inputs: { "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class FacebookPlayerComponent {
+    player: FacebookPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacebookPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FacebookPlayerComponent, "et-facebook-player", never, {}, {}, never, never, true, [{ directive: typeof FacebookPlayerParamsDirective; inputs: { "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof FacebookPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class KickPlayerParamsDirective implements StreamPlayerParams {
+    channel: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    muted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KickPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KickPlayerParamsDirective, never, never, { "channel": { "alias": "channel"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "muted": { "alias": "muted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const KICK_PLAYER_TOKEN: InjectionToken<KickPlayerDirective>;
+declare class KickPlayerDirective implements StreamPlayer {
+    private platformId;
+    private document;
+    private params;
+    private el;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KickPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KickPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class KickPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KickPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KickPlayerSlotComponent, "et-kick-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof KickPlayerParamsDirective; inputs: { "channel": "channel"; "width": "width"; "height": "height"; "muted": "muted"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class KickPlayerComponent {
+    player: KickPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KickPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KickPlayerComponent, "et-kick-player", never, {}, {}, never, never, true, [{ directive: typeof KickPlayerParamsDirective; inputs: { "channel": "channel"; "width": "width"; "height": "height"; "muted": "muted"; }; outputs: {}; }, { directive: typeof KickPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SoopPlayerParamsDirective implements StreamPlayerParams {
+    userId: _angular_core.InputSignal<string | null>;
+    videoId: _angular_core.InputSignal<string | null>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SoopPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SoopPlayerParamsDirective, never, never, { "userId": { "alias": "userId"; "required": false; "isSignal": true; }; "videoId": { "alias": "videoId"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const SOOP_PLAYER_TOKEN: InjectionToken<SoopPlayerDirective>;
+declare class SoopPlayerDirective implements StreamPlayer {
+    private platformId;
+    private params;
+    private el;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SoopPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SoopPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class SoopPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SoopPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SoopPlayerSlotComponent, "et-soop-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof SoopPlayerParamsDirective; inputs: { "userId": "userId"; "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class SoopPlayerComponent {
+    player: SoopPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SoopPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SoopPlayerComponent, "et-soop-player", never, {}, {}, never, never, true, [{ directive: typeof SoopPlayerParamsDirective; inputs: { "userId": "userId"; "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof SoopPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TikTokPlayerParamsDirective implements StreamPlayerParams {
+    videoId: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    readonly ASPECT_RATIO: number;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TikTokPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TikTokPlayerParamsDirective, never, never, { "videoId": { "alias": "videoId"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TIKTOK_PLAYER_TOKEN: InjectionToken<TikTokPlayerDirective>;
+declare class TikTokPlayerDirective implements StreamPlayer {
+    private platformId;
+    private params;
+    private el;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private iframe;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(seconds: number): void;
+    retry(): void;
+    private post;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TikTokPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TikTokPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class TikTokPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TikTokPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TikTokPlayerSlotComponent, "et-tiktok-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof TikTokPlayerParamsDirective; inputs: { "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class TikTokPlayerComponent {
+    player: TikTokPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TikTokPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TikTokPlayerComponent, "et-tiktok-player", never, {}, {}, never, never, true, [{ directive: typeof TikTokPlayerParamsDirective; inputs: { "videoId": "videoId"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof TikTokPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TwitchPlayerParamsDirective implements StreamPlayerParams {
+    src: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    autoplay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    chat: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    startTime: _angular_core.InputSignalWithTransform<number, unknown>;
+    channel: _angular_core.Signal<string | null>;
+    video: _angular_core.Signal<string | null>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitchPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TwitchPlayerParamsDirective, never, never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "chat": { "alias": "chat"; "required": false; "isSignal": true; }; "startTime": { "alias": "startTime"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TWITCH_PLAYER_TOKEN: InjectionToken<TwitchPlayerDirective>;
+declare class TwitchPlayerDirective implements StreamPlayer {
+    private platformId;
+    private document;
+    private params;
+    private el;
+    private scriptLoader;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(seconds: number): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitchPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TwitchPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type TwitchEmbedPlayer = {
+    play(): void;
+    pause(): void;
+    setMuted(muted: boolean): void;
+    getMuted(): boolean;
+    seek(timestamp: number): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    addEventListener(event: string, callback: () => void): void;
+};
+type TwitchEmbed = {
+    getPlayer(): TwitchEmbedPlayer;
+    addEventListener(event: string, callback: () => void): void;
+};
+type TwitchEmbedConstructor = {
+    new (elementId: string | HTMLElement, options: {
+        width: string | number;
+        height: string | number;
+        channel?: string;
+        video?: string;
+        parent?: string[];
+        autoplay?: boolean;
+        muted?: boolean;
+        time?: string;
+        layout?: 'video-with-chat' | 'video';
+    }): TwitchEmbed;
+    READY: string;
+    PLAY: string;
+    PAUSE: string;
+    ENDED: string;
+};
+type TwitchWindow = Window & {
+    Twitch?: {
+        Embed: TwitchEmbedConstructor;
+    };
+};
+type TwitchPlayerParams = {
+    channel: string | null;
+    video: string | null;
+};
+
+declare class TwitchPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitchPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TwitchPlayerSlotComponent, "et-twitch-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof TwitchPlayerParamsDirective; inputs: { "src": "src"; "width": "width"; "height": "height"; "autoplay": "autoplay"; "chat": "chat"; "startTime": "startTime"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class TwitchPlayerComponent {
+    player: TwitchPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitchPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TwitchPlayerComponent, "et-twitch-player", never, {}, {}, never, never, true, [{ directive: typeof TwitchPlayerParamsDirective; inputs: { "src": "src"; "width": "width"; "height": "height"; "autoplay": "autoplay"; "chat": "chat"; "startTime": "startTime"; }; outputs: {}; }, { directive: typeof TwitchPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class VimeoPlayerParamsDirective implements StreamPlayerParams {
+    videoId: _angular_core.InputSignal<string | number>;
+    startTime: _angular_core.InputSignalWithTransform<number, unknown>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VimeoPlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<VimeoPlayerParamsDirective, never, never, { "videoId": { "alias": "videoId"; "required": true; "isSignal": true; }; "startTime": { "alias": "startTime"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const VIMEO_PLAYER_TOKEN: InjectionToken<VimeoPlayerDirective>;
+declare class VimeoPlayerDirective implements StreamPlayer {
+    private platformId;
+    private document;
+    private params;
+    private el;
+    private scriptLoader;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.WritableSignal<string | null>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(seconds: number): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VimeoPlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<VimeoPlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type VimeoWindow = Window & {
+    Vimeo: {
+        Player: new (element: HTMLElement | string, options: VimeoPlayerOptions) => VimeoPlayer;
+    };
+};
+type VimeoPlayerOptions = {
+    id?: number | string;
+    url?: string;
+    width?: number | string;
+    height?: number | string;
+    responsive?: boolean;
+    autopause?: boolean;
+    autoplay?: boolean;
+    muted?: boolean;
+    loop?: boolean;
+    controls?: boolean;
+};
+type VimeoPlayer = {
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    getMuted(): Promise<boolean>;
+    setMuted(muted: boolean): Promise<boolean>;
+    getCurrentTime(): Promise<number>;
+    getDuration(): Promise<number>;
+    setCurrentTime(seconds: number): Promise<number>;
+    on(event: string, callback: (data: unknown) => void): void;
+    off(event: string, callback?: (data: unknown) => void): void;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+};
+type VimeoPlaybackEvent = {
+    duration: number;
+    percent: number;
+    seconds: number;
+};
+type VimeoDurationChangeEvent = {
+    duration: number;
+};
+
+declare class VimeoPlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VimeoPlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VimeoPlayerSlotComponent, "et-vimeo-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof VimeoPlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class VimeoPlayerComponent {
+    player: VimeoPlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VimeoPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VimeoPlayerComponent, "et-vimeo-player", never, {}, {}, never, never, true, [{ directive: typeof VimeoPlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof VimeoPlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class YoutubePlayerParamsDirective implements StreamPlayerParams {
+    videoId: _angular_core.InputSignal<string>;
+    startTime: _angular_core.InputSignalWithTransform<number, unknown>;
+    width: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    playerId: _angular_core.Signal<string>;
+    createBindings(): _angular_core.Binding[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubePlayerParamsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YoutubePlayerParamsDirective, never, never, { "videoId": { "alias": "videoId"; "required": true; "isSignal": true; }; "startTime": { "alias": "startTime"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const YOUTUBE_PLAYER_SLOT_TOKEN: InjectionToken<YoutubePlayerSlotDirective>;
+declare class YoutubePlayerSlotDirective {
+    private params;
+    streamSlotPriority: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    streamSlotOnPipBack: _angular_core.InputSignal<(() => void) | undefined>;
+    slot: _ethlete_components.StreamPlayerSlotHandle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubePlayerSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YoutubePlayerSlotDirective, never, never, { "streamSlotPriority": { "alias": "streamSlotPriority"; "required": false; "isSignal": true; }; "streamSlotOnPipBack": { "alias": "streamSlotOnPipBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const YOUTUBE_PLAYER_TOKEN: InjectionToken<YoutubePlayerDirective>;
+declare class YoutubePlayerDirective implements StreamPlayer {
+    private platformId;
+    private document;
+    private params;
+    private el;
+    private scriptLoader;
+    private renderer;
+    readonly CAPABILITIES: StreamPlayerCapabilities;
+    state: _angular_core.WritableSignal<StreamPlayerState>;
+    thumbnail: _angular_core.Signal<string>;
+    private playerResource;
+    constructor();
+    play(): void;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    seek(seconds: number): void;
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubePlayerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YoutubePlayerDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type YtWindow = Window & {
+    YT: {
+        Player: new (elementOrId: HTMLElement | string, config: YtPlayerConfig) => YtPlayer;
+        PlayerState: {
+            UNSTARTED: -1;
+            ENDED: 0;
+            PLAYING: 1;
+            PAUSED: 2;
+            BUFFERING: 3;
+            CUED: 5;
+        };
+        ready(callback: () => void): void;
+    };
+    onYouTubeIframeAPIReady?: () => void;
+};
+type YtPlayerConfig = {
+    width?: string | number;
+    height?: string | number;
+    videoId?: string;
+    playerVars?: YtPlayerVars;
+    events?: {
+        onReady?: (event: YtPlayerEvent) => void;
+        onStateChange?: (event: YtPlayerStateChangeEvent) => void;
+        onError?: (event: YtPlayerErrorEvent) => void;
+    };
+};
+type YtPlayerVars = {
+    autoplay?: 0 | 1;
+    controls?: 0 | 1 | 2;
+    rel?: 0 | 1;
+    modestbranding?: 0 | 1;
+    start?: number;
+    mute?: 0 | 1;
+    enablejsapi?: 0 | 1;
+    origin?: string;
+    [key: string]: unknown;
+};
+type YtPlayer = {
+    playVideo(): void;
+    pauseVideo(): void;
+    stopVideo(): void;
+    seekTo(seconds: number, allowSeekAhead: boolean): void;
+    mute(): void;
+    unMute(): void;
+    isMuted(): boolean;
+    getPlayerState(): number;
+    getCurrentTime(): number;
+    getDuration(): number;
+    cueVideoById(videoId: string, startSeconds?: number): void;
+    loadVideoById(videoId: string, startSeconds?: number): void;
+    destroy(): void;
+};
+type YtPlayerEvent = {
+    target: YtPlayer;
+};
+type YtPlayerStateChangeEvent = {
+    target: YtPlayer;
+    data: number;
+};
+type YtPlayerErrorEvent = {
+    target: YtPlayer;
+    data: number;
+};
+
+declare class YoutubePlayerSlotComponent {
+    slotDirective: StreamPlayerSlotDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubePlayerSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YoutubePlayerSlotComponent, "et-youtube-player-slot", never, {}, {}, never, ["*"], true, [{ directive: typeof YoutubePlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof StreamPlayerSlotDirective; inputs: { "streamSlotPriority": "streamSlotPriority"; "streamSlotOnPipBack": "streamSlotOnPipBack"; }; outputs: {}; }]>;
+}
+
+declare class YoutubePlayerComponent {
+    player: YoutubePlayerDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubePlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YoutubePlayerComponent, "et-youtube-player", never, {}, {}, never, never, true, [{ directive: typeof YoutubePlayerParamsDirective; inputs: { "videoId": "videoId"; "startTime": "startTime"; "width": "width"; "height": "height"; }; outputs: {}; }, { directive: typeof YoutubePlayerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+type StreamPipWindowConfig = {
+    /** Minimum allowed width in px. @default 160 */
+    minWidth: number;
+    /** Maximum allowed width in px. @default 640 */
+    maxWidth: number;
+    /** Minimum allowed height in px. @default 90 */
+    minHeight: number;
+    /** Maximum allowed height in px. @default 360 */
+    maxHeight: number;
+    /** Desired initial size (longest side) in px. @default 400 */
+    desiredSize: number;
+    /** Height in px of the collapsed peek strip. @default 40 */
+    collapsePeek: number;
+    /** Minimum distance from the viewport edge in px. @default 8 */
+    viewportPadding: number;
+};
+/**
+ * Default pip window sizing / layout config.
+ * Spread this when you only want to override a subset of values:
+ * `{ ...DEFAULT_PIP_WINDOW_CONFIG, minWidth: 200 }`
+ */
+declare const DEFAULT_PIP_WINDOW_CONFIG: StreamPipWindowConfig;
+type StreamConfig = {
+    /**
+     * An optional consent component to automatically render around stream player components.
+     * When set, any stream player component will use this component as its consent gate.
+     *
+     * The component must have `[etStreamConsent]` as a `hostDirective` (or equivalent consent
+     * directive) so the stream player can read the consent state from the injector tree.
+     */
+    consentComponent: Type<unknown> | null;
+    /**
+     * An optional component to render inside every player slot as a PIP overlay.
+     */
+    pipSlotPlaceholderComponent: Type<unknown> | null;
+    /**
+     * An optional component shown while the player is initializing (before `isReady`).
+     * It is automatically destroyed once the player fires its ready event.
+     *
+     * @default `StreamPlayerLoadingComponent`
+     */
+    loadingComponent: Type<unknown>;
+    /**
+     * An optional component shown when the player fails to load (e.g. SDK blocked by an ad-blocker).
+     * It is automatically destroyed when the player is retried and hid again when retry succeeds.
+     *
+     * @default `StreamPlayerErrorComponent`
+     */
+    errorComponent: Type<unknown>;
+    /**
+     * The component rendered by `PipManager` when at least one pip is active.
+     * It is automatically created when the first pip activates and destroyed
+     * after the last pip exits (including exit animations).
+     *
+     * Supply a custom component that provides `PIP_CHROME_REF_TOKEN` to fully
+     * replace the built-in pip chrome UI.
+     *
+     * @default `StreamPipChromeComponent`
+     */
+    pipChromeComponent: Type<unknown>;
+    /**
+     * Sizing and layout defaults for the floating pip window.
+     * Override individual values by spreading `DEFAULT_PIP_WINDOW_CONFIG`:
+     * `{ ...DEFAULT_PIP_WINDOW_CONFIG, minWidth: 200 }`
+     *
+     * @default `DEFAULT_PIP_WINDOW_CONFIG`
+     */
+    pipWindow: StreamPipWindowConfig;
+    /**
+     * Appearance defaults for the built-in pip chrome UI.
+     * Custom `pipChromeComponent` implementations may ignore this entirely.
+     *
+     * @default `DEFAULT_PIP_CHROME_CONFIG`
+     */
+    pipChrome: StreamPipChromeConfig;
+};
+declare const injectStreamConfig: {
+    (): StreamConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StreamConfig;
+    (options: _angular_core.InjectOptions): StreamConfig | null;
+};
+declare const createStreamConfig: (valueOverride?: Partial<StreamConfig>) => {
+    pipWindow: {
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        desiredSize: number;
+        collapsePeek: number;
+        viewportPadding: number;
+    };
+    pipChrome: {
+        controlsColor?: string;
+    };
+    consentComponent: Type<unknown> | null;
+    pipSlotPlaceholderComponent: Type<unknown> | null;
+    loadingComponent: Type<unknown>;
+    errorComponent: Type<unknown>;
+    pipChromeComponent: Type<unknown>;
+};
+declare const provideStreamConfig: (valueOverride?: Partial<StreamConfig>) => _angular_core.Provider[];
+
+declare const provideStreamManager: () => _angular_core.Provider[];
+declare const injectStreamManager: {
+    (): StreamManager;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): StreamManager;
+    (options: _angular_core.InjectOptions): StreamManager | null;
+};
+
+type StreamPlayerSlotOptions = {
+    /** Reactive player id derived from platform-specific params (e.g. `computed(() => \`youtube-\${params.videoId()}\`)`). */
+    playerId: Signal<StreamPlayerId>;
+    /** Natural aspect ratio (width / height) of the player. Passed to PIP entries so the chrome can resize accordingly. */
+    aspectRatio: number;
+    /** Forwarded from the host directive's `streamSlotPriority` input. */
+    streamSlotPriority: Signal<boolean>;
+    /** Forwarded from the host directive's `streamSlotOnPipBack` input. */
+    streamSlotOnPipBack: Signal<(() => void) | undefined>;
+    /**
+     * Creates and returns the platform player `ComponentRef`.
+     * Receives the environment and element injectors so input bindings have the
+     * correct injection context.
+     */
+    createPlayer: (envInjector: EnvironmentInjector, elementInjector: Injector) => ComponentRef<unknown>;
+    /** Used in dev-mode warnings to identify which directive misconfigured consent. */
+    directiveName?: string;
+};
+type StreamPlayerSlotHandle = {
+    currentPlayerIdSignal: WritableSignal<StreamPlayerId | null>;
+    currentState: Signal<StreamPlayerState>;
+    pipActivate(onBack?: () => void): void;
+    pipDeactivate(): void;
+};
+declare const createStreamPlayerSlot: (options: StreamPlayerSlotOptions) => StreamPlayerSlotHandle;
+
+declare const injectStreamScriptLoader: {
+    (): {
+        load: (src: string) => Observable<void>;
+    };
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): {
+        load: (src: string) => Observable<void>;
+    };
+    (options: _angular_core.InjectOptions): {
+        load: (src: string) => Observable<void>;
+    } | null;
+};
+type StreamScriptLoader = ReturnType<typeof injectStreamScriptLoader>;
+
+declare const StreamImports: readonly [typeof StreamConsentComponent, typeof StreamConsentAcceptDirective, typeof StreamPlayerLoadingComponent, typeof StreamPlayerErrorComponent, typeof StreamPlayerErrorDirective, typeof YoutubePlayerComponent, typeof YoutubePlayerDirective, typeof YoutubePlayerParamsDirective, typeof YoutubePlayerSlotComponent, typeof StreamPlayerSlotDirective, typeof TwitchPlayerComponent, typeof TwitchPlayerDirective, typeof TwitchPlayerSlotComponent, typeof VimeoPlayerComponent, typeof VimeoPlayerDirective, typeof VimeoPlayerSlotComponent, typeof DailymotionPlayerComponent, typeof DailymotionPlayerDirective, typeof DailymotionPlayerSlotComponent, typeof KickPlayerComponent, typeof KickPlayerDirective, typeof KickPlayerSlotComponent, typeof FacebookPlayerComponent, typeof FacebookPlayerDirective, typeof FacebookPlayerSlotComponent, typeof TikTokPlayerComponent, typeof TikTokPlayerDirective, typeof TikTokPlayerSlotComponent, typeof SoopPlayerComponent, typeof SoopPlayerDirective, typeof SoopPlayerSlotComponent, typeof PipWindowComponent, typeof PipPlayerComponent, typeof PipCloseDirective, typeof PipBackDirective, typeof PipBringBackDirective, typeof PipGridToggleDirective];
+
+declare class TabBarTriggerDirective {
+    private elementRef;
+    private scrollable;
+    protected tabBar: _ethlete_components.TabBarDirective;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly ID: string;
+    justActivated: _angular_core.WritableSignal<boolean>;
+    isSelected: _angular_core.Signal<boolean>;
+    tabIndex: _angular_core.Signal<0 | -1>;
+    constructor();
+    /** @internal */
+    focus(): void;
+    /** @internal */
+    getElement(): HTMLElement;
+    handleClick(): void;
+    private scrollIntoView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabBarTriggerDirective, "[etTabBarTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.SurfaceInteractiveDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabBarUnderlineDirective {
+    private tabBar;
+    private trigger;
+    private elementRef;
+    isActive: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarUnderlineDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabBarUnderlineDirective, "[etTabBarUnderline]", never, {}, {}, never, never, true, never>;
+}
+
+declare const TAB_BAR_ORIENTATIONS: {
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};
+type TabBarOrientation = (typeof TAB_BAR_ORIENTATIONS)[keyof typeof TAB_BAR_ORIENTATIONS];
+declare const TAB_BAR_FITS: {
+    readonly CONTENT: "content";
+    readonly FILL: "fill";
+};
+type TabBarFit = (typeof TAB_BAR_FITS)[keyof typeof TAB_BAR_FITS];
+declare const TAB_BAR_VARIANTS: {
+    readonly PRIMARY: "primary";
+    readonly SECONDARY: "secondary";
+};
+type TabBarVariant = (typeof TAB_BAR_VARIANTS)[keyof typeof TAB_BAR_VARIANTS];
+
+declare class TabBarDirective {
+    private destroyRef;
+    orientation: _angular_core.InputSignal<TabBarOrientation>;
+    fit: _angular_core.InputSignal<TabBarFit>;
+    variant: _angular_core.InputSignal<TabBarVariant>;
+    divider: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    triggers: _angular_core.WritableSignal<TabBarTriggerDirective[]>;
+    /** @internal */
+    focusedIndex: _angular_core.WritableSignal<number>;
+    selectedIndex: _angular_core.WritableSignal<number>;
+    /** @internal */
+    readonly ID: string;
+    /** @internal */
+    lastActiveUnderlineElement: _angular_core.WritableSignal<HTMLElement | null>;
+    /** @internal */
+    animationsReady: _angular_core.WritableSignal<boolean>;
+    activeTrigger: _angular_core.Signal<TabBarTriggerDirective | null>;
+    constructor();
+    /** @internal */
+    registerTrigger(trigger: TabBarTriggerDirective): void;
+    /** @internal */
+    unregisterTrigger(trigger: TabBarTriggerDirective): void;
+    /** @internal */
+    selectTrigger(trigger: TabBarTriggerDirective): void;
+    handleKeydown(event: KeyboardEvent): void;
+    handleFocusout(event: FocusEvent): void;
+    private moveFocus;
+    private focusFirst;
+    private focusLast;
+    private activateFocused;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabBarDirective, "[etTabBar]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TAB_BAR_TOKEN: InjectionToken<TabBarDirective>;
+declare const TAB_BAR_TRIGGER_TOKEN: InjectionToken<TabBarTriggerDirective>;
+
+declare class NavTabLinkDirective {
+    private routerLinkActive;
+    private tabBar;
+    private destroyRef;
+    trigger: TabBarTriggerDirective;
+    private routerLinkIsActive;
+    isActive: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavTabLinkDirective, "[etNavTabLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NavTabsOutletDirective {
+    private tabBar;
+    readonly ID: string;
+    activeTriggerId: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsOutletDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavTabsOutletDirective, "[etNavTabsOutlet]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NavTabsDirective {
+    private routerEvent;
+    /** @internal */
+    navigationVersion: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavTabsDirective, "[etNavTabs]", never, {}, {}, never, never, true, never>;
+}
+
+declare const NAV_TABS_TOKEN: InjectionToken<NavTabsDirective>;
+
+declare class NavTabLinkComponent {
+    protected navTabLink: NavTabLinkDirective;
+    private elementRef;
+    protected handleSpace(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavTabLinkComponent, "a[et-nav-tab-link]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.RouterLink; inputs: { "routerLink": "et-nav-tab-link"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "state": "state"; "relativeTo": "relativeTo"; }; outputs: {}; }, { directive: typeof i1.RouterLinkActive; inputs: { "routerLinkActive": "routerLinkActive"; "routerLinkActiveOptions": "routerLinkActiveOptions"; "ariaCurrentWhenActive": "ariaCurrentWhenActive"; }; outputs: {}; }, { directive: typeof TabBarTriggerDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }, { directive: typeof NavTabLinkDirective; inputs: {}; outputs: {}; }, { directive: typeof FocusRingDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NavTabsOutletComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavTabsOutletComponent, "et-nav-tabs-outlet", never, {}, {}, never, ["*"], true, [{ directive: typeof NavTabsOutletDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const TAB_SIZES: {
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+};
+type TabSize = (typeof TAB_SIZES)[keyof typeof TAB_SIZES];
+
+declare class NavTabsComponent {
+    protected tabBar: TabBarDirective;
+    size: _angular_core.InputSignal<TabSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavTabsComponent, "et-nav-tabs", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof TabBarDirective; inputs: { "orientation": "orientation"; "fit": "fit"; "divider": "divider"; "variant": "variant"; }; outputs: {}; }, { directive: typeof NavTabsDirective; inputs: {}; outputs: {}; }]>;
+}
+
+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;
+};
+
+declare class TabPanelDirective {
+    private tabGroup;
+    triggerId: _angular_core.InputSignal<string | null>;
+    readonly ID: string;
+    isActive: _angular_core.Signal<boolean>;
+    isInactive: _angular_core.Signal<boolean>;
+    isHidden: _angular_core.Signal<boolean>;
+    shouldRender: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabPanelDirective, "[etTabPanel]", never, { "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabGroupDirective {
+    tabBar: TabBarDirective;
+    private elementRef;
+    preserveContent: _angular_core.InputSignal<boolean>;
+    selectedIndex: _angular_core.ModelSignal<number>;
+    sessionMemoryKey: _angular_core.InputSignal<string | null>;
+    private sessionMemoryAvailable;
+    /** @internal */
+    panels: _angular_core.WritableSignal<TabPanelDirective[]>;
+    restoredSessionMemoryKey: _angular_core.WritableSignal<string>;
+    constructor();
+    /** @internal */
+    registerPanel(panel: TabPanelDirective): void;
+    /** @internal */
+    unregisterPanel(panel: TabPanelDirective): void;
+    private resolveSelectedIndex;
+    private getSessionMemoryStorageKey;
+    private getResolvedSessionMemoryKey;
+    private getSessionMemory;
+    private parseSelectedIndex;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabGroupDirective, "[etTabGroup]", never, { "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "sessionMemoryKey": { "alias": "sessionMemoryKey"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, never, never, true, never>;
+}
+
+declare const TAB_GROUP_TOKEN: InjectionToken<TabGroupDirective>;
+declare const TAB_PANEL_TOKEN: InjectionToken<TabPanelDirective>;
+
+declare class TabTriggerDirective {
+    panelId: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabTriggerDirective, "[etTabTrigger]", never, { "panelId": { "alias": "panelId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabLabelDirective {
+    templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabLabelDirective, "[etTabLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TabComponent {
+    label: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | null>;
+    disabled: _angular_core.InputSignal<boolean>;
+    customLabel: _angular_core.Signal<TabLabelDirective | undefined>;
+    /** @internal */
+    implicitLabelRef: _angular_core.Signal<TemplateRef<unknown>>;
+    /** @internal */
+    contentRef: _angular_core.Signal<TemplateRef<unknown>>;
+    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>;
+}
+
+declare class TabGroupComponent {
+    protected tabGroup: TabGroupDirective;
+    size: _angular_core.InputSignal<TabSize>;
+    tabs: _angular_core.Signal<readonly TabComponent[]>;
+    protected triggerElements: _angular_core.Signal<TabBarTriggerDirective[]>;
+    /** @internal */
+    tabGroupId: string;
+    protected isPanelHidden(index: number): boolean;
+    protected shouldRenderPanel(index: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabGroupComponent, "et-tab-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["tabs"], never, true, [{ directive: typeof _ethlete_core.ProvideSurfaceDirective; inputs: { "etProvideSurface": "surface"; }; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }, { directive: typeof TabBarDirective; inputs: { "orientation": "orientation"; "fit": "fit"; "divider": "divider"; "variant": "variant"; }; outputs: {}; }, { directive: typeof TabGroupDirective; inputs: { "preserveContent": "preserveContent"; "selectedIndex": "selectedIndex"; "sessionMemoryKey": "sessionMemoryKey"; }; outputs: { "selectedIndexChange": "selectedIndexChange"; }; }]>;
+}
+
+declare const NavTabImports: readonly [typeof NavTabsComponent, typeof NavTabLinkComponent, typeof NavTabsOutletComponent];
+declare const TabImports: readonly [typeof TabGroupComponent, typeof TabComponent, typeof TabLabelDirective];
+
+type ToggletipContent = string | TemplateRef<unknown>;
+declare class ToggletipDirective {
+    private destroyRef;
+    private elementRef;
+    private colorProvider;
+    private surfaceProvider;
+    content: _angular_core.InputSignal<ToggletipContent | null>;
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    ariaLabelledBy: _angular_core.InputSignal<string | null>;
+    placement: _angular_core.InputSignal<Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    arrowPadding: _angular_core.InputSignal<Padding | null>;
+    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;
+    private contentId;
+    private resolvedAriaLabel;
+    private resolvedAriaDescribedBy;
+    constructor();
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    isOpen(): boolean;
+    controls(): string | null;
+    expanded(): boolean | null;
+    popupRole(): "dialog" | null;
+    private mountToggletip;
+    private closeOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggletipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggletipDirective, "[etToggletip]", ["etToggletip"], { "content": { "alias": "etToggletip"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "etToggletipAriaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "etToggletipAriaLabelledBy"; "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; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "disabled": { "alias": "etToggletipDisabled"; "required": false; "isSignal": true; }; "open": { "alias": "etToggletipOpen"; "required": false; "isSignal": true; }; }, { "open": "etToggletipOpenChange"; }, never, never, true, never>;
+}
+
+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: {}; }]>;
+}
+
+declare class ToggletipCloseDirective {
+    protected overlayRef: OverlayRef<ToggletipComponent, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggletipCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggletipCloseDirective, "[etToggletipClose]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ToggletipTriggerDirective {
+    private button;
+    private destroyRef;
+    private elementRef;
+    private toggletip;
+    constructor();
+    isOpen(): boolean;
+    pressedVariant(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggletipTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggletipTriggerDirective, "[etToggletipTrigger]", ["etToggletipTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare const TOGGLETIP_ERROR_CODES: {
+    readonly TEMPLATE_TOGGLETIP_REQUIRES_LABEL: 1500;
+    readonly TRIGGER_REQUIRES_BUTTON: 1501;
+    readonly TRIGGER_REQUIRES_TOGGLETIP: 1502;
+};
+
+declare const TOGGLETIP_IMPORTS: readonly [typeof ToggletipDirective, typeof ToggletipCloseDirective, typeof ToggletipTriggerDirective, typeof ToggletipComponent];
+
+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: {}; }]>;
+}
+
+type TooltipContent = string | TemplateRef<unknown>;
+declare class TooltipDirective {
+    private document;
+    private destroyRef;
+    private elementRef;
+    private colorProvider;
+    private surfaceProvider;
+    content: _angular_core.InputSignal<TooltipContent | null>;
+    ariaDescription: _angular_core.InputSignal<string | null>;
+    placement: _angular_core.InputSignal<Placement>;
+    fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
+    offset: _angular_core.InputSignal<OffsetOptions | null>;
+    arrowPadding: _angular_core.InputSignal<Padding | null>;
+    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;
+    private hasFocus;
+    private descriptionId;
+    private descriptionElement;
+    private accessibleDescription;
+    constructor();
+    show(): void;
+    hide(): void;
+    private setupHoverBehavior;
+    private setupFocusBehavior;
+    private syncHostDescription;
+    private syncDescriptionElement;
+    private removeDescriptionElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[etTooltip]", ["etTooltip"], { "content": { "alias": "etTooltip"; "required": false; "isSignal": true; }; "ariaDescription": { "alias": "etTooltipAriaDescription"; "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; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "etTooltipDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TOOLTIP_ERROR_CODES: {
+    readonly TEMPLATE_TOOLTIP_REQUIRES_DESCRIPTION: 1400;
+};
+
+declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
+
+export { ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BrandLoaderComponent, ButtonComponent, ButtonDirective, ButtonStylesDirective, CHECKBOX_IMPORTS, CHEVRON_ICON, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChoiceFieldComponent, DAILYMOTION_PLAYER_TOKEN, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_STREAM_PLAYER_STATE, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DescriptionComponent, FACEBOOK_PLAYER_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_TOKEN, GridComponent, GridDirective, GridDragDirective, GridImports, GridItemComponent, GridItemDirective, GridItemRef, GridResizeDirective, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, INPUT_IMPORTS, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LOCK_ICON, LabelDirective, NAV_TABS_TOKEN, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NavTabImports, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, OVERLAY_ERROR_CODES, OVERLAY_IMPORTS, OVERLAY_REF, OverlayAnchorDirective, OverlayDirective, OverlaySurfaceDirective, OverlayTriggerDirective, PENCIL_ICON, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLUS_ICON, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, RadioComponent, RadioGroupComponent, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SOOP_PLAYER_TOKEN, STREAM_CONSENT_TOKEN, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableErrorCode, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamImports, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_PANEL_TOKEN, TAB_SIZES, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabImports, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TextButtonComponent, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, createGridAdapter, createNotificationRef, createOverlayRef, createPipChromeAnimations, createPipChromeState, createStreamConfig, createStreamPlayerSlot, fromGridPosition, injectFormSupport, injectGridConfig, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, provideFormSupport, provideGridConfig, provideIcons, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlayManager, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, toGridPosition };
+export type { ButtonIconAlignment, ButtonSize, FacebookVideoPlayer, FacebookWindow, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, HintComponentBase, IconDefinition, InputTextAlignment, LabelDirectiveBase, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OverlayAutoFocusTarget, OverlayConfig, OverlayManager, OverlayMode, OverlayPositionStrategy, OverlayRef, OverlayRole, OverlaySurfaceContext, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectionListDirectiveBase, SelectionListItem, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, ToggletipContent, TooltipContent, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };