@ethlete/components 1.0.0-next.31 → 1.0.0-next.32

package/types/ethlete-components.d.ts

@@ -1,16 +1,16 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, ElementRef, InjectionToken, Type, InputSignal, Provider, Signal, WritableSignal, ViewContainerRef, Injector, Binding, StaticProvider, OnInit, ComponentRef, ModelSignal, OnDestroy, computed, EnvironmentInjector, ApplicationRef } from '@angular/core';
+import { TemplateRef, ElementRef, InjectionToken, Type, InputSignal, Signal, WritableSignal, Provider, ViewContainerRef, Injector, Binding, StaticProvider, OnInit, ComponentRef, ModelSignal, OnDestroy, computed, EnvironmentInjector, ApplicationRef } from '@angular/core';
 import * as _ethlete_components from '@ethlete/components';
 import { RoundStageStructureWithMatchesView, RoundStageStructureView, MatchListViewUnion, RoundType } from '@ethlete/types';
 import * as _angular_platform_browser from '@angular/platform-browser';
 import * as _ethlete_core from '@ethlete/core';
-import { ScrollObserverDirective, ScrollToElementOptions, AnimatableDirective, OverlayRuntimeCloseSource, OverlayRuntimeCloseGuard, OverlayRuntimePositionStrategy, OverlayRuntimeCloseEvent, OverlayRuntimeRef, Breakpoint, AnimatedLifecycleDirective, AnimatedSizeAxis, ColorTheme, ResizeEdge, DragHandleDirective, ResizeMoveEvent, CreateUnsavedChangesTrackerConfig, UnsavedChangesTrackerRef, AnimatedLifecycleState, OverlayRuntimeShiftOptions, AngularRenderer, OverlayRuntimeAnimationDelegate, ConsentHandler, DragMoveEvent, ProvideColorDirective } from '@ethlete/core';
+import { ScrollObserverDirective, ScrollToElementOptions, AnimatableDirective, OverlayRuntimeCloseSource, OverlayRuntimeCloseGuard, OverlayRuntimePositionStrategy, OverlayRuntimeCloseEvent, OverlayRuntimeRef, Breakpoint, AnimatedLifecycleDirective, AnimatedSizeAxis, ColorTheme, ResizeEdge, DragHandleDirective, ResizeMoveEvent, CreateUnsavedChangesTrackerConfig, UnsavedChangesTrackerRef, AnimatedLifecycleState, OverlayRuntimeShiftOptions, AngularRenderer, OverlayRuntimeAnimationDelegate, ConsentHandler, LabelsSource, DragMoveEvent, ProvideColorDirective } from '@ethlete/core';
 import { Locale } from 'date-fns';
-import { AnyQueryCreator, RequestArgs, QueryArgsOf, ResponseType, QueryErrorResponse, RequestError, QueryArgs, QueryCreator, AnyV2QueryCreator, AnyLegacyQueryCreator, QueryDataOf, QueryRepositoryEvent, QueryDevtoolsEntry, Query, QueryRepository, QueryRepositoryCacheEntry, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QuerySequenceStatus, AnyQuerySnapshot } from '@ethlete/query';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { FieldTree, ValidationError, FormValueControl, FormCheckboxControl, PathKind, SchemaPath, SchemaPathRules, validate } from '@angular/forms/signals';
+import { QueryFormFields, QueryFormSignals, QueryFormModel, AnyQueryCreator, RequestArgs, QueryArgsOf, ResponseType, QueryErrorResponse, RequestError, QueryArgs, QueryCreator, AnyV2QueryCreator, AnyLegacyQueryCreator, QueryDataOf, QueryRepositoryEvent, QueryDevtoolsEntry, Query, QueryRepository, QueryRepositoryCacheEntry, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QuerySequenceStatus, AnyQuerySnapshot, AnyV2Query, AnyLegacyQuery, AnyQueryCollection } from '@ethlete/query';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import * as _angular_forms_signals from '@angular/forms/signals';
-import { ValidationError, FormValueControl, FormCheckboxControl, PathKind, SchemaPath, SchemaPathRules, validate } from '@angular/forms/signals';
 import { Placement, OffsetOptions, Padding } from '@floating-ui/dom';
 import * as i1 from '@angular/router';
 
@@ -957,17 +957,17 @@ type BreadcrumbLabels = {
 };
 /** The built-in English labels. */
 declare const DEFAULT_BREADCRUMB_LABELS: BreadcrumbLabels;
-/** The label set every breadcrumb in this injector uses. @default DEFAULT_BREADCRUMB_LABELS */
-declare const BREADCRUMB_LABELS: InjectionToken<BreadcrumbLabels>;
 /**
- * Localize the breadcrumb's strings for everything below this injector. Partial — whatever you leave
- * out keeps its {@link DEFAULT_BREADCRUMB_LABELS} value.
+ * Localize the breadcrumb's strings for everything below this injector, and read the set in effect
+ * here as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_BREADCRUMB_LABELS}
+ * value. See {@link createLabels} for the shape, which every domain in this library shares.
  *
  * @example
  * provideBreadcrumbLabels({ navigation: 'Brotkrumen', overflow: 'Ausgeblendete Ebenen anzeigen' });
  */
-declare const provideBreadcrumbLabels: (labels: Partial<BreadcrumbLabels>) => Provider;
-declare const injectBreadcrumbLabels: () => BreadcrumbLabels;
+declare const provideBreadcrumbLabels: (labels: _ethlete_core.LabelsSource<BreadcrumbLabels>) => _angular_core.Provider;
+declare const injectBreadcrumbLabels: () => _angular_core.Signal<BreadcrumbLabels>;
+declare const BREADCRUMB_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<BreadcrumbLabels>>;
 
 /**
  * What the breadcrumb needs from a crumb — implemented by `etBreadcrumbItemTemplate`. It is a
@@ -1195,6 +1195,7 @@ declare class BreadcrumbSeparatorDirective {
  * </nav>
  */
 declare class BreadcrumbDirective {
+    private elementRef;
     private injectedLabels;
     /**
      * Move the middle crumbs into an overflow control when the trail doesn't fit. Turn it off to let the
@@ -1230,11 +1231,32 @@ declare class BreadcrumbDirective {
     private fullTrailWidth;
     /** The space the trail has, from the reactive host dimensions (not a `clientWidth` read at call time). */
     private availableWidth;
+    /**
+     * Whether the trail has been measured at least once. Sticky: a later trail change re-measures, but
+     * un-painting an already visible trail to do so would be a worse flash than the one this avoids.
+     */
+    private hasMeasured;
+    /**
+     * Nothing can be known about whether the trail fits before it has been measured, and rendering the full
+     * trail on that guess is the flash on load: the browser paints the overflowing trail, then swaps it for
+     * the collapsed one. While this is true the trail takes its space but isn't painted — see the
+     * `[data-measuring]` rule in the CSS. Only while collapsing is possible at all; otherwise there is no
+     * decision pending and nothing to wait for.
+     *
+     * @internal
+     */
+    isMeasuring: _angular_core.Signal<boolean>;
     /** Whether the middle crumbs are currently hidden behind the overflow control. */
     isCollapsed: _angular_core.Signal<boolean>;
     /** The slots to render: every crumb, or first + overflow + last once collapsed. */
     renderedItems: _angular_core.Signal<BreadcrumbRenderItem[]>;
     constructor();
+    /**
+     * Takes one pair of host measurements as the trail's state: that it has been measured, and — if the full
+     * trail didn't fit — how wide it wants to be. Zero width means the element isn't laid out yet (or sits in
+     * something hidden), which is not a measurement of anything.
+     */
+    private recordMeasurement;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BreadcrumbDirective, "[etBreadcrumb]", ["etBreadcrumb"], { "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "crumbs": { "alias": "crumbs"; "required": false; "isSignal": true; }; }, {}, ["declaredCrumbs", "separatorTemplate"], never, true, never>;
 }
@@ -1475,6 +1497,30 @@ declare const CALENDAR_ERROR_CODES: {
     readonly CELL_OUTSIDE_CALENDAR: 2901;
 };
 
+/**
+ * The strings the calendar renders or announces itself. Month and weekday **names** are not here — those
+ * come from the `DATE_LOCALE` date-fns locale, which is what a localized app provides.
+ */
+type CalendarLabels = {
+    /** Accessible label for the control that steps back a month. */
+    previousMonth: string;
+    /** Accessible label for the control that steps forward a month. */
+    nextMonth: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_CALENDAR_LABELS: CalendarLabels;
+/**
+ * Localize the calendar's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_CALENDAR_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideCalendarLabels({ previousMonth: 'Vorheriger Monat', nextMonth: 'Nächster Monat' });
+ */
+declare const provideCalendarLabels: (labels: _ethlete_core.LabelsSource<CalendarLabels>) => _angular_core.Provider;
+declare const injectCalendarLabels: () => _angular_core.Signal<CalendarLabels>;
+declare const CALENDAR_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<CalendarLabels>>;
+
 type CalendarWeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 
 type CalendarMode = 'single' | 'range';
@@ -1599,9 +1645,14 @@ declare class CalendarGridDirective {
 }
 
 declare class CalendarComponent {
+    private calendarLabels;
     protected calendar: CalendarDirective;
-    previousMonthLabel: _angular_core.InputSignal<string>;
-    nextMonthLabel: _angular_core.InputSignal<string>;
+    previousMonthLabel: _angular_core.InputSignal<string | null>;
+    nextMonthLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `previousMonthLabel`, else the domain's label set. */
+    protected resolvedPreviousMonthLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `nextMonthLabel`, else the domain's label set. */
+    protected resolvedNextMonthLabel: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "et-calendar", never, { "previousMonthLabel": { "alias": "previousMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof CalendarDirective; inputs: { "mode": "mode"; "min": "min"; "max": "max"; "dateFilter": "dateFilter"; "firstDayOfWeek": "firstDayOfWeek"; "locale": "locale"; "value": "value"; "rangeValue": "rangeValue"; "activeMonth": "activeMonth"; }; outputs: { "valueChange": "valueChange"; "rangeValueChange": "rangeValueChange"; "activeMonthChange": "activeMonthChange"; }; }]>;
 }
@@ -1644,17 +1695,17 @@ type CarouselLabels = {
 };
 /** The built-in English labels. */
 declare const DEFAULT_CAROUSEL_LABELS: CarouselLabels;
-/** The label set every carousel in this injector uses. @default DEFAULT_CAROUSEL_LABELS */
-declare const CAROUSEL_LABELS: InjectionToken<CarouselLabels>;
 /**
- * Localize the carousel's strings for everything below this injector. Partial — whatever you leave out
- * keeps its {@link DEFAULT_CAROUSEL_LABELS} value.
+ * Localize the carousel's strings for everything below this injector, and read the set in effect here
+ * as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_CAROUSEL_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
  *
  * @example
  * provideCarouselLabels({ previous: 'Vorheriges Bild', next: 'Nächstes Bild' });
  */
-declare const provideCarouselLabels: (labels: Partial<CarouselLabels>) => Provider;
-declare const injectCarouselLabels: () => CarouselLabels;
+declare const provideCarouselLabels: (labels: _ethlete_core.LabelsSource<CarouselLabels>) => _angular_core.Provider;
+declare const injectCarouselLabels: () => _angular_core.Signal<CarouselLabels>;
+declare const CAROUSEL_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<CarouselLabels>>;
 
 declare class ScrollableActiveChildDirective {
     private scrollable;
@@ -1735,7 +1786,7 @@ declare class ScrollableDirective {
     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>;
+    renderScrollbars: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @internal */
     scrollContainerRef: _angular_core.WritableSignal<ElementRef<HTMLElement> | null>;
     private childIntersectionsActivated;
@@ -1848,7 +1899,7 @@ declare class ScrollableDarkenDirective {
 
 declare class ScrollableDragDirective {
     private scrollable;
-    enabled: _angular_core.InputSignal<boolean>;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     cursorDragScrollState: {
         isDragging: _angular_core.Signal<boolean>;
         currentDragAmount: _angular_core.Signal<{
@@ -1866,7 +1917,7 @@ declare const SCROLLABLE_ERROR_CODES: {
 };
 
 declare class ScrollableIgnoreChildDirective {
-    enabled: _angular_core.InputSignal<boolean>;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     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>;
 }
@@ -1913,7 +1964,7 @@ declare class ScrollableNavigationDirective {
 declare class ScrollableSnapDirective {
     private scrollable;
     private document;
-    enabled: _angular_core.InputSignal<boolean>;
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     snapOrigin: _angular_core.InputSignal<ScrollableScrollOrigin>;
     /**
      * Whether a pointer is being held on the track right now.
@@ -2514,6 +2565,25 @@ declare class CarouselComponent {
 /** The carousel, its slide template, and the headless directives to build your own out of a scrollable. */
 declare const CAROUSEL_IMPORTS: readonly [typeof CarouselComponent, typeof CarouselSlideDirective, typeof CarouselItemDirective, typeof CarouselDirective, typeof CarouselAutoplayDirective, typeof CarouselPreviousDirective, typeof CarouselNextDirective, typeof CarouselPlayToggleDirective];
 
+/** The strings a chip renders itself. Its content is yours; the remove button is the chip's own. */
+type ChipLabels = {
+    /** Accessible label for a removable chip's remove button. */
+    remove: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_CHIP_LABELS: ChipLabels;
+/**
+ * Localize a chip's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_CHIP_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideChipLabels({ remove: 'Entfernen' });
+ */
+declare const provideChipLabels: (labels: _ethlete_core.LabelsSource<ChipLabels>) => _angular_core.Provider;
+declare const injectChipLabels: () => _angular_core.Signal<ChipLabels>;
+declare const CHIP_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<ChipLabels>>;
+
 declare const CHIP_ERROR_CODES: {
     readonly REMOVE_OUTSIDE_CHIP: 1100;
 };
@@ -2529,9 +2599,12 @@ declare class ChipDirective {
 }
 
 declare class ChipRemoveDirective {
+    private chipLabels;
     protected chip: ChipDirective | null;
     private elementRef;
-    removeLabel: _angular_core.InputSignal<string>;
+    removeLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `removeLabel`, else the domain's label set. */
+    resolvedRemoveLabel: _angular_core.Signal<string>;
     protected readonly IS_BUTTON: boolean;
     constructor();
     protected handleClick(event: Event): void;
@@ -2547,6 +2620,452 @@ declare class ChipComponent {
 
 declare const CHIP_IMPORTS: readonly [typeof ChipComponent, typeof ChipDirective, typeof ChipRemoveDirective];
 
+/**
+ * What the overlay closes with. `didUpdate: false` for a dismissal — the draft is thrown away and the page's
+ * filters are untouched.
+ */
+type FilterOverlayResult<TValue = unknown> = {
+    didUpdate: false;
+} | {
+    didUpdate: true;
+    value: TValue;
+};
+/**
+ * A live count of what the draft filters would return, so the submit button can say "Show 42 results" instead of
+ * "Apply" and the reader can tell before committing.
+ *
+ * Built by {@link filterOverlayPreviewFromQuery} for the usual case; hand-write it when the count comes from
+ * somewhere other than a single query (a local collection, an aggregate of several endpoints).
+ */
+type FilterOverlayPreview = {
+    /** A count is in flight. */
+    loading: Signal<boolean>;
+    /** The count could not be established. */
+    hasError: Signal<boolean>;
+    /** How many results the draft would produce, or `null` while that is unknown. */
+    totalHits: Signal<number | null>;
+};
+/** What the submit button says and whether it can be pressed. */
+type FilterOverlaySubmitButton = {
+    label: string;
+    disabled: boolean;
+};
+/** Everything the default submit-button resolver has to go on. */
+type FilterOverlaySubmitState = {
+    /** `null` when the overlay has no preview at all — then there is no count to wait for. */
+    totalHits: number | null;
+    loading: boolean;
+    hasError: boolean;
+    hasPreview: boolean;
+    /** Counts above this are reported as "more than N", since an exact number stops being useful. */
+    maxCountedHits: number;
+};
+
+/**
+ * Every string the filter overlay's submit button can show. The counted ones are functions, since the number is
+ * the point.
+ */
+type FilterOverlayLabels = {
+    /** While a count is in flight. */
+    loading: string;
+    /** When the count could not be established. */
+    error: string;
+    /** When the draft filters would return nothing. */
+    empty: string;
+    /** Exactly one result — worth its own string, because "Show 1 results" reads badly. */
+    one: string;
+    /** A known count. */
+    many: (totalHits: number) => string;
+    /** More results than are worth counting exactly. */
+    more: (maxCountedHits: number) => string;
+    /** When the overlay has no preview, so there is no count to report. */
+    apply: string;
+    /** The reset control. */
+    reset: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_FILTER_OVERLAY_LABELS: FilterOverlayLabels;
+/** The built-in German labels, used when the current locale is a German one. */
+declare const GERMAN_FILTER_OVERLAY_LABELS: FilterOverlayLabels;
+/** The label set for a locale. Anything other than English and German needs {@link provideFilterOverlayLabels}. */
+declare const filterOverlayLabelsForLocale: (locale: string) => FilterOverlayLabels;
+/**
+ * Localize the filter overlay's strings below this injector, and read the set in effect here as a signal.
+ * Partial — what you leave out keeps the value the current locale gives it. See {@link createLabels} for the
+ * shape, which every domain in this library shares.
+ *
+ * @example
+ * provideFilterOverlayLabels({ apply: 'Voir les résultats', reset: 'Réinitialiser' });
+ */
+declare const provideFilterOverlayLabels: (labels: _ethlete_core.LabelsSource<FilterOverlayLabels>) => _angular_core.Provider;
+declare const injectFilterOverlayLabels: () => _angular_core.Signal<FilterOverlayLabels>;
+declare const FILTER_OVERLAY_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<FilterOverlayLabels>>;
+/**
+ * The submit button, worked out from the preview.
+ *
+ * The button is deliberately the place the count appears: it is what the reader is about to press, so putting
+ * the consequence on it ("Show 42 results") lets them decide without applying first. It disables itself while a
+ * count is pending, when the count failed, and when the answer is zero — applying a filter that returns nothing
+ * is never what someone meant to do.
+ *
+ * An overlay with no preview has nothing to wait for and simply reads "Show results". cdk's version returned the
+ * *loading* state in that case, which left the button permanently disabled.
+ */
+declare const resolveFilterOverlaySubmitButton: (state: FilterOverlaySubmitState, labels: FilterOverlayLabels) => FilterOverlaySubmitButton;
+
+type FilterOverlayConfig<TFields extends QueryFormFields> = {
+    /**
+     * The page's filter state. The overlay never edits it directly — it edits a detached branch and writes the
+     * branch back on submit, which is what makes dismissing the overlay a discard.
+     */
+    queryForm: QueryFormSignals<TFields>;
+    /**
+     * A live count of what the draft would return, driving the submit button. Optional; without it the button just
+     * says "Show results". Use {@link filterOverlayPreviewFromQuery} for the single-query case.
+     */
+    preview?: (draftValue: Signal<QueryFormModel<TFields>>) => FilterOverlayPreview;
+    /**
+     * Counts above this are reported as "more than N" rather than exactly. Past a few hundred the precise number
+     * stops telling the reader anything they can act on. @default 250
+     */
+    maxCountedHits?: number;
+    /** Full control over the submit button's label and disabled state, replacing the built-in resolver. */
+    submitButton?: (state: FilterOverlaySubmitState, labels: FilterOverlayLabels) => FilterOverlaySubmitButton;
+};
+/**
+ * The draft's editing surface — a query form branch, described by its **value** shape rather than by its field
+ * map.
+ *
+ * That is deliberate and worth explaining: `QueryFieldDef<T>` is contravariant in `T` (it can hold a
+ * `valueToQueryParam: (value: T) => unknown`), so a concrete field map does *not* satisfy
+ * `Record<string, QueryFieldDef<unknown>>`. Inference copes, but an explicit type argument —
+ * `injectFilterOverlay<typeof MY_FIELDS>()` — cannot be written at all. Naming the value shape sidesteps it, and
+ * is what a consumer actually cares about. Structurally identical to `QueryFormBranch`.
+ */
+type FilterOverlayDraft<TValue> = {
+    /** The bindable signal-forms field tree: `draft.fields.search`. */
+    readonly fields: FieldTree<TValue>;
+    /** The draft's live value. */
+    readonly value: Signal<TValue>;
+    /** How many of the draft's *filters* are set — search, sort and pagination excluded. */
+    readonly activeFilterCount: Signal<number>;
+    setValue(value: TValue): void;
+    patchValue(value: Partial<TValue>): void;
+    resetFieldToDefault(key: keyof TValue): void;
+    resetAllFieldsToDefault(): void;
+};
+/** The value shape of a query form, for naming a {@link FilterOverlay} without naming its field map. */
+type FilterOverlayValueOf<TForm> = TForm extends {
+    value: Signal<infer TValue>;
+} ? TValue : never;
+type FilterOverlay<TValue = unknown> = {
+    /**
+     * The draft being edited — bind its `fields` to your controls. A detached clone of the page's query form: its
+     * own value, no URL writes, no reset graph, so nothing the reader does here affects the page until they submit.
+     */
+    draft: FilterOverlayDraft<TValue>;
+    /** The live count, if the overlay was configured with one. */
+    preview: FilterOverlayPreview | null;
+    /** What the submit button should say, and whether it can be pressed. */
+    submitButton: Signal<FilterOverlaySubmitButton>;
+    /** The strings in effect, after locale and any overrides. */
+    labels: Signal<FilterOverlayLabels>;
+    /** How many filters the draft has set, for a badge on the overlay's own controls. */
+    activeFilterCount: Signal<number>;
+    /** Whether the draft differs from the filters actually applied — what "unsaved changes" means here. */
+    hasChanges: Signal<boolean>;
+    /**
+     * Whether every field in the draft is still at its default, i.e. there is nothing for `reset()` to do.
+     *
+     * Not the same as `activeFilterCount() === 0`: the query form deliberately leaves navigation state (search,
+     * page, sort) out of that count, so a reader who has typed a search has nothing to show in a badge but plenty
+     * to reset.
+     */
+    isPristine: Signal<boolean>;
+    /** Write the draft back to the page's filters and close. */
+    submit: () => void;
+    /** Put every filter back to its default, without closing. */
+    reset: () => void;
+    /** Close without applying anything. */
+    discard: () => void;
+};
+/** The filter overlay provided for the current overlay component. Inject with `{ optional: true }` in a control
+ *  that may also be used outside one. */
+declare const FILTER_OVERLAY_TOKEN: InjectionToken<FilterOverlay<unknown>>;
+/**
+ * Provides the filter overlay for an overlay component: a draft of the page's filters that the reader edits, a
+ * live count of what those filters would return, and an explicit apply.
+ *
+ * The model is **edit a copy, then commit** — dismissing the overlay discards, which is what lets a filter panel
+ * be closed with Escape without consequence. It is cdk's `FilterOverlayService` rebuilt on the signals query
+ * form: no reactive-forms `FormGroup` to clone, no legacy query types, and `reset()` needs no configured defaults
+ * because the query form already knows them.
+ *
+ * @example
+ * export const FILTERS_OVERLAY = defineOverlay({ component: TeamFiltersComponent, … });
+ *
+ * @Component({
+ *   providers: [
+ *     provideFilterOverlay({
+ *       queryForm: injectTeamFilters(),
+ *       preview: filterOverlayPreviewFromQuery({
+ *         queryCreator: searchTeams,
+ *         args: (value) => ({ queryParams: { ...value, limit: 1 } }),
+ *       }),
+ *     }),
+ *   ],
+ * })
+ * export class TeamFiltersComponent {
+ *   protected filters = injectFilterOverlay();
+ * }
+ */
+declare const provideFilterOverlay: <TFields extends QueryFormFields>(config: FilterOverlayConfig<TFields>) => Provider[];
+/**
+ * The filter overlay provided above this component, typed to your filters' **value** shape:
+ *
+ * ```ts
+ * const createTeamFilters = () => createQueryForm({ fields: TEAM_FILTER_FIELDS });
+ * type TeamFilterValue = FilterOverlayValueOf<ReturnType<typeof createTeamFilters>>;
+ *
+ * protected filters = injectFilterOverlay<TeamFilterValue>();
+ * ```
+ */
+declare const injectFilterOverlay: <TValue = unknown>() => FilterOverlay<TValue>;
+
+declare const FILTER_OVERLAY_ERROR_CODES: {
+    readonly MISSING_FILTER_OVERLAY: 4200;
+};
+
+/**
+ * The usual live preview: one query, re-executed as the draft filters change, whose response says how many
+ * results they would return.
+ *
+ * A factory of a factory, because the query has to be created in the overlay's injection context — which only
+ * exists once the overlay is open. Pass the result as the config's `preview`; the filter overlay calls it with
+ * its draft value.
+ *
+ * Debouncing is the query form's job, not this one's: the branch's value is already the debounced one where a
+ * field asked for it, so typing in a search box does not fire a request per keystroke.
+ *
+ * @example
+ * providers: [
+ *   provideFilterOverlay({
+ *     queryForm: filters,
+ *     preview: filterOverlayPreviewFromQuery({
+ *       queryCreator: searchTeams,
+ *       args: (value) => ({ queryParams: { ...value, limit: 1 } }),
+ *       toTotalHits: (response) => response.totalHits,
+ *     }),
+ *   }),
+ * ]
+ */
+declare const filterOverlayPreviewFromQuery: <TCreator extends AnyQueryCreator, TValue>(config: {
+    /** The query creator to run. Created once, then re-executed as the draft changes. */
+    queryCreator: TCreator;
+    /**
+     * Builds the request args from the draft value. Return `null` to skip the request — for a draft that is not
+     * yet worth counting. Ask for as few rows as the endpoint allows: only the total is used.
+     */
+    args: (value: TValue) => RequestArgs<QueryArgsOf<TCreator>> | null;
+    /** Pulls the total out of the response. @default `response.totalHits` */
+    toTotalHits?: (response: ResponseType<QueryArgsOf<TCreator>>) => number;
+}) => (draftValue: Signal<TValue>) => FilterOverlayPreview;
+
+/**
+ * The submit button. Takes its label and disabled state from the live preview, so the button reads "Show 42
+ * results" rather than "Apply" and disables itself while the count is pending or zero.
+ *
+ * Put it on a real `<button>` — it is the primary action of a form and should behave like one.
+ *
+ * @example
+ * <button etFilterOverlaySubmit et-button></button>
+ */
+declare class FilterOverlaySubmitDirective {
+    protected filterOverlay: _ethlete_components.FilterOverlay<unknown> | null;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    /** The label the button should show. Rendered by `<et-filter-overlay-submit-label>`, or read it yourself. */
+    label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterOverlaySubmitDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilterOverlaySubmitDirective, "button[etFilterOverlaySubmit]", ["etFilterOverlaySubmit"], {}, {}, never, never, true, never>;
+}
+/**
+ * The reset control: puts every filter in the draft back to its default without closing the overlay, so the
+ * reader can start again without losing the panel.
+ *
+ * @example
+ * <button etFilterOverlayReset et-button variant="transparent">Reset</button>
+ */
+declare class FilterOverlayResetDirective {
+    protected filterOverlay: _ethlete_components.FilterOverlay<unknown> | null;
+    /**
+     * Nothing to reset when every field is already at its default. Deliberately not `activeFilterCount() === 0`:
+     * the query form leaves search and pagination out of that count, so a typed search would otherwise leave the
+     * reset button disabled with something still to clear.
+     */
+    protected isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterOverlayResetDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilterOverlayResetDirective, "button[etFilterOverlayReset]", ["etFilterOverlayReset"], {}, {}, never, never, true, never>;
+}
+
+declare const FILTER_OVERLAY_IMPORTS: readonly [typeof FilterOverlaySubmitDirective, typeof FilterOverlayResetDirective];
+
+declare const FLOATING_ACTION_ERROR_CODES: {
+    readonly PART_OUTSIDE_FLOATING_ACTION: 4100;
+    readonly MISSING_ANCHOR: 4101;
+};
+
+/**
+ * The trigger's home in the document flow — the element that stays put and keeps its space when the trigger
+ * detaches.
+ *
+ * It has to be a separate element from the trigger, and that is the whole trick: once the trigger is
+ * `position: fixed` it is *always* on screen, so observing it would immediately say "come back", then "go
+ * away", forever. The anchor never moves, so its visibility is a stable question. It is also what stops the
+ * layout jumping when the trigger leaves the flow.
+ *
+ * @example
+ * <div etFloatingActionAnchor>
+ *   <button etFloatingActionTrigger (click)="openFilters()">Filter</button>
+ * </div>
+ */
+declare class FloatingActionAnchorDirective {
+    /** @internal Where the anchor sits relative to the viewport — the input to the whole state machine. */
+    intersection: _angular_core.Signal<_ethlete_core.IntersectionObserverEntryWithDetails[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionAnchorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingActionAnchorDirective, "[etFloatingActionAnchor]", ["etFloatingActionAnchor"], {}, {}, never, never, true, never>;
+}
+/**
+ * The button (or link) itself. Carries the class the stylesheet moves, and nothing else — it stays the same
+ * element in the same place in the DOM whether it is inline or floating, so the tab order never changes and a
+ * screen reader never sees it appear or disappear.
+ *
+ * @example
+ * <button etFloatingActionTrigger (click)="openFilters()">Filter</button>
+ */
+declare class FloatingActionTriggerDirective {
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingActionTriggerDirective, "[etFloatingActionTrigger]", ["etFloatingActionTrigger"], {}, {}, never, never, true, never>;
+}
+/**
+ * The region the trigger acts on — the results list a filter button filters, the form a save bar saves.
+ *
+ * Optional, and what it buys is knowing when to *stop* offering the action: once this has scrolled past, the
+ * reader is somewhere else on the page and a pinned "Filter" button is just clutter. Without it the trigger
+ * floats for the rest of the page.
+ *
+ * @example
+ * <ul etFloatingActionScope>…</ul>
+ */
+declare class FloatingActionScopeDirective {
+    /** @internal Whether the region is still in play. */
+    intersection: _angular_core.Signal<_ethlete_core.IntersectionObserverEntryWithDetails[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionScopeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingActionScopeDirective, "[etFloatingActionScope]", ["etFloatingActionScope"], {}, {}, never, never, true, never>;
+}
+/**
+ * Where `scrollToTop()` scrolls to. Optional — without it the floating action's own element is the target,
+ * which is usually what you want.
+ *
+ * Put it somewhere else when the thing to return to isn't the top of the container: a filter panel that should
+ * scroll back to the first result rather than to the page heading above it.
+ *
+ * @example
+ * <h2 etFloatingActionTop>Results</h2>
+ */
+declare class FloatingActionTopDirective {
+    elementRef: ElementRef<HTMLElement>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionTopDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingActionTopDirective, "[etFloatingActionTop]", ["etFloatingActionTop"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Where the trigger is right now.
+ *
+ * - `inline` — its anchor is on screen, so it sits in the flow where it was written.
+ * - `floating` — the anchor has scrolled away but the region it acts on is still in play, so the trigger
+ *   detaches and pins itself to the corner.
+ * - `hidden` — the region has scrolled away too. There is nothing left to act on, so the trigger goes.
+ */
+declare const FLOATING_ACTION_STATES: {
+    readonly INLINE: "inline";
+    readonly FLOATING: "floating";
+    readonly HIDDEN: "hidden";
+};
+type FloatingActionState = (typeof FLOATING_ACTION_STATES)[keyof typeof FLOATING_ACTION_STATES];
+
+/**
+ * Keeps an action reachable after the reader has scrolled past it: the trigger sits in the flow where it was
+ * written, and pins itself to a corner of the viewport once its place in the page has scrolled away. A filter
+ * button above a long list, a "save changes" bar, a back-to-top.
+ *
+ * Ported from cdk's `rich-filter`, which was never about filtering — it renders no filter UI and imports nothing
+ * from `@ethlete/query`. This is that scroll-coordination pattern under a name that says what it does.
+ *
+ * **Why not CSS?** `position: sticky` can keep an element at an edge, but it cannot move it to a corner of the
+ * viewport, and it has no way to express "and the region this acts on is still on screen" — which is the part
+ * that stops a pinned button following the reader onto unrelated content. So the state comes from two
+ * intersection observers and CSS reacts to it.
+ *
+ * @example
+ * <div etFloatingAction>
+ *   <div etFloatingActionAnchor>
+ *     <button etFloatingActionTrigger (click)="openFilters()">Filter</button>
+ *   </div>
+ *
+ *   <ul etFloatingActionScope>
+ *     @for (result of results(); track result.id) { <li>…</li> }
+ *   </ul>
+ * </div>
+ */
+declare class FloatingActionDirective {
+    private elementRef;
+    private styleManager;
+    /**
+     * Keep the trigger in the flow, whatever the scroll position. The escape hatch for turning the behaviour off
+     * per breakpoint or per route without unwinding the markup — a desktop layout with the filters already in a
+     * sidebar has nothing to float. @default false
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** @internal Set by `etFloatingActionAnchor`. Its visibility is what drives the state. */
+    anchor: _angular_core.WritableSignal<FloatingActionAnchorDirective | null>;
+    /** @internal Set by `etFloatingActionTrigger`. */
+    trigger: _angular_core.WritableSignal<FloatingActionTriggerDirective | null>;
+    /** @internal Set by `etFloatingActionScope`; optional, and what bounds the action to a region. */
+    scope: _angular_core.WritableSignal<FloatingActionScopeDirective | null>;
+    /** @internal Set by `etFloatingActionTop`; optional override for `scrollToTop()`. */
+    top: _angular_core.WritableSignal<FloatingActionTopDirective | null>;
+    /**
+     * Where the trigger is: in the flow, pinned to the corner, or gone.
+     *
+     * Read off *above*, not merely "not visible": scrolling **down** past the anchor is what should pin the
+     * trigger, while an anchor still below the fold has simply not been reached and must stay put. The same goes
+     * for the scope — once it is above, the reader has left the region behind.
+     */
+    state: _angular_core.Signal<FloatingActionState>;
+    /** Whether the trigger is currently pinned to the viewport. */
+    isFloating: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Scroll back to the top of the region — what a filter button does after applying filters, so the reader sees
+     * the new first result rather than wherever they happened to be. Targets `[etFloatingActionTop]` if there is
+     * one, otherwise this element.
+     */
+    scrollToTop(options?: ScrollIntoViewOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingActionDirective, "[etFloatingAction]", ["etFloatingAction"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const FLOATING_ACTION_IMPORTS: readonly [typeof FloatingActionDirective, typeof FloatingActionAnchorDirective, typeof FloatingActionTriggerDirective, typeof FloatingActionScopeDirective, typeof FloatingActionTopDirective];
+
+declare const FLOATING_ACTION_TOKEN: InjectionToken<FloatingActionDirective>;
+
 declare const CASCADER_ERROR_CODES: {
     readonly MISSING_TRIGGER: 3300;
     readonly MISSING_SURFACE: 3301;
@@ -2615,8 +3134,11 @@ type FormFieldControl = {
     hasValue?: Signal<boolean>;
     /** True while the committed text can't be parsed (date/time/duration typed entry). */
     parseError?: Signal<boolean>;
-    /** User-facing message shown when `parseError` is set and there is no validation error. */
-    parseErrorMessage?: Signal<string>;
+    /**
+     * User-facing message shown when `parseError` is set and there is no validation error — the control's
+     * own `parseErrorMessage` input if it has one, else `DATE_TIME_LABELS`.
+     */
+    resolvedParseErrorMessage?: Signal<string>;
     /**
      * True when the control carries an author-supplied accessible name (its own `aria-label` /
      * `aria-labelledby`) independent of a projected `<et-label>`. The field's dev-time labelling
@@ -2624,19 +3146,46 @@ type FormFieldControl = {
      * `<et-label>` for labelling leave this unset.
      */
     hasCustomAccessibleName?: Signal<boolean>;
+    /**
+     * The control's current value. `et-counter` derives the length it displays from this — a string's
+     * `length`, an array's/set's element count, or whatever the counter's `lengthOf` says.
+     */
+    value?: Signal<unknown>;
+    /**
+     * The bound field's `maxLength()` limit. Signal forms binds this automatically into any control
+     * that declares a `maxLength` input, so `et-counter` gets its limit from the schema without the
+     * consumer repeating it. Note the controls deliberately do **not** forward it to the native
+     * `maxlength` attribute — hard-truncating input would stop the validator from ever reporting the
+     * over-limit error the counter is there to make visible.
+     */
+    maxLength?: Signal<number | undefined>;
+    /**
+     * True while an async validator is in flight for the bound field — bound automatically by signal
+     * forms into any control declaring a `pending` input. Surfaces as the field's busy state.
+     */
+    pending?: Signal<boolean>;
     activate(): void;
 };
 type HintComponentBase = object;
+/** A projected `et-counter`. The field only needs to know one is present to make room for it. */
+type CounterComponentBase = 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;
+    registerCounter(counter: CounterComponentBase): void;
+    unregisterCounter(counter: CounterComponentBase): void;
     unregisterLabel(label: LabelDirectiveBase): void;
     registeredControl: WritableSignal<FormFieldControl | null>;
     registeredHint: WritableSignal<HintComponentBase | null>;
+    registeredCounter: WritableSignal<CounterComponentBase | null>;
     registeredLabel: WritableSignal<LabelDirectiveBase | null>;
+    /** The registered control's value, for the counter to measure. */
+    controlValue: Signal<unknown>;
+    /** The bound field's schema `maxLength()`, when it has one. */
+    controlMaxLength: Signal<number | undefined>;
     /** The field's visible control frame — the box overlay-based controls anchor their panels to. */
     controlFrameElement: WritableSignal<HTMLElement | null>;
     activate(): void;
@@ -2651,6 +3200,8 @@ declare class FormFieldDirective implements FormFieldDirectiveBase {
     /** @internal */
     registeredHint: _angular_core.WritableSignal<object | null>;
     /** @internal */
+    registeredCounter: _angular_core.WritableSignal<object | null>;
+    /** @internal */
     registeredLabel: _angular_core.WritableSignal<LabelDirectiveBase | null>;
     /** Set by the form-field component; read by overlay-based controls (e.g. the select) as their anchor. */
     controlFrameElement: _angular_core.WritableSignal<HTMLElement | null>;
@@ -2664,6 +3215,12 @@ declare class FormFieldDirective implements FormFieldDirectiveBase {
     /** The control's parse-error message (shown when there's a parse error but no validation error). */
     parseErrorMessage: _angular_core.Signal<string | null>;
     controlType: _angular_core.Signal<_ethlete_components.FormFieldControlType>;
+    /** The registered control's value — the counter measures this. */
+    controlValue: _angular_core.Signal<unknown>;
+    /** The bound field's schema `maxLength()`, when signal forms bound one into the control. */
+    controlMaxLength: _angular_core.Signal<number | undefined>;
+    /** Whether an async validator is currently in flight for the bound field. */
+    isPending: _angular_core.Signal<boolean>;
     focused: _angular_core.Signal<boolean>;
     /** Whether the registered control's popup (picker/select/cascader panel) is open. */
     expanded: _angular_core.Signal<boolean>;
@@ -2685,6 +3242,10 @@ declare class FormFieldDirective implements FormFieldDirectiveBase {
     /** @internal */
     unregisterHint(hint: HintComponentBase): void;
     /** @internal */
+    registerCounter(counter: CounterComponentBase): void;
+    /** @internal */
+    unregisterCounter(counter: CounterComponentBase): void;
+    /** @internal */
     unregisterLabel(label: LabelDirectiveBase): void;
     activate(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldDirective, never>;
@@ -2933,9 +3494,17 @@ type OverlayStrategyBreakpoint = {
     /** Overlay strategy to be applied when the breakpoint is active. */
     strategy: OverlayStrategy;
 };
+/** A drag direction expressed in physical terms. Unaffected by the writing direction. */
+type OverlayDragToDismissPhysicalDirection = 'to-top' | 'to-bottom' | 'to-left' | 'to-right';
+/**
+ * A drag direction. The logical values (`to-inline-start`/`to-inline-end`) are resolved to their
+ * physical counterpart when the gesture is set up, using the overlay container's computed
+ * `direction` — so they follow the writing direction like the logical position strategies do.
+ */
+type OverlayDragToDismissDirection = OverlayDragToDismissPhysicalDirection | 'to-inline-start' | 'to-inline-end';
 type OverlayDragToDismissConfig = {
     /** Direction in which the overlay can be dragged. */
-    direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';
+    direction: OverlayDragToDismissDirection;
     /**
      * The minimum distance in pixels that the user must swipe to dismiss the overlay.
      *
@@ -2945,9 +3514,27 @@ type OverlayDragToDismissConfig = {
     /**
      * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.
      *
+     * Doubles as the flick threshold when `snapPoints` are set: a release at or above it advances one
+     * snap point in the direction of the flick.
+     *
      * @default 150 // 150px/s
      */
     minVelocityToDismiss?: number;
+    /**
+     * Resting positions the overlay can be dragged between, as fractions of its own size along the
+     * dismiss axis — `0` is fully open, `0.5` is dragged halfway out. The docked position is always
+     * available whether or not it is listed, and values outside `[0, 1)` are ignored.
+     *
+     * With snap points set, a flick advances one point in its own direction and a slow release settles
+     * at the nearest one; either running past the last point dismisses the overlay. Leaving this unset
+     * keeps the plain two-state behavior driven by `minDistanceToDismiss`/`minVelocityToDismiss`.
+     *
+     * The overlay stays its full size at every snap point — only its offset changes. Content that
+     * should reflow or scroll differently at a partial position is the consumer's concern.
+     *
+     * @default undefined // no intermediate resting positions
+     */
+    snapPoints?: number[];
 };
 type OverlayBreakpointConfig = {
     /** Min-width of the overlay. If a number is provided, assumes pixel units. */
@@ -3073,13 +3660,13 @@ declare class OverlayDirective {
     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>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disableClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
     autoFocus: _angular_core.InputSignal<string | false | undefined>;
-    restoreFocus: _angular_core.InputSignal<boolean>;
+    restoreFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
     hasBackdrop: _angular_core.InputSignal<boolean | undefined>;
-    closeOnEscape: _angular_core.InputSignal<boolean>;
-    closeOnOutsidePointer: _angular_core.InputSignal<boolean>;
+    closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnOutsidePointer: _angular_core.InputSignalWithTransform<boolean, unknown>;
     hostClass: _angular_core.InputSignal<string | string[] | undefined>;
     backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
     panelClass: _angular_core.InputSignal<string | string[] | undefined>;
@@ -3087,11 +3674,11 @@ declare class OverlayDirective {
     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>;
+    autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    shift: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoHide: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoCloseIfReferenceHidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    mirrorWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @internal */
     registeredAnchor: _angular_core.WritableSignal<OverlayAnchorDirective | null>;
     /** @internal */
@@ -3254,6 +3841,7 @@ declare const registerSingleton: <T>(target: WritableSignal<T | null> | null | u
  * only surfaces inherited inputs/outputs from a decorated base.
  */
 declare abstract class TextFieldControlDirective implements FormFieldControl {
+    private formFieldLabels;
     private formField;
     touched: _angular_core.ModelSignal<boolean>;
     /**
@@ -3264,14 +3852,28 @@ declare abstract class TextFieldControlDirective implements FormFieldControl {
      */
     mixed: _angular_core.ModelSignal<boolean>;
     /** Placeholder text shown while `mixed` is set — overrides the consumer placeholder. */
-    mixedLabel: _angular_core.InputSignal<string>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    hidden: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
     required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
+    /**
+     * The bound field's `maxLength()` limit, bound automatically by signal forms because this input
+     * exists — so `<et-counter />` needs no `[max]` for a schema-validated field.
+     *
+     * Deliberately **not** forwarded to the native `maxlength` attribute: hard-truncating typed input
+     * would stop the validator from ever reporting the over-limit error the counter exists to surface.
+     * Set `maxlength` yourself on the control if you want the browser to clamp instead.
+     */
+    maxLength: _angular_core.InputSignal<number | undefined>;
+    /**
+     * True while an async validator is in flight for the bound field — bound automatically by signal
+     * forms because this input exists. The field shell surfaces it as its busy state.
+     */
+    pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Author-supplied accessible name, forwarded onto the native control. Use this (or an
      * `<et-label>`) when the field has no visible label — a placeholder is not an accessible name.
@@ -3282,6 +3884,8 @@ declare abstract class TextFieldControlDirective implements FormFieldControl {
      * id of a projected `<et-label>`.
      */
     ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: Signal<string>;
     shouldDisplayError: Signal<boolean>;
     describedBy: _angular_core.WritableSignal<string | null>;
     focused: _angular_core.WritableSignal<boolean>;
@@ -3299,7 +3903,7 @@ declare abstract class TextFieldControlDirective implements FormFieldControl {
     constructor();
     activate(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextFieldControlDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextFieldControlDirective, never, never, { "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "required": false; "isSignal": true; }; "mixedLabel": { "alias": "mixedLabel"; "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; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "mixed": "mixedChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextFieldControlDirective, never, never, { "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "required": false; "isSignal": true; }; "mixedLabel": { "alias": "mixedLabel"; "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; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "mixed": "mixedChange"; }, never, never, true, never>;
 }
 
 /** A single entry in a cascader's hierarchy. `T` is the consumer's value type. */
@@ -3414,6 +4018,7 @@ type CascaderSearchLike = {
     appendCharacter(character: string): void;
 };
 declare class CascaderDirective<T = unknown> implements FormValueControl<T | T[] | null>, FormFieldControl {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     private document;
@@ -3424,17 +4029,17 @@ declare class CascaderDirective<T = unknown> implements FormValueControl<T | T[]
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
     open: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Multi-select: node activations toggle values instead of committing-and-closing. */
     multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    invalid: _angular_core.InputSignal<boolean>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /** Trigger text shown while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /** The hierarchical source browsed by the cascader. Required. */
     dataSource: _angular_core.InputSignal<CascaderDataSource<T> | null>;
     /** Whether only leaves (`'leaf'`, default) or any node (`'any'`) can be committed as the value. */
@@ -3448,7 +4053,7 @@ declare class CascaderDirective<T = unknown> implements FormValueControl<T | T[]
      */
     toErrorMessage: _angular_core.InputSignal<(error: unknown) => string>;
     /** Whether the overlay panel mirrors the anchor's width (off — columns size themselves). */
-    mirrorPanelWidth: _angular_core.InputSignal<boolean>;
+    mirrorPanelWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * How many columns the browse view shows side by side before older levels collapse into the
      * breadcrumb row (min 1). Deep hierarchies would otherwise grow the panel a column-width per
@@ -3457,6 +4062,8 @@ declare class CascaderDirective<T = unknown> implements FormValueControl<T | T[]
     maxVisibleColumns: _angular_core.InputSignalWithTransform<number, number>;
     afterOpen: _angular_core.OutputEmitterRef<void>;
     afterClose: _angular_core.OutputEmitterRef<void>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: Signal<string>;
     shouldDisplayError: Signal<boolean>;
     /** The committed values, normalized to an array (one entry in single mode, empty for no value). */
     values: Signal<T[]>;
@@ -3650,6 +4257,7 @@ type CascaderNodeSignal<T> = Signal<CascaderNode<T> | null>;
 
 /** One level of the hierarchy — a `role="group"` of tree items. Nodes read their level from it. */
 declare class CascaderColumnDirective {
+    private cascaderLabels;
     cascader: CascaderDirective<any> | null;
     private destroyRef;
     /** The column's zero-based level — column 0 shows the root. */
@@ -3826,6 +4434,37 @@ type CascaderFromQueryConfig<TCreator extends AnyQueryCreator, TValue, TSearchCr
  */
 declare const cascaderFromQuery: <TCreator extends AnyQueryCreator, TValue, TSearchCreator extends AnyQueryCreator = TCreator>(config: CascaderFromQueryConfig<TCreator, TValue, TSearchCreator>) => CascaderDataSource<TValue>;
 
+/** The strings the cascader's panel renders itself — its search field and the step back up a level. */
+type CascaderLabels = {
+    /** Shown while a level or a search is being fetched. */
+    loading: string;
+    /** Shown when a search matched nothing. */
+    noMatches: string;
+    /** Shown when a level has no options. */
+    noOptions: string;
+    /** The action that re-runs a failed search or level fetch. */
+    retry: string;
+    /** Heading for the root column, which has no parent option to name it. */
+    options: string;
+    /** Accessible label for the control that returns to the parent level. */
+    back: string;
+    /** Placeholder for the panel's search field. */
+    search: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_CASCADER_LABELS: CascaderLabels;
+/**
+ * Localize the cascader's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_CASCADER_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideCascaderLabels({ back: 'Zurück', search: 'Suchen' });
+ */
+declare const provideCascaderLabels: (labels: _ethlete_core.LabelsSource<CascaderLabels>) => _angular_core.Provider;
+declare const injectCascaderLabels: () => _angular_core.Signal<CascaderLabels>;
+declare const CASCADER_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<CascaderLabels>>;
+
 /**
  * The overlay-hosted panel surface: re-applies color/surface context (the pane is detached
  * from the trigger's DOM), tracks whether focus is inside (gating the roving-focus moves),
@@ -3850,14 +4489,22 @@ declare class CascaderPanelComponent {
 }
 
 declare class CascaderComponent {
+    protected cascaderLabels: _angular_core.Signal<_ethlete_components.CascaderLabels>;
+    private formFieldLabels;
     protected cascader: CascaderDirective<unknown>;
     protected errorColorTheme: _ethlete_core.ColorTheme;
     /** Shows a clear (×) control while a value is selected. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
-    backLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    backLabel: _angular_core.InputSignal<string | null>;
     /** Placeholder of the panel's search input (shown when the data source has a `search` hook). */
-    searchPlaceholder: _angular_core.InputSignal<string>;
+    searchPlaceholder: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `backLabel`, else the domain's label set. */
+    protected resolvedBackLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `searchPlaceholder`, else the domain's label set. */
+    protected resolvedSearchPlaceholder: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected handleClearClick(event: Event): void;
     protected resultDisabled(path: CascaderNode<unknown>[]): boolean;
@@ -3881,12 +4528,12 @@ declare class CheckboxDirective implements FormCheckboxControl, FormFieldControl
     checked: _angular_core.ModelSignal<boolean>;
     indeterminate: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** View-only: keeps the normal look and focusability but blocks toggling (unlike `disabled`). */
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     ariaChecked: _angular_core.Signal<boolean | "mixed">;
     shouldDisplayError: _angular_core.Signal<boolean>;
@@ -3942,6 +4589,12 @@ declare const FORM_FIELD_SIZES: {
 };
 type FormFieldSize = (typeof FORM_FIELD_SIZES)[keyof typeof FORM_FIELD_SIZES];
 
+/** How a choice field presents itself. See {@link ChoiceFieldComponent.variant}. */
+declare const CHOICE_FIELD_VARIANTS: {
+    readonly PLAIN: "plain";
+    readonly CARD: "card";
+};
+type ChoiceFieldVariant = (typeof CHOICE_FIELD_VARIANTS)[keyof typeof CHOICE_FIELD_VARIANTS];
 declare class ChoiceFieldComponent {
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
@@ -3961,6 +4614,12 @@ declare class ChoiceFieldComponent {
         supportHeight: _angular_core.Signal<number>;
     };
     size: _angular_core.InputSignal<FormFieldSize>;
+    /**
+     * `'card'` turns the row into a full-width clickable panel with the label leading and the control trailing — for
+     * a short list of consequential options where each wants room for a hint. Works for whichever control is
+     * projected, so a checkbox and a switch get the same preset. @default 'plain'
+     */
+    variant: _angular_core.InputSignal<ChoiceFieldVariant>;
     private errorContentRef;
     private hintContentRef;
     private errorAnimatableRef;
@@ -3970,7 +4629,7 @@ declare class ChoiceFieldComponent {
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChoiceFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChoiceFieldComponent, "et-choice-field", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-label", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChoiceFieldComponent, "et-choice-field", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-label", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class HintComponent implements HintComponentBase {
@@ -4031,7 +4690,7 @@ declare class ColorInputComponent {
      */
     protected blockWhenReadonly(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorInputComponent, "et-color-input", never, {}, {}, never, never, true, [{ directive: typeof ColorInputDirective; inputs: { "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorInputComponent, "et-color-input", never, {}, {}, never, never, true, [{ directive: typeof ColorInputDirective; inputs: { "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare const COLOR_INPUT_IMPORTS: readonly [typeof ColorInputComponent, typeof ColorInputDirective];
@@ -4119,6 +4778,7 @@ type DatePickerInputFieldBase = {
  * decorated base.
  */
 declare abstract class DatePickerInputDirective implements FormValueControl<string | null>, FormFieldControl, DatePickerHost {
+    private formFieldLabels;
     private formField;
     private document;
     defaultLocale: Locale | null;
@@ -4141,11 +4801,11 @@ declare abstract class DatePickerInputDirective implements FormValueControl<stri
     /** View state for a field whose source values disagree (bulk edit). The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /**
@@ -4153,7 +4813,7 @@ declare abstract class DatePickerInputDirective implements FormValueControl<stri
      * date field cannot render arbitrary text, so the field stays empty and the
      * label shows through the placeholder slot; it never enters the form value.
      */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /** date-fns format of the string value. Defaults to the control's format token. */
     valueFormat: _angular_core.InputSignal<string | undefined>;
     locale: _angular_core.InputSignal<Locale | null>;
@@ -4167,6 +4827,8 @@ declare abstract class DatePickerInputDirective implements FormValueControl<stri
      */
     mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
     pickerOpen: _angular_core.ModelSignal<boolean>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: Signal<string>;
     effectiveValueFormat: Signal<string>;
     effectiveLocale: Signal<Locale | null>;
     /** Uncommitted field text — kept visible when it fails to parse. */
@@ -4254,15 +4916,18 @@ declare abstract class DatePickerInputFieldDirective implements InputMaskHost {
  * only ever sees `Date` objects.
  */
 declare class DateInputDirective extends DatePickerInputDirective implements FormValueControl<string | null> {
+    private dateTimeLabels;
     defaultValueFormat: string;
     /** Message the form field shows when typed text can't be parsed as a date. */
-    parseErrorMessage: _angular_core.InputSignal<string>;
+    parseErrorMessage: _angular_core.InputSignal<string | null>;
     /** date-fns format shown in (and parsed from) the field. Locale-aware by default. */
     displayFormat: _angular_core.InputSignal<string>;
     /** Forwarded to the picker calendar. (`min`/`max` are reserved by signal forms.) */
     minDate: _angular_core.InputSignal<Date | null>;
     maxDate: _angular_core.InputSignal<Date | null>;
     dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** The string in effect: this instance's `parseErrorMessage`, else the domain's label set. */
+    resolvedParseErrorMessage: _angular_core.Signal<string>;
     controlType: _angular_core.WritableSignal<"date-input">;
     /** The current value as a `Date` (what the picker calendar binds to). */
     date: _angular_core.Signal<Date | null>;
@@ -4294,11 +4959,17 @@ declare class DateInputFieldDirective extends DatePickerInputFieldDirective {
 }
 
 declare class DateInputComponent {
+    private dateTimeLabels;
+    private formFieldLabels;
     protected dateInput: DateInputDirective;
-    pickerTriggerLabel: _angular_core.InputSignal<string>;
+    pickerTriggerLabel: _angular_core.InputSignal<string | null>;
     /** Shows a clear (×) control while a value or pending text is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `pickerTriggerLabel`, else the domain's label set. */
+    protected resolvedPickerTriggerLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected handleClearClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
@@ -4326,9 +4997,12 @@ declare class DatePickerTriggerDirective {
 declare const DATE_INPUT_IMPORTS: readonly [typeof DateInputComponent, typeof DateInputDirective, typeof DateInputFieldDirective, typeof DatePickerTriggerDirective, typeof DatePickerSurfaceDirective];
 
 declare class DatePickerPanelComponent {
+    private dateTimeLabels;
     /** Accessible name of the picker dialog — set per control (date / time / range / date-time). */
-    dialogLabel: _angular_core.InputSignal<string>;
+    dialogLabel: _angular_core.InputSignal<string | null>;
     private panelBody;
+    /** The string in effect: this instance's `dialogLabel`, else the domain's label set. */
+    protected resolvedDialogLabel: _angular_core.Signal<string>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerPanelComponent, "et-date-picker-panel", never, { "dialogLabel": { "alias": "dialogLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
@@ -4350,6 +5024,8 @@ type DateRangeSide = 'start' | 'end';
  * against `displayFormat` on blur/Enter, exactly like the single date input.
  */
 declare class DateRangeInputDirective implements FormValueControl<DateRangeValue>, FormFieldControl, DatePickerHost {
+    private dateTimeLabels;
+    private formFieldLabels;
     private formField;
     private destroyRef;
     private document;
@@ -4363,11 +5039,11 @@ declare class DateRangeInputDirective implements FormValueControl<DateRangeValue
      */
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     startPlaceholder: _angular_core.InputSignal<string>;
     endPlaceholder: _angular_core.InputSignal<string>;
@@ -4376,9 +5052,9 @@ declare class DateRangeInputDirective implements FormValueControl<DateRangeValue
      * date field cannot render arbitrary text, so the fields stay empty and the label
      * shows through the placeholder slot; it never enters the form value.
      */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /** Message the form field shows when either side's typed text can't be parsed as a date. */
-    parseErrorMessage: _angular_core.InputSignal<string>;
+    parseErrorMessage: _angular_core.InputSignal<string | null>;
     /** date-fns format of the string values. Defaults to the `DATE_FORMAT` token. */
     valueFormat: _angular_core.InputSignal<string | undefined>;
     /** date-fns format shown in (and parsed from) the fields. Locale-aware by default. */
@@ -4398,6 +5074,10 @@ declare class DateRangeInputDirective implements FormValueControl<DateRangeValue
     maxDate: _angular_core.InputSignal<Date | null>;
     dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
     pickerOpen: _angular_core.ModelSignal<boolean>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: Signal<string>;
+    /** The string in effect: this instance's `parseErrorMessage`, else the domain's label set. */
+    resolvedParseErrorMessage: Signal<string>;
     effectiveValueFormat: Signal<string>;
     effectiveLocale: Signal<Locale | null>;
     /** The side the focused field edits — the picker previews from here too. */
@@ -4505,13 +5185,23 @@ declare class DateRangeInputFieldDirective implements InputMaskHost {
 }
 
 declare class DateRangeInputComponent {
+    private dateTimeLabels;
+    private formFieldLabels;
     protected rangeInput: DateRangeInputDirective;
-    startAriaLabel: _angular_core.InputSignal<string>;
-    endAriaLabel: _angular_core.InputSignal<string>;
-    pickerTriggerLabel: _angular_core.InputSignal<string>;
+    startAriaLabel: _angular_core.InputSignal<string | null>;
+    endAriaLabel: _angular_core.InputSignal<string | null>;
+    pickerTriggerLabel: _angular_core.InputSignal<string | null>;
     /** Shows a clear (×) control while a value is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `startAriaLabel`, else the domain's label set. */
+    protected resolvedStartAriaLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `endAriaLabel`, else the domain's label set. */
+    protected resolvedEndAriaLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `pickerTriggerLabel`, else the domain's label set. */
+    protected resolvedPickerTriggerLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected handleClearClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangeInputComponent, never>;
@@ -4530,6 +5220,12 @@ declare const TIME_FORMAT: InjectionToken<string>;
 /**
  * The date-fns `Locale` used for display formatting and calendar labels.
  * `null` falls back to date-fns' built-in default (en-US).
+ *
+ * This is the one piece of localization that cannot follow `provideLocale()` automatically: a date-fns
+ * locale is a module with its own formatting rules, not something derivable from a `'de'` tag, and
+ * importing every locale to look one up would put all of them in the bundle. So an app that sets
+ * `provideLocale('de')` must also `provideDateLocale(de)` — {@link injectDateLocale} warns in dev mode
+ * when it hasn't.
  */
 declare const DATE_LOCALE: InjectionToken<Locale | null>;
 declare const provideDateFormat: (format: string) => Provider;
@@ -4553,15 +5249,18 @@ declare const DATE_TIME_INPUT_ERROR_CODES: {
  * and time picker only ever see `Date` objects.
  */
 declare class DateTimeInputDirective extends DatePickerInputDirective implements FormValueControl<string | null> {
+    private dateTimeLabels;
     defaultValueFormat: string;
     /** Message the form field shows when typed text can't be parsed as a date & time. */
-    parseErrorMessage: _angular_core.InputSignal<string>;
+    parseErrorMessage: _angular_core.InputSignal<string | null>;
     /** Combined date-fns format shown in (and parsed from) the field. Locale-aware by default. */
     displayFormat: _angular_core.InputSignal<string>;
     /** Forwarded to the picker calendar. (`min`/`max` are reserved by signal forms.) */
     minDate: _angular_core.InputSignal<Date | null>;
     maxDate: _angular_core.InputSignal<Date | null>;
     dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** The string in effect: this instance's `parseErrorMessage`, else the domain's label set. */
+    resolvedParseErrorMessage: _angular_core.Signal<string>;
     controlType: _angular_core.WritableSignal<"date-time-input">;
     /** The current value as a `Date` (what the picker calendar and time picker bind to). */
     dateTime: _angular_core.Signal<Date | null>;
@@ -4604,16 +5303,26 @@ declare class DateTimeInputFieldDirective extends DatePickerInputFieldDirective
 }
 
 declare class DateTimeInputComponent {
+    private dateTimeLabels;
+    private formFieldLabels;
     protected dateTimeInput: DateTimeInputDirective;
-    pickerTriggerLabel: _angular_core.InputSignal<string>;
-    minuteStep: _angular_core.InputSignal<number>;
-    secondStep: _angular_core.InputSignal<number>;
+    pickerTriggerLabel: _angular_core.InputSignal<string | null>;
+    minuteStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    secondStep: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Labels of the pane tabs shown when the picker mounts as a bottom sheet. */
-    dateTabLabel: _angular_core.InputSignal<string>;
-    timeTabLabel: _angular_core.InputSignal<string>;
+    dateTabLabel: _angular_core.InputSignal<string | null>;
+    timeTabLabel: _angular_core.InputSignal<string | null>;
     /** Shows a clear (×) control while a value or pending text is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `pickerTriggerLabel`, else the domain's label set. */
+    protected resolvedPickerTriggerLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `dateTabLabel`, else the domain's label set. */
+    protected resolvedDateTabLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `timeTabLabel`, else the domain's label set. */
+    protected resolvedTimeTabLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     /** Which pane the bottom-sheet tabs show (both panes render side by side on desktop). */
     protected activePane: _angular_core.WritableSignal<"time" | "date">;
@@ -4632,6 +5341,55 @@ declare class DateTimeInputComponent {
 
 declare const DATE_TIME_INPUT_IMPORTS: readonly [typeof DateTimeInputComponent, typeof DateTimeInputDirective, typeof DateTimeInputFieldDirective, typeof DatePickerTriggerDirective, typeof DatePickerSurfaceDirective];
 
+/**
+ * Every string the date/time inputs render or announce themselves — the picker triggers, the two halves
+ * of a range, the date/time tabs, and the parse errors a typed value can produce.
+ *
+ * Month and weekday **names** are not here: they come from the `DATE_LOCALE` date-fns locale, which is
+ * the other half of localizing these controls. See the localization guide.
+ */
+type DateTimeLabels = {
+    /** Accessible label for the control that opens a date picker. */
+    openCalendar: string;
+    /** Accessible label for the control that opens a time picker. */
+    openTimePicker: string;
+    /** Accessible label for the control that opens a combined date & time picker. */
+    openDateTimePicker: string;
+    /** Accessible label for the picker's dialog. */
+    chooseDate: string;
+    /** Accessible label for a range's start field. */
+    startDate: string;
+    /** Accessible label for a range's end field. */
+    endDate: string;
+    /** The date & time picker's tab showing the calendar. */
+    dateTab: string;
+    /** The date & time picker's tab showing the clock. */
+    timeTab: string;
+    /** Validation message for text that isn't a date. */
+    invalidDate: string;
+    /** Validation message for text that isn't a time. */
+    invalidTime: string;
+    /** Validation message for text that isn't a date and time. */
+    invalidDateTime: string;
+    /** Validation message for text that isn't a date range. */
+    invalidDateRange: string;
+    /** Validation message for text that isn't a duration. */
+    invalidDuration: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_DATE_TIME_LABELS: DateTimeLabels;
+/**
+ * Localize the date/time inputs' strings for everything below this injector, and read the set in effect
+ * here as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_DATE_TIME_LABELS} value.
+ * See {@link createLabels} for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideDateTimeLabels({ openCalendar: 'Kalender öffnen', invalidDate: 'Bitte ein gültiges Datum eingeben' });
+ */
+declare const provideDateTimeLabels: (labels: _ethlete_core.LabelsSource<DateTimeLabels>) => _angular_core.Provider;
+declare const injectDateTimeLabels: () => _angular_core.Signal<DateTimeLabels>;
+declare const DATE_TIME_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<DateTimeLabels>>;
+
 declare const DURATION_INPUT_ERROR_CODES: {
     readonly FIELD_OUTSIDE_DURATION_INPUT: 3050;
 };
@@ -4643,6 +5401,8 @@ declare const DURATION_INPUT_ERROR_CODES: {
  * blur/Enter against a configurable segment layout (`130` → `1:30` under `mm:ss`).
  */
 declare class DurationInputDirective implements FormValueControl<number | null>, FormFieldControl {
+    private dateTimeLabels;
+    private formFieldLabels;
     private formField;
     private destroyRef;
     /** Total elapsed milliseconds, or `null` while empty/unparseable. */
@@ -4650,22 +5410,26 @@ declare class DurationInputDirective implements FormValueControl<number | null>,
     /** View state for a field whose source values disagree (bulk edit). The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /**
      * Field placeholder shown while `mixed` is set. Presentation only — the field stays
      * empty and the label shows through the placeholder slot; it never enters the form value.
      */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /** Message the form field shows when typed text can't be parsed as a duration. */
-    parseErrorMessage: _angular_core.InputSignal<string>;
+    parseErrorMessage: _angular_core.InputSignal<string | null>;
     /** The segment layout: `h`/`m`/`s`/`S` token runs plus separators. @default `'mm:ss'` */
     durationFormat: _angular_core.InputSignal<string>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `parseErrorMessage`, else the domain's label set. */
+    resolvedParseErrorMessage: _angular_core.Signal<string>;
     spec: _angular_core.Signal<_ethlete_components.DurationFormatSpec>;
     /** The committed value formatted for display — masked (empty) while mixed. */
     displayValue: _angular_core.Signal<string>;
@@ -4740,10 +5504,13 @@ declare const formatDuration: (ms: number | null, spec: DurationFormatSpec) => s
 declare const parseDuration: (value: string, spec: DurationFormatSpec) => number | null;
 
 declare class DurationInputComponent {
+    private formFieldLabels;
     protected durationInput: DurationInputDirective;
     /** Shows a clear (×) control while a value or pending text is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected handleClearClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DurationInputComponent, never>;
@@ -4760,11 +5527,14 @@ declare const DURATION_INPUT_IMPORTS: readonly [typeof DurationInputComponent, t
  * the time picker itself only ever sees `Date` objects.
  */
 declare class TimeInputDirective extends DatePickerInputDirective implements FormValueControl<string | null> {
+    private dateTimeLabels;
     defaultValueFormat: string;
     /** Message the form field shows when typed text can't be parsed as a time. */
-    parseErrorMessage: _angular_core.InputSignal<string>;
+    parseErrorMessage: _angular_core.InputSignal<string | null>;
     /** date-fns format shown in (and parsed from) the field. Locale-aware by default. */
     displayFormat: _angular_core.InputSignal<string>;
+    /** The string in effect: this instance's `parseErrorMessage`, else the domain's label set. */
+    resolvedParseErrorMessage: _angular_core.Signal<string>;
     controlType: _angular_core.WritableSignal<"time-input">;
     private referenceDate;
     /** The current value as a `Date` (what the picker binds to). */
@@ -4804,13 +5574,19 @@ declare const TIME_INPUT_ERROR_CODES: {
 };
 
 declare class TimeInputComponent {
+    private dateTimeLabels;
+    private formFieldLabels;
     protected timeInput: TimeInputDirective;
-    pickerTriggerLabel: _angular_core.InputSignal<string>;
-    minuteStep: _angular_core.InputSignal<number>;
-    secondStep: _angular_core.InputSignal<number>;
+    pickerTriggerLabel: _angular_core.InputSignal<string | null>;
+    minuteStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    secondStep: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Shows a clear (×) control while a value or pending text is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `pickerTriggerLabel`, else the domain's label set. */
+    protected resolvedPickerTriggerLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected handleClearClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimeInputComponent, never>;
@@ -4824,6 +5600,41 @@ declare class DescriptionComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionComponent, "et-description", never, {}, {}, never, ["*"], true, never>;
 }
 
+/**
+ * Every string the dropzone renders or announces itself: the drop prompt, each entry's actions, and the
+ * fallback wording for an upload that failed without saying why.
+ *
+ * The prompt is also replaceable as content (`<et-dropzone>` projects anything you put inside it), which
+ * is the route to take when you want different markup rather than different words.
+ */
+type DropzoneLabels = {
+    /** The drop-target prompt, shown when nothing is projected into the dropzone. */
+    prompt: string;
+    /** The retry action on a failed entry. */
+    retry: string;
+    /** Accessible label prefix for an entry's remove action — the file name is appended. */
+    remove: string;
+    /** Accessible label for the replace action, shown in single-file mode. */
+    replaceFile: string;
+    /** How a failure with no server message is worded: `"photo.png" failed to upload.` */
+    uploadFailed: string;
+    /** Announced while uploads are in flight. */
+    uploading: (count: number) => string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_DROPZONE_LABELS: DropzoneLabels;
+/**
+ * Localize the dropzone's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_DROPZONE_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideDropzoneLabels({ prompt: 'Datei hierher ziehen oder klicken', retry: 'Erneut versuchen' });
+ */
+declare const provideDropzoneLabels: (labels: _ethlete_core.LabelsSource<DropzoneLabels>) => _angular_core.Provider;
+declare const injectDropzoneLabels: () => _angular_core.Signal<DropzoneLabels>;
+declare const DROPZONE_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<DropzoneLabels>>;
+
 /**
  * Display information for a value that is already part of the form control
  * (e.g. media uploaded in a previous session inside an edit form).
@@ -5109,15 +5920,15 @@ declare class DropzoneDirective<TValue = unknown> implements FormValueControl<TV
     private injector;
     value: _angular_core.ModelSignal<TValue | TValue[] | null>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     /** The upload workflow configuration. Create it via `createDropzoneUpload()`. */
     upload: _angular_core.InputSignal<AnyDropzoneUploadConfig<TValue>>;
     /** Whether multiple files can be uploaded. The control value becomes an array. */
-    multiple: _angular_core.InputSignal<boolean>;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Emits all files of a selection that were rejected, with the reason per file. */
     filesReject: _angular_core.OutputEmitterRef<DropzoneFileRejection[]>;
     /** Emits when the upload of an entry succeeded (after the control value was updated). */
@@ -5176,6 +5987,7 @@ declare class DropzoneDirective<TValue = unknown> implements FormValueControl<TV
 }
 
 declare class DropzoneComponent {
+    private dropzoneLabels;
     protected dropzoneDir: DropzoneDirective<any>;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
@@ -5198,13 +6010,13 @@ declare class DropzoneComponent {
     private renderer;
     private prefersReducedMotion;
     /** Label of the retry button shown for failed uploads. */
-    retryLabel: _angular_core.InputSignal<string>;
+    retryLabel: _angular_core.InputSignal<string | null>;
     /** Accessible label prefix of the remove button. The entry name is appended. */
-    removeLabel: _angular_core.InputSignal<string>;
+    removeLabel: _angular_core.InputSignal<string | null>;
     /** Accessible label of the replace button shown in single mode. */
-    replaceLabel: _angular_core.InputSignal<string>;
+    replaceLabel: _angular_core.InputSignal<string | null>;
     /** Fallback error message shown when the upload error has no message. */
-    uploadErrorLabel: _angular_core.InputSignal<string>;
+    uploadErrorLabel: _angular_core.InputSignal<string | null>;
     /** Overrides the built-in per-entry upload failure message (e.g. for i18n). */
     uploadErrorMessage: _angular_core.InputSignal<((entry: DropzoneEntry) => string) | null>;
     private fileInput;
@@ -5214,6 +6026,14 @@ declare class DropzoneComponent {
     private errorAnimatableRef;
     private hintAnimatableRef;
     private entryElements;
+    /** The string in effect: this instance's `retryLabel`, else the domain's label set. */
+    protected resolvedRetryLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `removeLabel`, else the domain's label set. */
+    protected resolvedRemoveLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `replaceLabel`, else the domain's label set. */
+    protected resolvedReplaceLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `uploadErrorLabel`, else the domain's label set. */
+    resolvedUploadErrorLabel: _angular_core.Signal<string>;
     private removingEntryIds;
     private filePickerOpen;
     canAnimate: {
@@ -5249,6 +6069,38 @@ declare const DROPZONE_ERROR_CODES: {
     readonly VALUE_MODE_MISMATCH: 2402;
 };
 
+/**
+ * The `x / N` character counter in a form field's support region.
+ *
+ * It sits at the inline-end of the support row and is **persistent** — unlike the hint, it does not
+ * swap out when an error appears, because a reader who just crossed the limit needs to see both the
+ * error and the count that caused it.
+ *
+ * The limit comes from `[max]` if given, otherwise from the bound field's schema `maxLength()`
+ * (signal forms binds that into the control automatically). With neither, the counter renders the
+ * bare count.
+ */
+declare class CounterComponent implements CounterComponentBase {
+    private formField;
+    /**
+     * The limit to count towards. Wins over the schema's `maxLength()` — use it for a control whose
+     * length isn't schema-validated, or to count towards a softer limit than the one that validates.
+     */
+    max: _angular_core.InputSignal<number | undefined>;
+    /** Measures the control's value. Override for a value type the default can't count. */
+    lengthOf: _angular_core.InputSignal<(value: unknown) => number>;
+    /** The limit actually in effect: the explicit `[max]`, else the bound field's `maxLength()`. */
+    resolvedMax: _angular_core.Signal<number | undefined>;
+    /** The current length of the control's value. */
+    current: _angular_core.Signal<number>;
+    isOverLimit: _angular_core.Signal<boolean>;
+    protected limitSuffix: _angular_core.Signal<string>;
+    protected announcement: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CounterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CounterComponent, "et-counter", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "lengthOf": { "alias": "lengthOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
  * Resolves the text shown for a validation error. Return `null` to fall back to the error's own
  * `message`. Lets an app centralize/localize error texts by `kind` (e.g. `required`, `minLength`,
@@ -5265,6 +6117,34 @@ declare class FormErrorComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormErrorComponent, "et-form-error", never, { "error": { "alias": "error"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * The strings every form control shows, rather than any one control's own. Both are answers a control
+ * gives about its *value*, which is why they recur: a bulk edit masks disagreeing values the same way in
+ * a text field and in a slider, and a clearable control offers to empty itself the same way everywhere.
+ *
+ * One set for all of them on purpose — translating "Clear" once should be enough. The per-control inputs
+ * (`clearLabel`, `mixedLabel`) still win where a specific instance needs different wording.
+ */
+type FormFieldLabels = {
+    /** Placeholder standing in for values that disagree across a bulk edit (`mixed`). */
+    mixed: string;
+    /** Accessible label for a control's clear-value button. */
+    clear: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_FORM_FIELD_LABELS: FormFieldLabels;
+/**
+ * Localize the strings shared by every form control below this injector, and read the set in effect here
+ * as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_FORM_FIELD_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideFormFieldLabels({ mixed: 'Gemischt', clear: 'Leeren' });
+ */
+declare const provideFormFieldLabels: (labels: _ethlete_core.LabelsSource<FormFieldLabels>) => _angular_core.Provider;
+declare const injectFormFieldLabels: () => _angular_core.Signal<FormFieldLabels>;
+declare const FORM_FIELD_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<FormFieldLabels>>;
+
 declare class FormFieldComponent {
     private provideColor;
     private provideSurface;
@@ -5276,14 +6156,23 @@ declare class FormFieldComponent {
     fill: _angular_core.InputSignal<FormFieldFill>;
     labelMode: _angular_core.InputSignal<FormFieldLabelMode>;
     size: _angular_core.InputSignal<FormFieldSize>;
+    /**
+     * Forces the busy state on. The field already shows it while an async validator is in flight for
+     * the bound field; use this for work the form doesn't know about (saving, a lookup of your own).
+     */
+    busy: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected errorContent: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     protected hintContent: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    counterContent: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     private controlFrame;
     prefixEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     protected errorAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
     protected hintAnimatable: _angular_core.Signal<AnimatableDirective | undefined>;
+    /** Whether the field is showing its busy affordance — a pending async validator, or `[busy]`. */
+    isBusy: _angular_core.Signal<boolean>;
     private errorDimensions;
     private hintDimensions;
+    private counterDimensions;
     private prefixDimensions;
     private supportPresentation;
     private resolvedSurface;
@@ -5310,7 +6199,7 @@ declare class FormFieldComponent {
     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: {}; }]>;
+    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; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; }, {}, never, ["[etInputPrefix]", "et-label", "*", "[etInputSuffix]", "et-hint", "et-counter"], 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 {
@@ -5323,7 +6212,7 @@ declare class InputSuffixDirective {
     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 FORM_FIELD_IMPORTS: readonly [typeof FormFieldComponent, typeof FormFieldDirective, typeof LabelDirective, typeof HintComponent, typeof CounterComponent, typeof InputPrefixDirective, typeof InputSuffixDirective];
 
 declare const INPUT_TEXT_ALIGNMENTS: {
     readonly START: "start";
@@ -5471,53 +6360,96 @@ declare class PasswordInputDirective extends TextFieldControlDirective implement
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PasswordInputDirective, "[etPasswordInput]", ["etPasswordInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "revealed": "revealedChange"; }, never, never, true, never>;
 }
 
+/**
+ * The strings the text-field family's own controls render — the number input's steppers and the password
+ * input's reveal toggle. The field's label, hint and errors are yours; these are the parts the control
+ * adds by itself.
+ */
+type InputLabels = {
+    /** Accessible label for the number input's step-up control. */
+    increment: string;
+    /** Accessible label for the number input's step-down control. */
+    decrement: string;
+    /** Accessible label for the password input's control while the value is masked. */
+    showPassword: string;
+    /** Accessible label for the password input's control while the value is visible. */
+    hidePassword: string;
+    /** The password input's warning that Caps Lock is on. */
+    capsLockOn: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_INPUT_LABELS: InputLabels;
+/**
+ * Localize the text field family's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_INPUT_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideInputLabels({ increment: 'Erhöhen', decrement: 'Verringern' });
+ */
+declare const provideInputLabels: (labels: _ethlete_core.LabelsSource<InputLabels>) => _angular_core.Provider;
+declare const injectInputLabels: () => _angular_core.Signal<InputLabels>;
+declare const INPUT_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<InputLabels>>;
+
 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"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    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"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class NumberInputComponent {
+    private inputLabels;
     protected numberInputDir: NumberInputDirective;
     private destroyRef;
     private document;
     /** Renders −/+ stepper buttons with press-and-hold auto-repeat. */
     stepper: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Accessible name of the increment stepper button. */
-    incrementLabel: _angular_core.InputSignal<string>;
+    incrementLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the decrement stepper button. */
-    decrementLabel: _angular_core.InputSignal<string>;
+    decrementLabel: _angular_core.InputSignal<string | null>;
     private nativeInput;
+    /** The string in effect: this instance's `incrementLabel`, else the domain's label set. */
+    protected resolvedIncrementLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `decrementLabel`, else the domain's label set. */
+    protected resolvedDecrementLabel: _angular_core.Signal<string>;
     private repeatSub;
     constructor();
     syncNativeValue(event: Event): void;
     protected startStepRepeat(event: PointerEvent, direction: 1 | -1): void;
     protected stopStepRepeat(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "et-number-input", never, { "stepper": { "alias": "stepper"; "required": false; "isSignal": true; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; "isSignal": true; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NumberInputDirective; inputs: { "min": "min"; "max": "max"; "step": "step"; "placeholder": "placeholder"; "autocomplete": "autocomplete"; "textAlign": "textAlign"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "et-number-input", never, { "stepper": { "alias": "stepper"; "required": false; "isSignal": true; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; "isSignal": true; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NumberInputDirective; inputs: { "min": "min"; "max": "max"; "step": "step"; "placeholder": "placeholder"; "autocomplete": "autocomplete"; "textAlign": "textAlign"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class PasswordInputComponent {
+    private inputLabels;
     protected passwordDir: PasswordInputDirective;
     /** Whether the reveal (show/hide) toggle renders. */
-    revealable: _angular_core.InputSignal<boolean>;
+    revealable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Accessible name of the reveal toggle while the value is hidden (the "show" action). */
-    revealLabel: _angular_core.InputSignal<string>;
+    revealLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the reveal toggle while the value is shown (the "hide" action). */
-    hideLabel: _angular_core.InputSignal<string>;
+    hideLabel: _angular_core.InputSignal<string | null>;
     /** Show a warning indicator while the field is focused and Caps Lock is on. */
-    capsLockWarning: _angular_core.InputSignal<boolean>;
+    capsLockWarning: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Accessible text of the Caps Lock warning. */
-    capsLockLabel: _angular_core.InputSignal<string>;
+    capsLockLabel: _angular_core.InputSignal<string | null>;
     private nativeInput;
+    /** The string in effect: this instance's `revealLabel`, else the domain's label set. */
+    protected resolvedRevealLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `hideLabel`, else the domain's label set. */
+    protected resolvedHideLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `capsLockLabel`, else the domain's label set. */
+    protected resolvedCapsLockLabel: _angular_core.Signal<string>;
     constructor();
     protected showCapsLockWarning(): boolean;
     syncNativeValue(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordInputComponent, "et-password-input", never, { "revealable": { "alias": "revealable"; "required": false; "isSignal": true; }; "revealLabel": { "alias": "revealLabel"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "capsLockWarning": { "alias": "capsLockWarning"; "required": false; "isSignal": true; }; "capsLockLabel": { "alias": "capsLockLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof PasswordInputDirective; inputs: { "placeholder": "placeholder"; "autocomplete": "autocomplete"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "revealed": "revealed"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; "revealedChange": "revealedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordInputComponent, "et-password-input", never, { "revealable": { "alias": "revealable"; "required": false; "isSignal": true; }; "revealLabel": { "alias": "revealLabel"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "capsLockWarning": { "alias": "capsLockWarning"; "required": false; "isSignal": true; }; "capsLockLabel": { "alias": "capsLockLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof PasswordInputDirective; inputs: { "placeholder": "placeholder"; "autocomplete": "autocomplete"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "revealed": "revealed"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; "revealedChange": "revealedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare const INPUT_IMPORTS: readonly [typeof InputComponent, typeof InputDirective];
@@ -5681,11 +6613,11 @@ type MultiLanguageRichTextEditorValue = Record<string, string>;
 declare class MultiLanguageRichTextEditorDirective implements FormValueControl<MultiLanguageRichTextEditorValue> {
     value: _angular_core.ModelSignal<MultiLanguageRichTextEditorValue>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     /** The languages to offer, in switcher order. Consumer-provided — no languages are hard-wired. */
     languages: _angular_core.InputSignal<readonly MultiLanguageRichTextEditorLanguage[]>;
@@ -5855,7 +6787,11 @@ declare class RichTextEditorTriggersDirective {
     private overlayManager;
     private destroyRef;
     triggers: _angular_core.InputSignal<readonly RichTextEditorTrigger[]>;
-    emptyLabel: _angular_core.InputSignal<string>;
+    /** Shown by the popup when a query matches nothing. `null` (the default) uses the editor's
+     *  `noResults` label. */
+    emptyLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `emptyLabel`, else the editor's label set. */
+    private resolvedEmptyLabel;
     private readonly listboxId;
     private activeMatch;
     private activeIndex;
@@ -5909,6 +6845,144 @@ type RichTextMarkStates = {
     tableCell: boolean;
 };
 
+/**
+ * Every string the rich text editor renders or announces itself. Defaults are English
+ * ({@link DEFAULT_RICH_TEXT_EDITOR_LABELS}); override them app-wide with
+ * {@link provideRichTextEditorLabels} or per instance via `et-rich-text-editor`'s `labels` input.
+ *
+ * Almost all of it is accessible labels: the toolbar's buttons show icons, so their name is the only
+ * thing a screen reader has to go on.
+ *
+ * The **tool** keys (`bold` … `table`) are named after their tool tokens, which is how the toolbar looks
+ * a button's name up. A tool your app registers through `RICH_TEXT_EDITOR_TOOL` keeps the `label` on its
+ * own definition instead — you wrote that string, so it is already in your language.
+ */
+type RichTextEditorLabels = {
+    /** Accessible label for the toolbar. */
+    toolbar: string;
+    /** Accessible label for the toolbar that follows a selection (`floatingToolbar`). */
+    selectionToolbar: string;
+    /** Accessible name for the block-style menu's trigger, given the current style's own label. */
+    textStyle: (currentStyle: string) => string;
+    /** Block-style menu entry: a normal paragraph. */
+    paragraph: string;
+    /** Block-style menu entry for a heading level. */
+    heading: (level: number) => string;
+    /** Accessible label for the link editor popover. */
+    linkEditor: string;
+    /** The link editor's heading while the caret sits on an existing link. */
+    linkEditorEdit: string;
+    /** The link editor's heading while adding a new link. */
+    linkEditorAdd: string;
+    /** Accessible label for the link editor's close button. */
+    linkEditorClose: string;
+    /** Label for the link editor's text field. */
+    linkTextLabel: string;
+    /** Placeholder for the link editor's text field. */
+    linkTextPlaceholder: string;
+    /** Label for the link editor's URL field. */
+    linkUrlLabel: string;
+    /** Placeholder for the link editor's URL field. */
+    linkUrlPlaceholder: string;
+    /** The link editor's "open in a new tab" checkbox. */
+    linkNewTab: string;
+    /** The link editor's action that strips the link, shown only for an existing one. */
+    linkRemove: string;
+    /** The link editor's confirm action while adding a link. */
+    linkAdd: string;
+    /** The link editor's confirm action while editing an existing link. */
+    linkUpdate: string;
+    /** The token palette's trigger. */
+    insertToken: string;
+    /** Shown by a token popup or palette that has nothing to offer. */
+    noResults: string;
+    /** Accessible label for a cell in the table tool's size picker, e.g. `'3 by 4'`. */
+    tableSize: (rows: number, columns: number) => string;
+    /** The size picker's readout while a size is hovered, e.g. `'3 × 4'`. */
+    tableSizePreview: (rows: number, columns: number) => string;
+    /** The size picker's readout before any size is hovered. */
+    tableInsert: string;
+    /** Table menu entry: add a header row to a table that has none. */
+    tableInsertHeaderRow: string;
+    /** Table menu entry: insert a row above the caret's. */
+    tableInsertRowAbove: string;
+    /** Table menu entry: insert a row below the caret's. */
+    tableInsertRowBelow: string;
+    /** Table menu entry: insert a column left of the caret's. */
+    tableInsertColumnLeft: string;
+    /** Table menu entry: insert a column right of the caret's. */
+    tableInsertColumnRight: string;
+    /** Table menu entry: delete the caret's row. */
+    tableDeleteRow: string;
+    /** Table menu entry: delete the caret's column. */
+    tableDeleteColumn: string;
+    /** Table menu entry: delete the whole table. */
+    tableDeleteTable: string;
+    /** Toolbar tool: bold. */
+    bold: string;
+    /** Toolbar tool: italic. */
+    italic: string;
+    /** Toolbar tool: strikethrough. */
+    strike: string;
+    /** Toolbar tool: underline. */
+    underline: string;
+    /** Toolbar tool: inline code. */
+    code: string;
+    /** Toolbar tool: bulleted list. */
+    bulletedList: string;
+    /** Toolbar tool: numbered list. */
+    numberedList: string;
+    /** Toolbar tool: link. */
+    link: string;
+    /** Toolbar tool: the opt-in alignment menu. */
+    align: string;
+    /** Accessible label for the alignment menu's trigger. */
+    alignTrigger: string;
+    /** Alignment menu entry: align left. */
+    alignLeft: string;
+    /** Alignment menu entry: center. */
+    alignCenter: string;
+    /** Alignment menu entry: align right. */
+    alignRight: string;
+    /** Alignment menu entry: justify. */
+    alignJustify: string;
+    /** Toolbar tool: the opt-in table menu, and its trigger. */
+    table: string;
+    /** Toolbar tool: the multi-language editor's language switcher. */
+    language: string;
+    /** Accessible name for the language switcher's trigger, given the active language's own name. */
+    languageTrigger: (currentLanguage: string) => string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_RICH_TEXT_EDITOR_LABELS: RichTextEditorLabels;
+/**
+ * Localize the rich text editor's strings for everything below this injector, and read the set in
+ * effect here as a signal. Partial — whatever you leave out keeps its
+ * {@link DEFAULT_RICH_TEXT_EDITOR_LABELS} value. See {@link createLabels} for the shape, which every
+ * domain in this library shares.
+ *
+ * @example
+ * provideRichTextEditorLabels({
+ *   toolbar: 'Textformatierung',
+ *   bold: 'Fett',
+ *   heading: (level) => `Überschrift ${level}`,
+ * });
+ */
+declare const provideRichTextEditorLabels: (labels: _ethlete_core.LabelsSource<RichTextEditorLabels>) => _angular_core.Provider;
+declare const injectRichTextEditorLabels: () => _angular_core.Signal<RichTextEditorLabels>;
+declare const RICH_TEXT_EDITOR_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<RichTextEditorLabels>>;
+/**
+ * A toolbar button's accessible name: the label set's entry for its tool token, or the `label` on the
+ * definition itself for a tool this library doesn't ship (an app's own tool, already in its language).
+ *
+ * The cast is the price of an extensible token: tool tokens are open strings, so no index signature can
+ * describe "the built-in ones happen to be keys of {@link RichTextEditorLabels}".
+ */
+declare const richTextEditorToolLabel: (labels: RichTextEditorLabels, tool: {
+    token: string;
+    label: string;
+}) => string;
+
 /**
  * The formatting controls the rich text editor can render in its toolbar. `'divider'` renders a
  * visual separator and `'heading'` renders the block-style menu; every other token renders a toggle
@@ -5954,7 +7028,13 @@ declare const injectRichTextEditorTools: {
  */
 declare const provideRichTextEditorTools: (tools: readonly RichTextEditorTool[]) => _angular_core.Provider[];
 
-/** Icon + label + wiring for a single toggle-button tool. */
+/**
+ * Icon + label + wiring for a single toggle-button tool.
+ *
+ * `label` is only the fallback: what the toolbar renders comes from `RICH_TEXT_EDITOR_LABELS`, keyed by
+ * the tool's token — which is why the built-in tables below read their labels from that set's defaults
+ * rather than repeating them.
+ */
 type RichTextEditorToolButton = {
     icon: string;
     label: string;
@@ -6039,6 +7119,7 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     private document;
     private renderer;
     private toolsConfig;
+    private injectedLabels;
     /** @internal */
     editorDom: {
         root: _angular_core.WritableSignal<HTMLElement | null>;
@@ -6075,12 +7156,12 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     };
     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>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /** Which formatting tools the toolbar renders, and in what order. Falls back to the value from
@@ -6089,9 +7170,20 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     /** Markdown autoformat while typing: `- `, `1. ` and `# `–`### ` at a line start convert into
      *  lists/headings, and closing `**bold**`, `*italic*`, `` `code` ``, `~~strike~~`, `__`/`_` runs
      *  convert into their marks. Registered token-trigger characters never autoformat. */
-    autoformat: _angular_core.InputSignal<boolean>;
+    autoformat: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Per-instance overrides for the editor's strings, merged over the injected `RICH_TEXT_EDITOR_LABELS`.
+     * Prefer `provideRichTextEditorLabels` for app-wide localization; use this for a one-off wording.
+     */
+    labels: _angular_core.InputSignal<Partial<RichTextEditorLabels> | null>;
     /** Resolved toolbar tools: the `tools` input if set, otherwise the provided/default config. */
     resolvedTools: _angular_core.Signal<readonly RichTextEditorTool[]>;
+    /**
+     * The strings in effect here: the injected label set with this instance's `labels` applied. Every part
+     * of the editor reads it through this — the toolbars, the link editor and the opt-in tools all reach
+     * the editor already.
+     */
+    resolvedLabels: _angular_core.Signal<RichTextEditorLabels>;
     /**
      * @internal Codec that (de)serializes `{{type:id}}` token chips. Installed by
      * `[etRichTextEditorTriggers]` or a render-only provider; `null` when the building-block
@@ -6210,7 +7302,7 @@ declare class RichTextEditorDirective implements FormValueControl<string>, FormF
     private reflectMarks;
     private runCommand;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RichTextEditorDirective, "[etRichTextEditor]", ["etRichTextEditor"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "autoformat": { "alias": "autoformat"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RichTextEditorDirective, "[etRichTextEditor]", ["etRichTextEditor"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "autoformat": { "alias": "autoformat"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 declare class RichTextEditorFloatingToolbarComponent {
@@ -6233,9 +7325,15 @@ declare class RichTextEditorFloatingToolbarComponent {
         readonly DIVIDER: "divider";
     };
     protected readonly TOOL_BUTTONS: Partial<Record<_ethlete_components.RichTextEditorTool, _ethlete_components.RichTextEditorToolButton>>;
+    /** The editor's strings — the same set, since this toolbar is part of that editor. */
+    protected labels: _angular_core.Signal<_ethlete_components.RichTextEditorLabels>;
     /** The inline marks from the editor's configured tools — headings/lists stay in the static toolbar. */
     protected inlineTools: _angular_core.Signal<_ethlete_components.RichTextEditorTool[]>;
     constructor();
+    /** A tool button's accessible name, from the label set. */
+    protected toolLabel(token: string, tool: {
+        label: string;
+    }): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorFloatingToolbarComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorFloatingToolbarComponent, "et-rich-text-editor-floating-toolbar", never, { "editor": { "alias": "editor"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
 }
@@ -6249,25 +7347,27 @@ type RichTextEditorLinkEditorValue = {
 declare class RichTextEditorLinkEditorComponent {
     private ownColorProvider;
     private contextColorProvider;
+    /** The editor's strings, handed in by `[etRichTextEditorLinkEditor]` — the popover renders detached. */
+    labels: _angular_core.InputSignal<RichTextEditorLabels>;
     href: _angular_core.InputSignal<string>;
     text: _angular_core.InputSignal<string>;
-    newTab: _angular_core.InputSignal<boolean>;
+    newTab: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the caret sits on an existing link (shows the Remove action + "Update"/"Add" wording). */
-    exists: _angular_core.InputSignal<boolean>;
+    exists: _angular_core.InputSignalWithTransform<boolean, unknown>;
     saveLink: _angular_core.OutputEmitterRef<RichTextEditorLinkEditorValue>;
     removeLink: _angular_core.OutputEmitterRef<void>;
     dismiss: _angular_core.OutputEmitterRef<void>;
     protected urlValue: _angular_core.WritableSignal<string>;
     protected textValue: _angular_core.WritableSignal<string>;
     protected newTabValue: _angular_core.WritableSignal<boolean>;
-    protected title: _angular_core.Signal<"Edit link" | "Add link">;
+    protected title: _angular_core.Signal<string>;
     constructor();
     protected save(): void;
     /** Applying re-focuses the editor before the browser processes the Enter keydown's default
      *  action, which would then insert a line break into the editor — so the default is prevented. */
     protected saveOnEnter(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorLinkEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorLinkEditorComponent, "et-rich-text-editor-link-editor", never, { "href": { "alias": "href"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "newTab": { "alias": "newTab"; "required": false; "isSignal": true; }; "exists": { "alias": "exists"; "required": false; "isSignal": true; }; }, { "saveLink": "saveLink"; "removeLink": "removeLink"; "dismiss": "dismiss"; }, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorLinkEditorComponent, "et-rich-text-editor-link-editor", never, { "labels": { "alias": "labels"; "required": true; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "newTab": { "alias": "newTab"; "required": false; "isSignal": true; }; "exists": { "alias": "exists"; "required": false; "isSignal": true; }; }, { "saveLink": "saveLink"; "removeLink": "removeLink"; "dismiss": "dismiss"; }, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -6306,10 +7406,12 @@ declare class RichTextEditorTokenPaletteComponent {
     editor: _angular_core.InputSignal<RichTextEditorDirective>;
     /** The triggers whose items become chip buttons. Use the same array as the editor's triggers. */
     triggers: _angular_core.InputSignal<readonly RichTextEditorTrigger[]>;
-    /** Accessible name for the palette group. */
-    label: _angular_core.InputSignal<string>;
+    /** Accessible name for the palette group. `null` (the default) uses the editor's `insertToken` label. */
+    label: _angular_core.InputSignal<string | null>;
     /** Focus the editor after inserting so the user can keep typing. */
-    focusEditorOnInsert: _angular_core.InputSignal<boolean>;
+    focusEditorOnInsert: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The name in effect: this instance's `label`, else the editor's label set. */
+    protected resolvedLabel: _angular_core.Signal<string>;
     private groups;
     /** Only groups that actually have items to offer — empty (e.g. search-only) triggers are dropped. */
     protected visibleGroups: _angular_core.Signal<RichTextEditorTokenPaletteGroup[]>;
@@ -6341,7 +7443,7 @@ declare class RichTextEditorTokenPopupComponent {
     private contextColorProvider;
     items: _angular_core.InputSignal<RichTextEditorTriggerItem[]>;
     activeIndex: _angular_core.InputSignal<number>;
-    loading: _angular_core.InputSignal<boolean>;
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     error: _angular_core.InputSignal<string | null>;
     emptyLabel: _angular_core.InputSignal<string>;
     listboxId: _angular_core.InputSignal<string>;
@@ -6353,7 +7455,7 @@ declare class RichTextEditorTokenPopupComponent {
     constructor();
     private resolveErrorTheme;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorTokenPopupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorTokenPopupComponent, "et-rich-text-editor-token-popup", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "listboxId": { "alias": "listboxId"; "required": true; "isSignal": true; }; }, { "selectItem": "selectItem"; "activateItem": "activateItem"; }, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorTokenPopupComponent, "et-rich-text-editor-token-popup", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": true; "isSignal": true; }; "listboxId": { "alias": "listboxId"; "required": true; "isSignal": true; }; }, { "selectItem": "selectItem"; "activateItem": "activateItem"; }, never, never, true, [{ directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }, { directive: typeof _ethlete_core.AutoSurfaceDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -6391,11 +7493,13 @@ declare class RichTextEditorAlignToolComponent {
     /** On touch, open the menu without stealing focus so the keyboard (and docked toolbar) stay put. */
     protected hasTouchInput: _angular_core.Signal<boolean>;
     editor: _angular_core.InputSignal<RichTextEditorDirective>;
-    protected readonly OPTIONS: {
+    /** The editor's strings — the tool is part of that editor's toolbar. */
+    protected labels: _angular_core.Signal<_ethlete_components.RichTextEditorLabels>;
+    protected options: _angular_core.Signal<{
         value: TextAlign;
         label: string;
         icon: string;
-    }[];
+    }[]>;
     /** Alignment of the caret's block/cell — kept live so the trigger icon and menu stay in sync. */
     protected current: _angular_core.WritableSignal<"left" | "right" | "center" | "justify">;
     protected currentIcon: _angular_core.Signal<string>;
@@ -6539,13 +7643,13 @@ declare class MenuDirective {
     offset: _angular_core.InputSignal<OffsetOptions | "auto" | null>;
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     /** Render an arrow pointing at the trigger. Trigger-anchored root menus only — submenus and context menus never render one. */
-    arrow: _angular_core.InputSignal<boolean>;
+    arrow: _angular_core.InputSignalWithTransform<boolean, unknown>;
     arrowPadding: _angular_core.InputSignal<Padding | null>;
-    autoFocus: _angular_core.InputSignal<boolean>;
-    hoverOpen: _angular_core.InputSignal<boolean>;
-    hoverOpenDelay: _angular_core.InputSignal<number>;
-    hoverCloseDelay: _angular_core.InputSignal<number>;
-    disabled: _angular_core.InputSignal<boolean>;
+    autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hoverOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hoverOpenDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    hoverCloseDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     open: _angular_core.ModelSignal<boolean>;
     root: MenuDirective;
     depth: number;
@@ -6709,10 +7813,10 @@ declare class MenuSelectionGroupDirective implements MenuSelectionGroupDirective
     value: _angular_core.ModelSignal<unknown>;
     touched: _angular_core.ModelSignal<boolean>;
     multipleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    disabled: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     multiple: _angular_core.Signal<boolean>;
     items: _angular_core.WritableSignal<MenuSelectionGroupItem[]>;
@@ -6740,10 +7844,10 @@ declare class MenuSelectionItemDirective {
     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>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     kind: _angular_core.Signal<MenuSelectionItemKind>;
     ariaChecked: _angular_core.Signal<boolean | "mixed">;
@@ -6863,6 +7967,8 @@ declare class RichTextEditorTableToolComponent {
     editor: _angular_core.InputSignal<RichTextEditorDirective>;
     protected menu: _angular_core.Signal<MenuDirective>;
     protected pickerGrid: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** The editor's strings — the tool is part of that editor's toolbar. */
+    protected labels: _angular_core.Signal<_ethlete_components.RichTextEditorLabels>;
     private ops;
     protected readonly pickerRows: number[];
     protected readonly pickerCols: number[];
@@ -7004,11 +8110,14 @@ declare class RichTextEditorComponent {
         readonly TABLE: "table";
         readonly DIVIDER: "divider";
     };
-    protected readonly HEADING_OPTIONS: readonly {
-        level: number | null;
+    /** The strings in effect, owned by the directive so the opt-in tools read the same set. */
+    protected labels: _angular_core.Signal<_ethlete_components.RichTextEditorLabels>;
+    /** The block-style menu's entries, named by the label set rather than by the option table. */
+    protected headingOptions: _angular_core.Signal<{
         label: string;
+        level: number | null;
         icon: string;
-    }[];
+    }[]>;
     private registeredTools;
     /** Every renderable tool by token: the static base buttons plus any opt-in tools provided via DI. */
     protected toolDefs: _angular_core.Signal<Map<string, RichTextEditorToolDefinition>>;
@@ -7025,6 +8134,8 @@ declare class RichTextEditorComponent {
     /** The toolbar button currently holding the single roving tab stop (ARIA toolbar pattern). */
     private toolbarTabStop;
     constructor();
+    /** A tool button's accessible name, from the label set where this library owns the tool. */
+    protected toolLabel(tool: RichTextEditorToolDefinition): string;
     protected syncValueFromDom(): void;
     /**
      * The toolbar is a single tab stop (ARIA toolbar pattern): Tab enters on one button, the arrow
@@ -7056,7 +8167,7 @@ declare class RichTextEditorComponent {
      *  editor opened from the docked toolbar (which takes focus into an overlay) keeps the bar up. */
     private trackEditingActive;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "et-rich-text-editor", never, {}, {}, never, never, true, [{ directive: typeof RichTextEditorDirective; inputs: { "value": "value"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "placeholder": "placeholder"; "tools": "tools"; "autoformat": "autoformat"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof RichTextEditorFloatingToolbarDirective; inputs: {}; outputs: {}; }, { directive: typeof RichTextEditorLinkEditorDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "et-rich-text-editor", never, {}, {}, never, never, true, [{ directive: typeof RichTextEditorDirective; inputs: { "value": "value"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "placeholder": "placeholder"; "tools": "tools"; "autoformat": "autoformat"; "labels": "labels"; }; outputs: { "valueChange": "valueChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof RichTextEditorFloatingToolbarDirective; inputs: {}; outputs: {}; }, { directive: typeof RichTextEditorLinkEditorDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare const RICH_TEXT_EDITOR_IMPORTS: readonly [typeof RichTextEditorComponent, typeof RichTextEditorDirective];
@@ -7064,7 +8175,7 @@ declare const RICH_TEXT_EDITOR_IMPORTS: readonly [typeof RichTextEditorComponent
 declare class MultiLanguageRichTextEditorComponent {
     protected dir: MultiLanguageRichTextEditorDirective;
     placeholder: _angular_core.InputSignal<string>;
-    autoformat: _angular_core.InputSignal<boolean>;
+    autoformat: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Formatting tools for the embedded editor (the language switcher is prepended automatically).
      *  `null` uses the default toolbar. */
     tools: _angular_core.InputSignal<readonly RichTextEditorTool[] | null>;
@@ -7081,6 +8192,8 @@ declare class MultiLanguageRichTextEditorLanguageToolComponent {
     /** On touch, open the menu without stealing focus so the keyboard (and docked toolbar) stay put. */
     protected hasTouchInput: _angular_core.Signal<boolean>;
     editor: _angular_core.InputSignal<RichTextEditorDirective>;
+    /** The editor's strings — the switcher is part of that editor's toolbar. */
+    protected labels: _angular_core.Signal<_ethlete_components.RichTextEditorLabels>;
     protected languages: _angular_core.Signal<readonly _ethlete_components.MultiLanguageRichTextEditorLanguage[]>;
     protected activeCode: _angular_core.Signal<string>;
     protected activeLabel: _angular_core.Signal<string>;
@@ -7111,18 +8224,18 @@ declare class OtpInputDirective implements FormValueControl<string>, FormFieldCo
     private destroyRef;
     value: _angular_core.ModelSignal<string>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     /** Number of characters/segments. */
-    length: _angular_core.InputSignal<number>;
+    length: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Which characters are accepted — anything else is stripped (also from pastes). */
     charset: _angular_core.InputSignal<OtpInputCharset>;
     /** Renders dots instead of the typed characters (PIN entry). */
-    masked: _angular_core.InputSignal<boolean>;
+    masked: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Emits once each time the value reaches the full length. */
     complete: _angular_core.OutputEmitterRef<string>;
     shouldDisplayError: _angular_core.Signal<boolean>;
@@ -7251,6 +8364,7 @@ declare class PhoneInputFlagDirective {
 }
 
 declare class PhoneInputDirective implements FormValueControl<string>, FormFieldControl {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     /** Normalized `+<dialCode><national digits>` — empty string while nothing is entered. */
@@ -7258,18 +8372,20 @@ declare class PhoneInputDirective implements FormValueControl<string>, FormField
     /** View state for a field whose source values disagree. The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /** Field placeholder shown while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     defaultCountry: _angular_core.InputSignal<string>;
     /** ISO codes listed on top of the country dropdown. */
     preferredCountries: _angular_core.InputSignal<string[]>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
     shouldDisplayError: _angular_core.Signal<boolean>;
     hasValue: _angular_core.Signal<boolean>;
     /** The placeholder the tel field currently shows — `mixedLabel` while mixed. */
@@ -7342,14 +8458,46 @@ declare const PHONE_INPUT_ERROR_CODES: {
     readonly FLAG_TEMPLATE_OUTSIDE_PHONE_INPUT: 2801;
 };
 
+/**
+ * The strings the phone input renders itself. The country *names* are not here — they come from
+ * `Intl.DisplayNames` for the current locale, so they are already translated.
+ */
+type PhoneInputLabels = {
+    /** Accessible label for the country-code selector. */
+    selectCountry: string;
+    /** Placeholder for the country list's search field. */
+    searchCountries: string;
+    /** Shown when a country search matched nothing. */
+    noCountries: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_PHONE_INPUT_LABELS: PhoneInputLabels;
+/**
+ * Localize the phone input's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_PHONE_INPUT_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * providePhoneInputLabels({ selectCountry: 'Land auswählen' });
+ */
+declare const providePhoneInputLabels: (labels: _ethlete_core.LabelsSource<PhoneInputLabels>) => _angular_core.Provider;
+declare const injectPhoneInputLabels: () => _angular_core.Signal<PhoneInputLabels>;
+declare const PHONE_INPUT_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<PhoneInputLabels>>;
+
 declare class PhoneInputComponent {
+    protected phoneInputLabels: _angular_core.Signal<_ethlete_components.PhoneInputLabels>;
+    private formFieldLabels;
     protected phone: PhoneInputDirective;
     private locale;
     /** Accessible name of the country-picker trigger — its only visible content is the flag + dial code. */
-    countryLabel: _angular_core.InputSignal<string>;
+    countryLabel: _angular_core.InputSignal<string | null>;
     /** Shows a clear (×) control while a number is set and the field is in use. */
-    clearable: _angular_core.InputSignal<boolean>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `countryLabel`, else the domain's label set. */
+    protected resolvedCountryLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected showClear: _angular_core.Signal<boolean>;
     protected countries: _angular_core.Signal<{
         name: string;
@@ -7369,6 +8517,7 @@ declare const PHONE_INPUT_IMPORTS: readonly [typeof PhoneInputComponent, typeof
 
 type RatingIconState = 'full' | 'half' | 'empty';
 declare class RatingDirective implements FormValueControl<number | null>, FormFieldControl {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     private elementRef;
@@ -7376,20 +8525,22 @@ declare class RatingDirective implements FormValueControl<number | null>, FormFi
     /** View state for a field whose source values disagree. The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     /** `aria-valuetext` announced while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     /**
      * Typed `number | undefined` because signal forms reserves `max` on value controls —
      * a schema `max(...)` validator binds straight into this input.
      */
     max: _angular_core.InputSignal<number | undefined>;
-    allowHalf: _angular_core.InputSignal<boolean>;
+    allowHalf: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
     effectiveMax: _angular_core.Signal<number>;
     step: _angular_core.Signal<1 | 0.5>;
     /** The value previewed under the pointer, set by the rendered icons. */
@@ -7732,6 +8883,7 @@ type SelectAsyncOptions = {
     hasMore: Signal<boolean>;
 };
 declare class SelectDirective implements FormValueControl<unknown>, FormFieldControl {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     private document;
@@ -7742,14 +8894,14 @@ declare class SelectDirective implements FormValueControl<unknown>, FormFieldCon
     open: _angular_core.ModelSignal<boolean>;
     multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     /** Trigger text shown while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /**
      * Data-driven options: the select owns the option rows instead of the consumer projecting
      * `et-select-option`s, and windows their rendering (virtualization) — only rows near the
@@ -7761,7 +8913,7 @@ declare class SelectDirective implements FormValueControl<unknown>, FormFieldCon
     options: _angular_core.InputSignal<readonly SelectOptionData[] | null>;
     filterModeInput: _angular_core.InputSignal<SelectFilterMode>;
     /** Enter with a search query that matches no option commits the raw query string as the value. */
-    allowCustomValues: _angular_core.InputSignal<boolean>;
+    allowCustomValues: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Single characters that commit the pending search query as a custom value the moment they
      * are typed (e.g. `[',']`), and split pasted text in multi mode. Only with `allowCustomValues`.
@@ -7773,17 +8925,17 @@ declare class SelectDirective implements FormValueControl<unknown>, FormFieldCon
      * Commits a pending search query as a custom value when the panel closes (Tab, outside
      * click) instead of discarding it. An Escape close never commits — it clears the query first.
      */
-    commitCustomValueOnClose: _angular_core.InputSignal<boolean>;
+    commitCustomValueOnClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Maximum number of selected values (multi select) — further adds are ignored. */
     maxSelection: _angular_core.InputSignal<number | undefined>;
     /** Renders an "Add new" row in `et-select`'s panel — clicking it emits `addNew`. */
     allowAddNew: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Async option state — rendered by `et-select` as a loading row inside the panel. */
-    loadingInput: _angular_core.InputSignal<boolean>;
+    loadingInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Async option state — rendered by `et-select` as an error row inside the panel. */
     errorInput: _angular_core.InputSignal<string | null>;
     /** Async option state — `et-select` renders a load-more control emitting `loadMore`. */
-    hasMoreItemsInput: _angular_core.InputSignal<boolean>;
+    hasMoreItemsInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the panel mirrors the anchor's width. Off for compact triggers (e.g. a country picker). */
     mirrorPanelWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
@@ -7810,6 +8962,8 @@ declare class SelectDirective implements FormValueControl<unknown>, FormFieldCon
      * value selection.
      */
     pickOption: _angular_core.OutputEmitterRef<unknown>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: Signal<string>;
     /**
      * An async option source pushed in by `[etSelectOptions]` (from `selectOptionsFromQuery` /
      * `selectOptionsFromV2Query`). While set it overrides the `loading`/`error`/`hasMoreItems`
@@ -8245,6 +9399,36 @@ declare const SELECT_ERROR_CODES: {
     readonly OPTIONS_OUTSIDE_SELECT: 1013;
 };
 
+/**
+ * The strings the select's panel renders itself. The options are yours; these are the panel's own
+ * affordances — paging through an async option list, and the create-a-value flow (`customValues`).
+ */
+type SelectLabels = {
+    /** Shown while the option list is being fetched. */
+    loading: string;
+    /** Shown when the option list came back empty. */
+    empty: string;
+    /** The "fetch the next page of options" control in an async panel. */
+    loadMore: string;
+    /** The panel's entry that starts creating a value that isn't in the list. */
+    addNew: string;
+    /** The confirm action of the create-a-value flow. */
+    create: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_SELECT_LABELS: SelectLabels;
+/**
+ * Localize the select's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_SELECT_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideSelectLabels({ loadMore: 'Mehr laden', create: 'Erstellen' });
+ */
+declare const provideSelectLabels: (labels: _ethlete_core.LabelsSource<SelectLabels>) => _angular_core.Provider;
+declare const injectSelectLabels: () => _angular_core.Signal<SelectLabels>;
+declare const SELECT_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<SelectLabels>>;
+
 declare class SelectOptionGroupComponent {
     protected group: SelectOptionGroupDirective;
     protected readonly labelId: string;
@@ -8359,15 +9543,25 @@ declare class SelectVirtualOptionComponent {
 }
 
 declare class SelectComponent {
+    protected selectLabels: _angular_core.Signal<_ethlete_components.SelectLabels>;
+    private formFieldLabels;
     protected select: SelectDirective;
     protected errorColorTheme: _ethlete_core.ColorTheme;
-    loadMoreLabel: _angular_core.InputSignal<string>;
-    addNewLabel: _angular_core.InputSignal<string>;
+    loadMoreLabel: _angular_core.InputSignal<string | null>;
+    addNewLabel: _angular_core.InputSignal<string | null>;
     /** Leading text of the "Create …" row rendered for `customValueCandidate`. */
-    createLabel: _angular_core.InputSignal<string>;
+    createLabel: _angular_core.InputSignal<string | null>;
     /** Shows a clear (×) control while a value is selected. */
     clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    clearLabel: _angular_core.InputSignal<string>;
+    clearLabel: _angular_core.InputSignal<string | null>;
+    /** The string in effect: this instance's `loadMoreLabel`, else the domain's label set. */
+    protected resolvedLoadMoreLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `addNewLabel`, else the domain's label set. */
+    protected resolvedAddNewLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `createLabel`, else the domain's label set. */
+    protected resolvedCreateLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `clearLabel`, else `FORM_FIELD_LABELS`. */
+    protected resolvedClearLabel: _angular_core.Signal<string>;
     protected mixedLabelId: string;
     protected showClear: _angular_core.Signal<boolean>;
     hasSearch: _angular_core.Signal<boolean>;
@@ -8417,12 +9611,12 @@ declare class SelectionListDirective implements SelectionListDirectiveBase, Form
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
     multipleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** View-only: options keep their normal look and focusability but cannot be (de)selected. */
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     multiple: _angular_core.Signal<boolean>;
     selection: SelectionState<unknown, SelectionListItem>;
@@ -8503,13 +9697,25 @@ declare class SelectionOptionDirective {
     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>;
 }
 
+/** How a checkbox option presents itself. See {@link CheckboxOptionComponent.variant}. */
+declare const CHECKBOX_OPTION_VARIANTS: {
+    readonly PLAIN: "plain";
+    readonly CARD: "card";
+};
+type CheckboxOptionVariant = (typeof CHECKBOX_OPTION_VARIANTS)[keyof typeof CHECKBOX_OPTION_VARIANTS];
 declare class CheckboxOptionComponent {
     optionDirective: SelectionOptionDirective;
+    /**
+     * `'card'` turns the option into a full-width clickable panel with the label leading and the control trailing —
+     * for a small set of consequential choices where each deserves room for a description. `'plain'` is the ordinary
+     * control-then-label row. @default 'plain'
+     */
+    variant: _angular_core.InputSignal<CheckboxOptionVariant>;
     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: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxOptionComponent, "et-checkbox-option", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, 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 {
@@ -8543,15 +9749,33 @@ declare class RadioGroupComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "et-radio-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "mixed": "mixed"; "touched": "touched"; "disabled": "disabled"; "readonly": "readonly"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
+/** How a radio presents itself. See {@link RadioComponent.variant}. */
+declare const RADIO_VARIANTS: {
+    readonly PLAIN: "plain";
+    readonly CARD: "card";
+};
+type RadioVariant = (typeof RADIO_VARIANTS)[keyof typeof RADIO_VARIANTS];
 declare class RadioComponent {
     optionDirective: SelectionOptionDirective;
+    /**
+     * `'card'` turns the option into a full-width clickable panel with the label leading and the control trailing —
+     * for a small set of consequential choices (a plan, a shipping speed) where each deserves room for a
+     * description. `'plain'` is the ordinary control-then-label row. @default 'plain'
+     */
+    variant: _angular_core.InputSignal<RadioVariant>;
     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: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent, "et-radio", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*", "et-description"], true, [{ directive: typeof SelectionOptionDirective; inputs: { "value": "value"; "checked": "checked"; "disabled": "disabled"; }; outputs: { "checkedChange": "checkedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
+/** How a segmented button group presents its selection. See {@link SegmentedButtonGroupComponent.variant}. */
+declare const SEGMENTED_BUTTON_GROUP_VARIANTS: {
+    readonly PILL: "pill";
+    readonly TABS: "tabs";
+};
+type SegmentedButtonGroupVariant = (typeof SEGMENTED_BUTTON_GROUP_VARIANTS)[keyof typeof SEGMENTED_BUTTON_GROUP_VARIANTS];
 declare class SegmentedButtonGroupComponent {
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
@@ -8571,6 +9795,15 @@ declare class SegmentedButtonGroupComponent {
         supportHeight: _angular_core.Signal<number>;
     };
     size: _angular_core.InputSignal<FormFieldSize>;
+    /**
+     * How the selection is drawn. `'pill'` fills the selected segment; `'tabs'` underlines it instead, for a group
+     * that reads as a set of views rather than a set of values.
+     *
+     * It is still a **selection control**, not navigation — it binds to a form field and announces itself as a radio
+     * group. If the segments correspond to routes, or to panels of content that should be linkable, reach for
+     * [tabs](/components/tabs) instead; this variant is for a filter that happens to look like tabs. @default 'pill'
+     */
+    variant: _angular_core.InputSignal<SegmentedButtonGroupVariant>;
     private errorContentRef;
     private hintContentRef;
     private errorAnimatableRef;
@@ -8582,7 +9815,7 @@ declare class SegmentedButtonGroupComponent {
     };
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedButtonGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonGroupComponent, "et-segmented-button-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["et-label", ".et-segmented-button-group-label", "*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "mixed": "mixed"; "touched": "touched"; "disabled": "disabled"; "readonly": "readonly"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonGroupComponent, "et-segmented-button-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["et-label", ".et-segmented-button-group-label", "*", "et-hint"], true, [{ directive: typeof FormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof SelectionListDirective; inputs: { "value": "value"; "mixed": "mixed"; "touched": "touched"; "disabled": "disabled"; "readonly": "readonly"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: { "etProvideColor": "color"; }; outputs: {}; }]>;
 }
 
 declare class SegmentedButtonComponent {
@@ -8622,8 +9855,8 @@ type SliderHostBase = {
     step: Signal<number>;
     /** Bulk-edit view state — while set, thumbs park at the track start and hide their value from ARIA. */
     mixed: Signal<boolean>;
-    /** `aria-valuetext` the thumbs announce while `mixed` is set. */
-    mixedLabel: Signal<string>;
+    /** `aria-valuetext` the thumbs announce while `mixed` is set, after `SLIDER_LABELS` is applied. */
+    resolvedMixedLabel: Signal<string>;
     disabled: Signal<boolean>;
     readonly: Signal<boolean>;
     interactive: Signal<boolean>;
@@ -8654,25 +9887,28 @@ declare const SLIDER_TOKEN: InjectionToken<SliderHostBase>;
 
 type RangeSliderValue = [number, number];
 declare class RangeSliderDirective implements FormValueControl<RangeSliderValue>, FormFieldControl, SliderHostBase {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     value: _angular_core.ModelSignal<RangeSliderValue>;
     /** View state for a field whose source values disagree. The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     /** `aria-valuetext` both thumbs announce while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
-    minValue: _angular_core.InputSignal<number>;
-    maxValue: _angular_core.InputSignal<number>;
-    step: _angular_core.InputSignal<number>;
+    minValue: _angular_core.InputSignalWithTransform<number, unknown>;
+    maxValue: _angular_core.InputSignalWithTransform<number, unknown>;
+    step: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Minimum gap kept between the two thumbs — should be a multiple of `step`. */
-    minDistance: _angular_core.InputSignal<number>;
+    minDistance: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
     effectiveMin: _angular_core.Signal<number>;
     effectiveMax: _angular_core.Signal<number>;
     interactive: _angular_core.Signal<boolean>;
@@ -8758,23 +9994,26 @@ declare class SliderTrackDirective {
 }
 
 declare class SliderDirective implements FormValueControl<number>, FormFieldControl, SliderHostBase {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     value: _angular_core.ModelSignal<number>;
     /** View state for a field whose source values disagree. The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     /** `aria-valuetext` the thumb announces while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     min: _angular_core.InputSignal<number | undefined>;
     max: _angular_core.InputSignal<number | undefined>;
-    step: _angular_core.InputSignal<number>;
+    step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
     effectiveMin: _angular_core.Signal<number>;
     effectiveMax: _angular_core.Signal<number>;
     interactive: _angular_core.Signal<boolean>;
@@ -8808,6 +10047,7 @@ declare class SliderDirective implements FormValueControl<number>, FormFieldCont
 }
 
 declare class RangeSliderComponent {
+    private sliderLabels;
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
         formFieldDir: FormFieldDirective;
@@ -8827,13 +10067,17 @@ declare class RangeSliderComponent {
     };
     protected slider: RangeSliderDirective;
     /** Accessible name of the start thumb. */
-    startLabel: _angular_core.InputSignal<string>;
+    startLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the end thumb. */
-    endLabel: _angular_core.InputSignal<string>;
+    endLabel: _angular_core.InputSignal<string | null>;
     private errorContentRef;
     private hintContentRef;
     private errorAnimatableRef;
     private hintAnimatableRef;
+    /** The string in effect: this instance's `startLabel`, else the domain's label set. */
+    protected resolvedStartLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `endLabel`, else the domain's label set. */
+    protected resolvedEndLabel: _angular_core.Signal<string>;
     canAnimate: {
         state: _angular_core.Signal<boolean>;
     };
@@ -8850,6 +10094,30 @@ declare const SLIDER_ERROR_CODES: {
     readonly THUMB_COUNT_MISMATCH: 3103;
 };
 
+/**
+ * The strings a slider announces. A range slider has two thumbs and no visible text, so naming them is
+ * the only way a screen reader can tell them apart.
+ */
+type SliderLabels = {
+    /** Accessible label for a range slider's lower thumb. */
+    minimum: string;
+    /** Accessible label for a range slider's upper thumb. */
+    maximum: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_SLIDER_LABELS: SliderLabels;
+/**
+ * Localize a slider's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_SLIDER_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideSliderLabels({ minimum: 'Minimum', maximum: 'Maximum' });
+ */
+declare const provideSliderLabels: (labels: _ethlete_core.LabelsSource<SliderLabels>) => _angular_core.Provider;
+declare const injectSliderLabels: () => _angular_core.Signal<SliderLabels>;
+declare const SLIDER_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<SliderLabels>>;
+
 declare class SliderComponent {
     support: {
         errorColorTheme: _ethlete_core.ColorTheme;
@@ -8898,10 +10166,10 @@ declare class SwitchDirective implements FormFieldControl {
     touched: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** View-only: keeps the normal look and focusability but blocks toggling (unlike `disabled`). */
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
     shouldDisplayError: _angular_core.Signal<boolean>;
     describedBy: _angular_core.WritableSignal<string | null>;
@@ -8925,30 +10193,45 @@ declare class SwitchComponent {
 declare const SWITCH_IMPORTS: readonly [typeof SwitchComponent, typeof SwitchDirective];
 
 declare class TagInputDirective implements FormValueControl<string[]>, FormFieldControl {
+    private formFieldLabels;
     private formField;
     private destroyRef;
     value: _angular_core.ModelSignal<string[]>;
     /** View state for a field whose source values disagree. The raw form value stays untouched. */
     mixed: _angular_core.ModelSignal<boolean>;
     touched: _angular_core.ModelSignal<boolean>;
-    disabled: _angular_core.InputSignal<boolean>;
-    readonly: _angular_core.InputSignal<boolean>;
-    invalid: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    required: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     name: _angular_core.InputSignal<string>;
+    /**
+     * The bound field's `maxLength()` limit — for an array value that is the maximum number of tags.
+     * Signal forms binds it automatically because this input exists, so `<et-counter />` picks the
+     * limit up from the schema. Display only: the tag input does not refuse tags past it, so the
+     * validator is still the thing that reports the violation.
+     */
+    maxLength: _angular_core.InputSignal<number | undefined>;
+    /**
+     * True while an async validator is in flight for the bound field — bound automatically by signal
+     * forms because this input exists. The field shell surfaces it as its busy state.
+     */
+    pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     placeholder: _angular_core.InputSignal<string>;
     /** Field placeholder shown while `mixed` is set. */
-    mixedLabel: _angular_core.InputSignal<string>;
+    mixedLabel: _angular_core.InputSignal<string | null>;
     /**
      * What commits the pending text as a tag: multi-character entries are key names
      * (`'Enter'`), single characters commit as soon as they are typed (and split pastes).
      */
     separators: _angular_core.InputSignal<string[]>;
-    allowDuplicates: _angular_core.InputSignal<boolean>;
+    allowDuplicates: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Maps raw text to the stored tag — return `null` to reject. Defaults to trimming. */
     normalizeTag: _angular_core.InputSignal<(raw: string) => string | null>;
     maxTags: _angular_core.InputSignal<number | undefined>;
+    /** The string in effect: this instance's `mixedLabel`, else `FORM_FIELD_LABELS`. */
+    resolvedMixedLabel: _angular_core.Signal<string>;
     shouldDisplayError: _angular_core.Signal<boolean>;
     /** The raw value normalized to the tags the control currently shows. Mixed has no effective tags. */
     effectiveValues: _angular_core.Signal<readonly string[]>;
@@ -8981,7 +10264,7 @@ declare class TagInputDirective implements FormValueControl<string[]>, FormField
     removeAt(index: number): void;
     removeLast(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagInputDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TagInputDirective, "[etTagInput]", ["etTagInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "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; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "mixedLabel": { "alias": "mixedLabel"; "required": false; "isSignal": true; }; "separators": { "alias": "separators"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "normalizeTag": { "alias": "normalizeTag"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "mixed": "mixedChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TagInputDirective, "[etTagInput]", ["etTagInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "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; }; "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; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "mixedLabel": { "alias": "mixedLabel"; "required": false; "isSignal": true; }; "separators": { "alias": "separators"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "normalizeTag": { "alias": "normalizeTag"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "mixed": "mixedChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 /** The text field of a tag input — commits its text as a tag on separators and blur. */
@@ -9010,7 +10293,7 @@ declare const TAG_INPUT_ERROR_CODES: {
 declare class TagInputComponent {
     protected tagInput: TagInputDirective;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagInputComponent, "et-tag-input", never, {}, {}, never, never, true, [{ directive: typeof TagInputDirective; inputs: { "value": "value"; "mixed": "mixed"; "touched": "touched"; "disabled": "disabled"; "readonly": "readonly"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "placeholder": "placeholder"; "mixedLabel": "mixedLabel"; "separators": "separators"; "allowDuplicates": "allowDuplicates"; "normalizeTag": "normalizeTag"; "maxTags": "maxTags"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagInputComponent, "et-tag-input", never, {}, {}, never, never, true, [{ directive: typeof TagInputDirective; inputs: { "value": "value"; "mixed": "mixed"; "touched": "touched"; "disabled": "disabled"; "readonly": "readonly"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "placeholder": "placeholder"; "mixedLabel": "mixedLabel"; "separators": "separators"; "allowDuplicates": "allowDuplicates"; "normalizeTag": "normalizeTag"; "maxTags": "maxTags"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare const TAG_INPUT_IMPORTS: readonly [typeof TagInputComponent, typeof TagInputDirective, typeof TagInputFieldDirective];
@@ -9025,8 +10308,8 @@ declare class TextareaDirective extends TextFieldControlDirective implements For
     value: _angular_core.ModelSignal<string>;
     placeholder: _angular_core.InputSignal<string>;
     autocomplete: _angular_core.InputSignal<string>;
-    rows: _angular_core.InputSignal<number>;
-    autosize: _angular_core.InputSignal<boolean>;
+    rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
     minRows: _angular_core.InputSignal<number | null>;
     maxRows: _angular_core.InputSignal<number | null>;
     /** Only applied when `autosize` is off; an autosizing textarea is never manually resizable. */
@@ -9063,7 +10346,7 @@ declare class TextareaComponent {
     constructor();
     syncNativeValue(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "et-textarea", never, {}, {}, never, never, true, [{ directive: typeof TextareaDirective; inputs: { "placeholder": "placeholder"; "autocomplete": "autocomplete"; "rows": "rows"; "autosize": "autosize"; "minRows": "minRows"; "maxRows": "maxRows"; "resize": "resize"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "et-textarea", never, {}, {}, never, never, true, [{ directive: typeof TextareaDirective; inputs: { "placeholder": "placeholder"; "autocomplete": "autocomplete"; "rows": "rows"; "autosize": "autosize"; "minRows": "minRows"; "maxRows": "maxRows"; "resize": "resize"; "value": "value"; "mixed": "mixed"; "mixedLabel": "mixedLabel"; "disabled": "disabled"; "readonly": "readonly"; "hidden": "hidden"; "invalid": "invalid"; "errors": "errors"; "required": "required"; "name": "name"; "maxLength": "maxLength"; "pending": "pending"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; "mixedChange": "mixedChange"; "touchedChange": "touchedChange"; }; }, { directive: typeof _ethlete_core.ColorInteractiveDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare const TEXTAREA_IMPORTS: readonly [typeof TextareaComponent, typeof TextareaDirective];
@@ -9151,8 +10434,8 @@ declare class GridDirective {
     private gridConfig;
     private reducedMotion;
     breakpoints: _angular_core.InputSignal<GridBreakpointConfig[]>;
-    rowHeight: _angular_core.InputSignal<number>;
-    gap: _angular_core.InputSignal<number>;
+    rowHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    gap: _angular_core.InputSignalWithTransform<number, unknown>;
     initialItems: _angular_core.InputSignal<GridItemConfig[]>;
     readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     layoutChange: _angular_core.OutputEmitterRef<GridSerializedState>;
@@ -9548,10 +10831,6 @@ declare const GRID_TOKEN: InjectionToken<GridDirective>;
 
 type GridConfig = {
     registrations: GridComponentRegistration[];
-    interactiveAriaLabel: string;
-    readonlyAriaLabel: string;
-    removeActionAriaLabel: string;
-    transformer: (text: string, locale: string) => string;
     actionsComponent?: GridItemActionsComponent | null;
 };
 declare const provideGridConfig: (valueOverride?: Partial<GridConfig> | undefined) => _angular_core.Provider[];
@@ -9586,7 +10865,7 @@ declare const fromGridPosition: (pos: GridItemPosition) => {
 declare class GridComponent {
     grid: GridDirective;
     private gridConfig;
-    private locale;
+    private labels;
     protected actionsComponent: _angular_core.Signal<_ethlete_components.GridItemActionsComponent | null>;
     protected registeredItems: _angular_core.Signal<{
         item: _ethlete_components.GridItemConfig;
@@ -9626,8 +10905,7 @@ declare class GridItemToolbarComponent {
 
 declare class GridItemDefaultActionsComponent {
     private grid;
-    private gridConfig;
-    private locale;
+    private labels;
     itemId: _angular_core.InputSignal<string>;
     data: _angular_core.InputSignal<unknown>;
     protected removeAriaLabel: _angular_core.Signal<string>;
@@ -9687,6 +10965,36 @@ declare const GRID_ERROR_CODES: {
     readonly UNKNOWN_ITEM_TYPE: 1904;
 };
 
+/**
+ * Every string the grid announces. It renders no text of its own — the items are yours — so these are
+ * all accessible labels.
+ *
+ * They used to live on `GridConfig` next to a `transformer(text, locale)` hook, which asked an app to
+ * translate *by matching the English string*. `GridConfig` keeps the registrations and the actions
+ * component; the wording lives here, like every other label in this library.
+ */
+type GridLabels = {
+    /** Accessible label for a grid whose items can be moved and resized. */
+    interactiveGrid: string;
+    /** Accessible label for a read-only grid. */
+    readonlyGrid: string;
+    /** Accessible label for an item's remove action. */
+    removeItem: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_GRID_LABELS: GridLabels;
+/**
+ * Localize the grid's accessible labels for everything below this injector, and read the set in effect
+ * here as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_GRID_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideGridLabels({ readonlyGrid: 'Raster', removeItem: 'Element entfernen' });
+ */
+declare const provideGridLabels: (labels: _ethlete_core.LabelsSource<GridLabels>) => _angular_core.Provider;
+declare const injectGridLabels: () => _angular_core.Signal<GridLabels>;
+declare const GRID_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<GridLabels>>;
+
 declare const GRID_IMPORTS: readonly [typeof GridComponent, typeof GridItemComponent, typeof GridItemToolbarComponent, typeof GridItemDefaultActionsComponent, typeof GridDebugComponent];
 
 type IconDefinition = {
@@ -9748,7 +11056,7 @@ declare const provideIcons: (...icons: IconDefinition[]) => {
  * Keep this in sync when adding or removing a built-in `et-*` icon under
  * `libs/components/src/lib/icon/headless/`.
  */
-declare const ET_BUILT_IN_ICON_NAMES: readonly ["et-align-center", "et-align-justify", "et-align-left", "et-align-right", "et-arrow-out-up-right", "et-arrow-right", "et-arrow-up", "et-arrows-left-right", "et-bold", "et-calendar", "et-check", "et-chevron", "et-clipboard-check", "et-clock", "et-code", "et-ellipsis-vertical", "et-eye", "et-eye-slash", "et-file", "et-filter", "et-floppy-disk", "et-focus-frame", "et-grid-2x2", "et-heading-1", "et-heading-2", "et-heading-3", "et-italic", "et-link", "et-list-bulleted", "et-list-numbered", "et-lock", "et-minus", "et-paragraph", "et-pause", "et-pencil", "et-play", "et-plus", "et-rotate-right", "et-star", "et-strikethrough", "et-table", "et-times", "et-triangle-exclamation", "et-underline", "et-upload"];
+declare const ET_BUILT_IN_ICON_NAMES: readonly ["et-align-center", "et-align-justify", "et-align-left", "et-align-right", "et-arrow-out-up-right", "et-arrow-right", "et-arrow-up", "et-arrows-left-right", "et-bold", "et-calendar", "et-check", "et-chevron", "et-clipboard-check", "et-clock", "et-code", "et-ellipsis", "et-ellipsis-vertical", "et-eye", "et-eye-slash", "et-file", "et-filter", "et-floppy-disk", "et-focus-frame", "et-grid-2x2", "et-heading-1", "et-heading-2", "et-heading-3", "et-italic", "et-link", "et-list-bulleted", "et-list-numbered", "et-lock", "et-minus", "et-paragraph", "et-pause", "et-pencil", "et-play", "et-plus", "et-rotate-right", "et-star", "et-strikethrough", "et-table", "et-times", "et-triangle-exclamation", "et-underline", "et-upload"];
 /** Union of the SDK's built-in icon names — see {@link ET_BUILT_IN_ICON_NAMES}. */
 type EtBuiltInIconName = (typeof ET_BUILT_IN_ICON_NAMES)[number];
 /**
@@ -9822,6 +11130,9 @@ declare const CLOCK_ICON: IconDefinition;
 
 declare const CODE_ICON: IconDefinition;
 
+/** Horizontal three-dot glyph — the breadcrumb's "show the hidden levels" trigger. */
+declare const ELLIPSIS_ICON: IconDefinition;
+
 /** Vertical three-dot "more actions" glyph — the table's column menu trigger. */
 declare const ELLIPSIS_VERTICAL_ICON: IconDefinition;
 
@@ -9913,6 +11224,7 @@ declare const UPLOAD_ICON: IconDefinition;
 declare const ICON_IMPORTS: readonly [typeof IconDirective];
 
 declare class BrandLoaderComponent {
+    protected labels: _angular_core.Signal<_ethlete_components.LoaderLabels>;
     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;
@@ -9920,34 +11232,277 @@ declare class BrandLoaderComponent {
     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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrandLoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BrandLoaderComponent, "et-brand-loader", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * What a busy indicator announces. A spinner, a brand loader and a skeleton are all shapes with no
+ * text, so this is the only thing a screen reader has to go on.
+ *
+ * One set for all of them on purpose: an app that translates "Loading" should not have to say so once
+ * per component. `et-skeleton`'s `loadingAllyText` still overrides it per instance where something more
+ * specific reads better ("Loading results").
+ */
+type LoaderLabels = {
+    /** Announced by an indeterminate loader — the spinner, the brand loader, a stream's loading overlay. */
+    loading: string;
+    /** Announced in place of a skeleton's shapes, which are `aria-hidden`. */
+    loadingContent: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_LOADER_LABELS: LoaderLabels;
+/**
+ * Localize what loaders announce for everything below this injector, and read the set in effect here as
+ * a signal. Partial — whatever you leave out keeps its {@link DEFAULT_LOADER_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideLoaderLabels({ loading: 'Lädt', loadingContent: 'Lädt…' });
+ */
+declare const provideLoaderLabels: (labels: _ethlete_core.LabelsSource<LoaderLabels>) => _angular_core.Provider;
+declare const injectLoaderLabels: () => _angular_core.Signal<LoaderLabels>;
+declare const LOADER_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<LoaderLabels>>;
+
+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>;
+}
+
+/**
+ * One item in a masonry. It measures itself — continuously, via its own `ResizeObserver` — and takes the
+ * width and position the masonry works out from those measurements.
+ *
+ * Continuous measurement is what makes late content behave: an image that arrives after layout, a card that
+ * reflows when a translation swaps in, a description that expands on click. cdk measured each item once and
+ * kept the number, so any of those left the item overlapping its neighbour until the next resize.
+ *
+ * The element is yours, which is what lets a masonry be a real list — `<ul etMasonry>` with `<li
+ * etMasonryItem>` children needs no ARIA roles at all.
+ *
+ * @example
+ * <li etMasonryItem>…</li>
+ */
+declare class MasonryItemDirective {
+    /** @internal The masonry sorts its items by document position, which needs their elements. */
+    elementRef: ElementRef<HTMLElement>;
+    private masonry;
+    private dimensions;
+    /**
+     * The item's measured border box.
+     *
+     * `rect()` rather than the integer `offset` sizes: a column width is rarely a whole number of pixels (the
+     * remainder is shared out between the columns), and rounding every item's height would drift the columns
+     * apart by a pixel per item stacked.
+     */
+    private measured;
+    /** How tall the item is right now — what the masonry packs with. */
+    blockSize: _angular_core.Signal<number>;
+    /**
+     * How wide the item is right now. The masonry compares this against the column width to know whether the
+     * item has re-measured since the columns changed — a stale width means a stale height too, and both arrive
+     * together when the observer fires.
+     */
+    inlineSize: _angular_core.Signal<number>;
+    /** The width the masonry has assigned, or `null` before its container has been measured. */
+    columnInlineSize: _angular_core.Signal<number | null>;
+    /**
+     * Whether the item has reported its size *at the width the masonry gave it*. Until it has, its height is
+     * the height it had at some other width, so the placement derived from it would be wrong. The observer
+     * delivers both sizes together, which is what makes the width a reliable proxy for "this height is current".
+     */
+    isMeasured: _angular_core.Signal<boolean>;
+    /** Where the masonry has put this item, or `null` before it has. */
+    placement: _angular_core.Signal<_ethlete_components.MasonryPlacement | null>;
+    /** Whether the item's placement is current, i.e. derived from a height measured at its present width. */
+    isPlaced: _angular_core.Signal<boolean>;
+    /**
+     * Whether the item has a place on screen — **sticky**: it fades in on its first placement and then stays
+     * visible. That the reveal latches is the point. Every column width change un-measures every item for a
+     * frame (its recorded width is the old one until the observer reports), and a reveal tied to the live
+     * measurement would therefore fade the whole masonry out and back in on every frame of a window drag.
+     *
+     * Before the first placement there is nothing to show but a pile of items in the container's start corner,
+     * which is what the initial transparency is for.
+     */
+    private hasBeenPlaced;
+    isPositioned: _angular_core.Signal<unknown>;
+    private isMoveArmed;
+    /**
+     * Whether this item may animate a move. It must not animate the first one: before it has a placement its
+     * offsets are zero, so an armed transition would slide it in from the container's start corner — and an item
+     * appended to a feed would slide in from there too. So the transition is armed a frame *after* the item is
+     * placed, by which point the browser has painted it where it belongs and there is nothing to animate from.
+     */
+    canMove: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MasonryItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MasonryItemDirective, "[etMasonryItem]", ["etMasonryItem"], {}, {}, never, never, true, never>;
+}
+
+/** Where one item sits: which column it landed in, and its offset from the container's start corner. */
+type MasonryPlacement = {
+    column: number;
+    /** Offset along the inline axis (left in LTR, right in RTL — CSS resolves the side). */
+    inlineOffset: number;
+    /** Offset along the block axis, i.e. how tall the column was when this item was placed. */
+    blockOffset: number;
+};
+/** The column grid a masonry has settled on for its current width. */
+type MasonryColumns = {
+    /** `0` means the container has not been measured yet, so nothing can be placed. */
+    count: number;
+    inlineSize: number;
+};
+/** The result of one packing pass. */
+type MasonryPacking = {
+    /** Index-aligned with the block sizes handed in. */
+    placements: MasonryPlacement[];
+    /** How tall each column ended up, gap included — the state the greedy pass carries along. */
+    columnBlockSizes: number[];
+    /** How tall the container has to be to hold every column. */
+    blockSize: number;
+};
+
+/**
+ * Packs variable-height items into columns, each item going to whichever column is currently shortest — the
+ * layout a photo feed wants, where cropping every card to a common height would be the alternative.
+ *
+ * It measures and positions, because CSS still can't: native masonry (`display: grid-lanes`, CSS Grid Level
+ * 3) is not Baseline as of this writing, and CSS `columns` fills column by column, so the reading order of a
+ * feed would no longer be its visual order. See `plans/cdk-port/07-masonry.md` for the full verdict. Items
+ * are therefore absolutely positioned from their measured sizes, which keeps DOM order and reading order the
+ * same and means a reflow never relayouts the page around it.
+ *
+ * The measuring is per item and continuous (a `ResizeObserver` each), so a card whose image loads late, or
+ * whose text reflows, moves the ones below it — the one thing cdk's one-shot `getBoundingClientRect()`
+ * snapshots could not do.
+ *
+ * @example
+ * <ul etMasonry [columnWidth]="240" [gap]="16">
+ *   @for (photo of photos(); track photo.id) {
+ *     <li etMasonryItem><img [src]="photo.url" alt="" /></li>
+ *   }
+ * </ul>
+ */
+declare class MasonryDirective {
+    private elementRef;
+    private styleManager;
+    /**
+     * The narrowest a column may be, in px — a minimum rather than a target. As many columns as fit at that
+     * width are used (gaps included), and the leftover space is shared out between them, so the columns always
+     * fill the container. That is `repeat(auto-fill, minmax(X, 1fr))`, expressed as a number because the
+     * packing needs it as one.
+     *
+     * Accepts a per-breakpoint map (`{ xs: 150, md: 240 }`) for a layout that wants coarser columns on a phone
+     * than the container width alone would give. @default 250
+     */
+    columnWidth: _angular_core.InputSignalWithTransform<number, string | _ethlete_core.BreakpointInput<number>>;
+    /**
+     * The space between columns and between stacked items, in px. Also accepts a per-breakpoint map. It is a
+     * number rather than CSS `gap` because the items are positioned, not laid out — CSS never sees the
+     * columns. @default 16
+     */
+    gap: _angular_core.InputSignalWithTransform<number, string | _ethlete_core.BreakpointInput<number>>;
+    private dimensions;
+    private registeredItems;
+    /**
+     * @internal The items in DOM order, which for masonry *is* the placement order: registration order follows
+     * creation order, and a `@for` that re-orders its items would otherwise pack them by the order they were
+     * born in rather than the order they are read in.
+     */
+    items: _angular_core.Signal<MasonryItemDirective[]>;
+    /**
+     * How wide the container is. Only the inline size is taken from the observed dimensions, deliberately: this
+     * directive *sets* the container's height, so a signal carrying both would see its own write and lay out
+     * again. Reading one number out of it means the recompute stops at an unchanged value instead.
+     */
+    containerInlineSize: _angular_core.Signal<number>;
+    /** The column grid in effect: how many, and how wide. `count: 0` until the container has been measured. */
+    columns: _angular_core.Signal<_ethlete_components.MasonryColumns>;
+    /**
+     * The columns items have already been given, and the column count they were given for. Rebalancing is a
+     * *geometry* decision, not a content one: see `repack()`.
+     */
+    private columnAssignments;
+    /**
+     * Every item's position, derived rather than assigned. The whole layout is one `computed` over the item
+     * sizes, the column grid and the gap — so there is no invalidation to get right, no imperative pass over
+     * the DOM, and appending to a feed re-derives the existing placements *identically* because the packing is
+     * prefix-stable. What cdk did with a partial-invalidation mode, Angular's binding dedupe does here: an
+     * item whose placement is unchanged is not written to again.
+     */
+    private layout;
+    /** How tall the container is, i.e. the tallest column. */
+    blockSize: _angular_core.Signal<number>;
+    /**
+     * Whether the layout matches what is on screen: the container has been measured, and every item has
+     * reported its size at the current column width.
+     *
+     * This is the signal to gate an infinite scroll on — fetching the next page while the current one is still
+     * settling appends items against sizes that are about to change, which is what cdk needed its
+     * `injectInfinityQueryResponseDelay` handshake for. That provider only ever existed for the legacy query
+     * client, so this is the generic replacement: `disabled: !masonry.isSettled()` on the trigger, whatever the
+     * client.
+     */
+    isSettled: _angular_core.Signal<boolean>;
+    /**
+     * Whether the container itself has changed width in the last moment — a window drag, a panel opening, a
+     * sidebar collapsing. Items snap to their new columns while it is true instead of animating: the columns
+     * change every frame of a drag, so a move transition would be restarted every frame and the items would
+     * trail behind the layout they belong to.
+     */
+    isResizing: _angular_core.Signal<boolean>;
+    constructor();
+    /** @internal Where an item sits, or `null` before the first measurement. */
+    placementOf(item: MasonryItemDirective): MasonryPlacement | null;
+    /**
+     * Re-balance the columns from scratch, as if the items had just arrived.
+     *
+     * Items keep the column they were first given for as long as the column count holds, because the
+     * alternative is a grid that reshuffles itself whenever any one card changes height — expanding a
+     * description would move cards two columns away. The cost is that heights which change a lot *after* the
+     * first layout leave the columns less even than a fresh pack would, so this is the escape hatch: call it
+     * after replacing the content wholesale, and the packing balances again. A resize that changes the column
+     * count rebalances on its own.
+     */
+    repack(): void;
+    /** @internal Called by an item while it exists. */
+    registerItem(item: MasonryItemDirective): void;
+    /** @internal */
+    unregisterItem(item: MasonryItemDirective): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MasonryDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MasonryDirective, "[etMasonry]", ["etMasonry"], { "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, 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 const MASONRY_TOKEN: InjectionToken<MasonryDirective>;
 
-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 const MASONRY_ERROR_CODES: {
+    readonly PART_OUTSIDE_MASONRY: 3900;
+    readonly MISSING_ITEMS: 3901;
+};
+
+declare const MASONRY_IMPORTS: readonly [typeof MasonryDirective, typeof MasonryItemDirective];
 
 declare class NotificationActionDirective {
     private notification;
@@ -10093,11 +11648,6 @@ type NotificationManagerConfig = {
      * 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[];
@@ -10114,6 +11664,25 @@ declare const NOTIFICATION_ERROR_CODES: {
     readonly DISMISS_OUTSIDE_NOTIFICATION: 1701;
 };
 
+/** The strings a notification renders itself. Its message and actions are yours; dismissal is its own. */
+type NotificationLabels = {
+    /** Accessible label for a notification's dismiss button. */
+    dismiss: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_NOTIFICATION_LABELS: NotificationLabels;
+/**
+ * Localize a notification's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_NOTIFICATION_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideNotificationLabels({ dismiss: 'Schließen' });
+ */
+declare const provideNotificationLabels: (labels: _ethlete_core.LabelsSource<NotificationLabels>) => _angular_core.Provider;
+declare const injectNotificationLabels: () => _angular_core.Signal<NotificationLabels>;
+declare const NOTIFICATION_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<NotificationLabels>>;
+
 type NotificationEntry = {
     id: string;
     config: NotificationConfig;
@@ -10165,6 +11734,7 @@ declare class NotificationComponent {
     private provideTheme;
     private provideSurface;
     private managerConfig;
+    private labels;
     private surfaceThemes;
     private surfaceContextTracker;
     private resolvedColor;
@@ -10289,7 +11859,7 @@ declare class OverlayContainerComponent {
     };
     component: _angular_core.InputSignal<Type<object>>;
     componentBindings: _angular_core.InputSignal<Binding[] | undefined>;
-    renderArrow: _angular_core.InputSignal<boolean>;
+    renderArrow: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private contentOutlet;
     animatedLifecycle: _angular_core.WritableSignal<AnimatedLifecycleDirective>;
     contentComponentRef: _angular_core.WritableSignal<ComponentRef<object> | null>;
@@ -10392,6 +11962,7 @@ declare const OVERLAY_ERROR_CODES: {
     readonly NESTED_OVERLAY_MAIN: 1206;
     readonly REF_OUTSIDE_OVERLAY: 1207;
     readonly MISSING_OVERLAY_MAIN: 1208;
+    readonly MISSING_ANIMATION_ORIGIN: 1209;
 };
 
 declare const OVERLAY_FOOTER_TOKEN: InjectionToken<OverlayFooterDirective>;
@@ -11062,11 +12633,24 @@ declare const injectLeftSheetStrategy: {
 };
 declare const leftSheetOverlayStrategy: (config?: Partial<OverlayBreakpointConfig>) => (() => OverlayStrategyBreakpoint[]);
 
+/** The momentum a dismissing gesture had when the pointer let go, so the exit can carry it. */
+type DragDismissMomentum = {
+    /** Release speed along the dismiss axis in px/s. Always positive. */
+    speed: number;
+    /** How far the overlay still has to travel to clear its docked edge, in px. */
+    remainingDistance: number;
+};
 type DragToDismissContext = {
     element: HTMLElement;
     overlayRef: OverlayRef<object, unknown>;
     config: OverlayDragToDismissConfig;
     renderer: AngularRenderer;
+    /**
+     * Called immediately before the gesture closes the overlay, with the momentum of the release. The
+     * sheet strategy uses it to give the leave transition the speed of the swipe instead of a fixed
+     * duration — see `createSheetStrategy`.
+     */
+    onDismiss?: (momentum: DragDismissMomentum) => void;
 };
 type DragToDismissRef = {
     unsubscribe: () => void;
@@ -11216,11 +12800,10 @@ type PaginationLabels = {
 };
 /** The built-in English labels. */
 declare const DEFAULT_PAGINATION_LABELS: PaginationLabels;
-/** The label set every paginator in this injector uses. @default DEFAULT_PAGINATION_LABELS */
-declare const PAGINATION_LABELS: InjectionToken<PaginationLabels>;
 /**
- * Localize the paginator's strings for everything below this injector. Partial — whatever you leave
- * out keeps its {@link DEFAULT_PAGINATION_LABELS} value.
+ * Localize the paginator's strings for everything below this injector, and read the set in effect
+ * here as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_PAGINATION_LABELS}
+ * value. See {@link createLabels} for the shape, which every domain in this library shares.
  *
  * @example
  * providePaginationLabels({
@@ -11230,8 +12813,9 @@ declare const PAGINATION_LABELS: InjectionToken<PaginationLabels>;
  *   range: ({ start, end, totalItems }) => `Zeige ${start}–${end} von ${totalItems}`,
  * });
  */
-declare const providePaginationLabels: (labels: Partial<PaginationLabels>) => Provider;
-declare const injectPaginationLabels: () => PaginationLabels;
+declare const providePaginationLabels: (labels: _ethlete_core.LabelsSource<PaginationLabels>) => _angular_core.Provider;
+declare const injectPaginationLabels: () => _angular_core.Signal<PaginationLabels>;
+declare const PAGINATION_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<PaginationLabels>>;
 
 /** The kind of control a {@link PaginationItem} represents. */
 type PaginationItemType = 'first' | 'previous' | 'page' | 'ellipsis' | 'next' | 'last';
@@ -11282,15 +12866,15 @@ declare class PaginationDirective {
     /** The active page (1-based). Two-way bindable. */
     page: _angular_core.ModelSignal<number>;
     /** Total number of pages. */
-    totalPages: _angular_core.InputSignal<number>;
+    totalPages: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Pages shown on each side of the current page. @default 1 */
-    siblingCount: _angular_core.InputSignal<number>;
+    siblingCount: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Pages shown at each edge before an ellipsis. @default 1 */
-    boundaryCount: _angular_core.InputSignal<number>;
+    boundaryCount: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Omit the first/last jump controls. @default false */
-    hideFirstLast: _angular_core.InputSignal<boolean>;
+    hideFirstLast: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Omit the previous/next controls. @default false */
-    hidePreviousNext: _angular_core.InputSignal<boolean>;
+    hidePreviousNext: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Accessible label for the navigation landmark. `null` (the default) uses the resolved
      * {@link PaginationLabels}' `navigation` label — set this only to distinguish one paginator from
@@ -11384,7 +12968,7 @@ declare class PaginationComponent {
     /** Items per page, used to compute the readout range. */
     pageSize: _angular_core.InputSignal<number | null>;
     /** Show a jump-to-page number field (useful for very large page counts). @default false */
-    showJumpTo: _angular_core.InputSignal<boolean>;
+    showJumpTo: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private listEl;
     private itemEls;
     private hostDimensions;
@@ -11484,6 +13068,227 @@ declare class PaginationSeoDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PaginationSeoDirective, "[etPaginationSeo]", never, { "urlForPage": { "alias": "etPaginationSeo"; "required": false; "isSignal": true; }; "pageTitle": { "alias": "pageTitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * One candidate set for a `<picture>`, i.e. one `<source>` element.
+ *
+ * @see https://web.dev/learn/design/responsive-images
+ */
+type PictureSource = {
+    /**
+     * The image's mime type, e.g. `image/webp`. Inferred from the URL when omitted; a URL it can't be
+     * inferred from logs an error in dev mode rather than throwing, since the browser copes without it.
+     */
+    type?: string | null;
+    /**
+     * A single URL, or a comma-separated candidate list with descriptors.
+     *
+     * With **width** descriptors (`400w`) you must also give `sizes`, or the browser has no way to know how
+     * much of the viewport the image will occupy. With **density** descriptors (`2x`) you must not — the
+     * browser picks by device pixel ratio. The two forms can't be mixed in one srcset.
+     *
+     * @example 'https://example.com/hero.jpg'
+     * @example 'https://example.com/hero.jpg 1x, https://example.com/hero@2x.jpg 2x'
+     * @example 'https://example.com/hero-400.jpg 400w, https://example.com/hero-800.jpg 800w'
+     */
+    srcset: string;
+    /**
+     * How much space the image will take, so the browser can pick a candidate before it has laid the page
+     * out. Only meaningful alongside width descriptors. Falls back to the picture's own `sizes`.
+     *
+     * @example '100vw'
+     * @example '(min-width: 800px) 50vw, 100vw'
+     */
+    sizes?: string | null;
+    /**
+     * The media query this source applies to — this is what makes art direction possible, as opposed to
+     * merely picking a resolution.
+     *
+     * @example '(min-width: 800px)'
+     * @example '(orientation: portrait)'
+     */
+    media?: string | null;
+};
+type PictureConfig = {
+    /**
+     * Prefixed onto every relative `srcset` entry, so sources can be authored as API paths. Absolute URLs
+     * and `data:` URIs are left alone.
+     */
+    baseUrl?: string;
+};
+/** Where the `<img>` has got to. `'loading'` until the browser reports either way. */
+declare const PICTURE_STATES: {
+    readonly LOADING: "loading";
+    readonly LOADED: "loaded";
+    readonly ERROR: "error";
+};
+type PictureState = (typeof PICTURE_STATES)[keyof typeof PICTURE_STATES];
+
+/**
+ * App- or route-wide picture defaults. Provide it where the media host is known — usually the app config, or
+ * a route that talks to a different CDN.
+ *
+ * @example
+ * providers: [providePictureConfig({ baseUrl: 'https://cdn.example.com' })]
+ */
+declare const providePictureConfig: (valueOverride?: Partial<PictureConfig> | undefined) => _angular_core.Provider[];
+declare const injectPictureConfig: {
+    (): PictureConfig;
+    (options: _angular_core.InjectOptions & {
+        optional?: false;
+    }): PictureConfig;
+    (options: _angular_core.InjectOptions): PictureConfig | null;
+};
+
+/**
+ * What to show while the image is still loading — a blurred `data:` URI, a solid block, a
+ * [skeleton](/components/skeleton). Optional; without it the space simply stays empty.
+ *
+ * @example
+ * <ng-template etPicturePlaceholder><et-skeleton-item shape="rect" /></ng-template>
+ */
+declare class PicturePlaceholderDirective {
+    templateRef: TemplateRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PicturePlaceholderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PicturePlaceholderDirective, "ng-template[etPicturePlaceholder]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * What to show when the image fails to load. Optional — without it a broken image renders as the browser's
+ * broken-image icon, which is rarely what a page wants.
+ *
+ * @example
+ * <ng-template etPictureError><p>This image is unavailable.</p></ng-template>
+ */
+declare class PictureErrorDirective {
+    templateRef: TemplateRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PictureErrorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PictureErrorDirective, "ng-template[etPictureError]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A responsive image: `<figure><picture><source…><img></picture><figcaption></figure>` from a list of sources.
+ *
+ * Two different jobs share the one element, and it is worth knowing which one you are doing. Several
+ * candidates in a **single** source's `srcset` is *resolution switching* — the same picture at several sizes,
+ * and the browser picks. Several **sources** with `media` queries is *art direction* — a different crop for a
+ * phone than for a desktop, which no `srcset` can express. `type` on a source is a third axis: offer AVIF
+ * before JPEG and a browser that can't decode it skips to the next without downloading anything.
+ *
+ * Reserve the space the image will occupy — `width`/`height`, or `aspectRatio` when only the ratio is known —
+ * or the page will shift when it loads.
+ *
+ * @example
+ * <et-picture
+ *   [sources]="[
+ *     { srcset: 'hero-wide.avif', media: '(min-width: 800px)' },
+ *     { srcset: 'hero-tall.avif' },
+ *   ]"
+ *   defaultSrc="hero.jpg"
+ *   alt="The stadium at kickoff"
+ *   [aspectRatio]="16 / 9"
+ * />
+ */
+declare class PictureComponent {
+    private config;
+    /**
+     * The `<source>` candidates, in the order the browser should consider them — first match wins, so put the
+     * most specific `media` and the most modern `type` first. A plain string is shorthand for
+     * `{ srcset: theString }`.
+     */
+    sources: _angular_core.InputSignal<(string | PictureSource)[]>;
+    /**
+     * The `<img>` behind the sources: what a browser loads when no `<source>` matched, and the element every
+     * `<picture>` needs — a `<picture>` with no `<img>` renders nothing at all. Give it the most compatible
+     * format you have.
+     */
+    defaultSrc: _angular_core.InputSignal<string | PictureSource | null>;
+    /**
+     * The image's alternative text. **Required**, because an image without it is invisible to a screen reader
+     * and unaccounted for by a linter — pass `''` for a decorative image, which is a deliberate statement that
+     * it carries no information.
+     */
+    alt: _angular_core.InputSignal<string>;
+    /** A visible caption, rendered as `<figcaption>` after the image. Omit for an image that needs none. */
+    figcaption: _angular_core.InputSignal<string | null>;
+    /**
+     * Load this image eagerly and at high priority, instead of lazily. For the one image that is the largest
+     * thing in the initial viewport (a hero, a header) — it is usually the page's Largest Contentful Paint, and
+     * lazy-loading it delays the metric it defines. Never for images below the fold. @default false
+     */
+    priority: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The image's intrinsic width in px, set as the `width` attribute. Together with `height` this reserves the
+     * space before the image arrives, which is what stops the page shifting.
+     */
+    width: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    /** The image's intrinsic height in px, set as the `height` attribute. */
+    height: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    /**
+     * The ratio to hold the image's box at, e.g. `16 / 9`. The alternative to `width`/`height` for a responsive
+     * image whose rendered size is decided by CSS: one number reserves the space in a layout where the pixel
+     * dimensions are not known in advance.
+     */
+    aspectRatio: _angular_core.InputSignal<string | number | null>;
+    /**
+     * How much space the image will occupy, for sources using width descriptors. Takes the attribute's own
+     * comma-separated form, or an array of its parts, which is easier to read.
+     *
+     * @example [sizes]="['(min-width: 800px) 50vw', '100vw']"
+     */
+    sizes: _angular_core.InputSignalWithTransform<string | null, string | string[] | null | undefined>;
+    /** The image finished loading. */
+    imgLoad: _angular_core.OutputEmitterRef<void>;
+    /** The image failed to load — a dead URL, a network error, an undecodable file. */
+    imgError: _angular_core.OutputEmitterRef<void>;
+    protected placeholder: _angular_core.Signal<PicturePlaceholderDirective | undefined>;
+    protected errorSlot: _angular_core.Signal<PictureErrorDirective | undefined>;
+    protected resolvedSources: _angular_core.Signal<PictureSource[]>;
+    protected resolvedDefaultSource: _angular_core.Signal<PictureSource | null>;
+    /** The `src` for the fallback `<img>`, which needs a single URL rather than a candidate list. */
+    protected defaultSrcUrl: _angular_core.Signal<string | null>;
+    /**
+     * Reset by the source it describes: a picture pointed at a new URL is loading again, and a state that
+     * stayed `'loaded'` would leave the placeholder hidden for the second image.
+     */
+    private loadState;
+    /**
+     * Where the image has got to, as a signal rather than only a pair of events — so a template can react to it
+     * without keeping its own copy. Also on the host as `data-state`, for styling.
+     */
+    state: _angular_core.Signal<PictureState>;
+    protected markLoaded(): void;
+    protected markFailed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PictureComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PictureComponent, "et-picture", never, { "sources": { "alias": "sources"; "required": false; "isSignal": true; }; "defaultSrc": { "alias": "defaultSrc"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": true; "isSignal": true; }; "figcaption": { "alias": "figcaption"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; "sizes": { "alias": "sizes"; "required": false; "isSignal": true; }; }, { "imgLoad": "imgLoad"; "imgError": "imgError"; }, ["placeholder", "errorSlot"], never, true, never>;
+}
+
+declare const PICTURE_IMPORTS: readonly [typeof PictureComponent, typeof PicturePlaceholderDirective, typeof PictureErrorDirective];
+
+/**
+ * The first URL out of a srcset, for the `<img src>` fallback a `<picture>` still needs — a browser that
+ * matches no `<source>` (or doesn't support `<picture>` at all) loads the `img`.
+ *
+ * Descriptors are stripped, and a `data:` URI is returned whole rather than split on its commas — base64
+ * payloads contain them, so treating one as a candidate list would truncate the image.
+ */
+declare const extractFirstImageUrl: (source: string | PictureSource | null) => string | null;
+/**
+ * A source in its full form, with the mime type filled in from the URL where it wasn't given. The type is
+ * what lets a browser skip a `<source>` it can't decode without downloading it, so it is worth inferring —
+ * but a URL that carries no extension (a signed CDN URL, an API endpoint) can't be inferred from, which
+ * warns in dev rather than throwing: the browser will simply try the source.
+ */
+declare const normalizePictureSource: (source: string | PictureSource) => PictureSource;
+/** `sizes` as the attribute wants it. An array is the readable way to author one, so both forms are taken. */
+declare const normalizePictureSizes: (sizes: string | string[] | null | undefined) => string | null;
+/**
+ * A source with the configured `baseUrl` applied, so sources can be authored as the paths an API returns.
+ *
+ * Applied **per candidate**, which is what makes a relative multi-candidate srcset work: cdk prefixed the
+ * srcset as one string, so `'a.jpg 1x, b.jpg 2x'` left the second candidate unresolved. A `data:` URI is
+ * passed through whole — its base64 payload contains commas, so it is not a candidate list.
+ */
+declare const withPictureBaseUrl: (source: PictureSource, config: PictureConfig | null) => PictureSource;
+
 type JsonKind = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'array' | 'object';
 /**
  * A recursive, collapsible, searchable JSON tree used by the query devtools value explorer. Renders
@@ -11493,7 +13298,7 @@ type JsonKind = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'array'
 declare class QueryDevtoolsJsonComponent {
     value: _angular_core.InputSignal<unknown>;
     nodeKey: _angular_core.InputSignal<string | null>;
-    depth: _angular_core.InputSignal<number>;
+    depth: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Lowercased search term; when set, the tree auto-expands and matches are highlighted. */
     search: _angular_core.InputSignal<string>;
     /** Full path of this node from the explorer root, used as the key for persisted expansion. */
@@ -11513,13 +13318,22 @@ declare class QueryDevtoolsJsonComponent {
     private localExpanded;
     protected expanded: _angular_core.Signal<boolean>;
     protected effectiveExpanded: _angular_core.Signal<boolean>;
+    protected copied: _angular_core.WritableSignal<boolean>;
+    private copiedReset$;
+    protected copyLabel: _angular_core.Signal<string>;
     protected preview: _angular_core.Signal<string>;
     protected display: _angular_core.Signal<string>;
     protected keyHit: _angular_core.Signal<boolean>;
     protected valueHit: _angular_core.Signal<boolean>;
+    constructor();
     protected childPath(key: string): string;
     protected toggle(): void;
+    /**
+     * Containers copy their whole subtree as JSON; leaves copy something pasteable — a raw string
+     * without the display quotes, so an id or url can go straight into a search box.
+     */
     protected copyValue(): void;
+    private flagCopied;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsJsonComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonComponent, "et-query-devtools-json", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "nodeKey": { "alias": "nodeKey"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "expandedPaths": { "alias": "expandedPaths"; "required": false; "isSignal": true; }; "collapsedPaths": { "alias": "collapsedPaths"; "required": false; "isSignal": true; }; "toggleFn": { "alias": "toggleFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -11532,6 +13346,7 @@ declare class QueryDevtoolsJsonComponent {
  */
 declare class QueryDevtoolsToggleComponent {
     openChange: _angular_core.OutputEmitterRef<void>;
+    protected shortcut: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsToggleComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsToggleComponent, "et-query-devtools-toggle", never, {}, { "openChange": "openChange"; }, never, never, true, never>;
 }
@@ -11586,6 +13401,7 @@ declare class QueryDevtoolsComponent {
         id: "events";
         label: string;
     })[];
+    protected readonly shortcut: string;
     protected open: _angular_core.WritableSignal<boolean>;
     protected panelHeight: _angular_core.WritableSignal<number>;
     protected resizing: _angular_core.WritableSignal<boolean>;
@@ -11743,6 +13559,257 @@ declare class QueryDevtoolsComponent {
 
 declare const QUERY_DEVTOOLS_IMPORTS: readonly [typeof QueryDevtoolsComponent];
 
+/**
+ * What the directive needs from a query in order to retry it: something executable. Both query clients satisfy
+ * it — the current client's `Query` directly, and a legacy one through
+ * [`legacyQueryErrorSource`](./query-error-legacy).
+ *
+ * Typed structurally rather than against `Query<TArgs>` so this component never has to name a client's types,
+ * which is what kept cdk's version pinned to the legacy one.
+ */
+type QueryErrorRetryTarget = {
+    execute: (executeArgs?: {
+        options?: {
+            allowCache?: boolean;
+        };
+    }) => unknown;
+};
+/** A query error, ready to render. */
+type QueryErrorView = {
+    /** The heading — from the status code, since that is the one thing every error has. */
+    title: string;
+    /** Every message the response carried, or one derived from the status code when it carried none. */
+    messages: string[];
+    /** Whether to render the messages as a list. True for a violation list, i.e. more than one message. */
+    isList: boolean;
+    /** Whether the failure is one the retry policy considers worth repeating. */
+    canRetry: boolean;
+    /** How long the retry policy would wait, in ms. `0` when it wouldn't retry at all. */
+    retryDelay: number;
+    /** The HTTP status, or `0` for a failure that never reached a server. */
+    status: number;
+};
+
+/** What a slot template is handed: the error, already worked out. */
+type QueryErrorSlotContext = {
+    $implicit: QueryErrorView;
+    error: QueryErrorView;
+};
+/**
+ * Replaces the title. The error is in scope, so a title can key off the status — "You are signed out" reads
+ * better for a 401 than the generic table entry does.
+ *
+ * @example
+ * <ng-template etQueryErrorTitle let-error>
+ *   {{ error.status === 401 ? 'You are signed out' : error.title }}
+ * </ng-template>
+ */
+declare class QueryErrorTitleDirective {
+    templateRef: TemplateRef<QueryErrorSlotContext>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryErrorTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryErrorTitleDirective, "ng-template[etQueryErrorTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Replaces the actions row, retry button included. For adding a "contact support" link, or for a recovery that
+ * isn't a retry — the retry itself stays available as `queryError.retry()`.
+ *
+ * @example
+ * <ng-template etQueryErrorActions>
+ *   <button (click)="queryError.retry()" et-button>Try again</button>
+ *   <a routerLink="/support">Contact support</a>
+ * </ng-template>
+ */
+declare class QueryErrorActionsDirective {
+    templateRef: TemplateRef<QueryErrorSlotContext>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryErrorActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryErrorActionsDirective, "ng-template[etQueryErrorActions]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Every string a query error renders. Two of them are functions of the HTTP status, because that is the only
+ * thing there is to go on when a response carries no message of its own.
+ *
+ * Defaults come from `@ethlete/query`'s status tables, in English or German depending on
+ * [`injectLocale()`](/core/providers) — so a localized app needs no configuration here at all. Override
+ * app-wide with {@link provideQueryErrorLabels}, or per instance via the `labels` input.
+ */
+type QueryErrorLabels = {
+    /** The heading for a status code, e.g. `'Not found'`. */
+    title: (status: number) => string;
+    /**
+     * The message for a status code. Used when the response carried none of its own, and as the replacement when
+     * the response's only message merely repeats the title.
+     */
+    message: (status: number) => string;
+    /** The retry button's label. */
+    retry: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_QUERY_ERROR_LABELS: QueryErrorLabels;
+/** The built-in German labels, used when the current locale is a German one. */
+declare const GERMAN_QUERY_ERROR_LABELS: QueryErrorLabels;
+/**
+ * The label set for a locale. Only English and German ship with the SDK, since those are the only status
+ * tables `@ethlete/query` carries; any other locale needs {@link provideQueryErrorLabels}.
+ */
+declare const queryErrorLabelsForLocale: (locale: string) => QueryErrorLabels;
+/**
+ * Localize a query error's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps the value the current locale gives it, so this is also how you
+ * localize into a third language while keeping English or German as the base. See {@link createLabels} for the
+ * shape, which every domain in this library shares.
+ *
+ * @example
+ * provideQueryErrorLabels({ retry: 'Réessayer', title: () => 'Une erreur est survenue' });
+ */
+declare const provideQueryErrorLabels: (labels: _ethlete_core.LabelsSource<QueryErrorLabels>) => _angular_core.Provider;
+declare const injectQueryErrorLabels: () => _angular_core.Signal<QueryErrorLabels>;
+declare const QUERY_ERROR_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<QueryErrorLabels>>;
+
+/**
+ * Turns a failed query into something renderable: a title, the messages, and whether retrying is worth
+ * offering. All state, no markup — `<et-query-error>` is this with the chrome on top.
+ *
+ * The classification work is not here, deliberately. `@ethlete/query` already normalizes every error shape it
+ * knows (class-validator arrays, Symfony violation lists, a bare `{ message }`, a plain string) into
+ * `QueryErrorResponse` before it reaches `query.error()`, and it attaches the retry policy's verdict as
+ * `retryState`. cdk re-did all of that by hand against the legacy client; this reads what the client already
+ * worked out, which is why it is client-agnostic.
+ *
+ * @example
+ * @if (usersQuery.error(); as error) {
+ *   <div etQueryError [error]="error" [query]="usersQuery">…</div>
+ * }
+ */
+declare class QueryErrorDirective {
+    private injectedLabels;
+    /**
+     * The failed query's error, i.e. `query.error()`. `null` renders nothing, so this can be bound
+     * unconditionally.
+     */
+    error: _angular_core.InputSignal<QueryErrorResponse | null>;
+    /**
+     * The query to re-run when the reader retries. Optional: without it the retry button still renders (when the
+     * error is retryable) and only emits `retry`, which is the hook for a legacy query or any other recovery.
+     */
+    query: _angular_core.InputSignal<QueryErrorRetryTarget | null>;
+    /**
+     * Show the retry button even for an error the retry policy considers final — a 404 will not fix itself, and
+     * offering to try again invites the reader to waste their time. Turn it on for a query whose failure really
+     * can be transient in a way the policy can't see. @default false
+     */
+    alwaysAllowRetry: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Per-instance label overrides, merged over the locale's set and any `provideQueryErrorLabels`. */
+    labels: _angular_core.InputSignal<Partial<QueryErrorLabels> | null>;
+    /**
+     * The reader asked to retry. Fires whether or not `query` is set, and after the query has been re-executed
+     * when it is — so it doubles as "retried" for analytics.
+     */
+    retryRequest: _angular_core.OutputEmitterRef<void>;
+    /** @internal Set by `etQueryErrorTitle`; replaces the default heading. */
+    titleSlot: _angular_core.WritableSignal<TemplateRef<QueryErrorSlotContext> | null>;
+    /** @internal Set by `etQueryErrorActions`; replaces the whole actions row. */
+    actionsSlot: _angular_core.WritableSignal<TemplateRef<QueryErrorSlotContext> | null>;
+    /** The strings in effect: the locale's set, with the injected and per-instance overrides applied. */
+    resolvedLabels: _angular_core.Signal<QueryErrorLabels>;
+    /** The error as something to render, or `null` when there is no error. */
+    view: _angular_core.Signal<QueryErrorView | null>;
+    /** Whether to offer a retry — false when there is no error at all. */
+    canRetry: _angular_core.Signal<boolean>;
+    /**
+     * Re-run the query and tell the world. Bypasses the cache: a retry exists because the last answer was
+     * unusable, so serving it again from memory would make the button do nothing.
+     */
+    retry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryErrorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryErrorDirective, "[etQueryError]", ["etQueryError"], { "error": { "alias": "error"; "required": true; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "alwaysAllowRetry": { "alias": "alwaysAllowRetry"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "retryRequest": "retryRequest"; }, never, never, true, never>;
+}
+
+declare const QUERY_ERROR_TOKEN: InjectionToken<QueryErrorDirective>;
+
+declare const QUERY_ERROR_ERROR_CODES: {
+    readonly PART_OUTSIDE_QUERY_ERROR: 4000;
+};
+
+/**
+ * A legacy `RequestError` as the current client's `QueryErrorResponse`.
+ *
+ * Nearly free, because a legacy error carries the raw `HttpErrorResponse` it came from — so the current
+ * client's own normalizer does the classifying, and a legacy error is described by exactly the same code, and
+ * judged by the same retry policy, as a current one. That is the point of the adapter: no second
+ * classification path to keep in step.
+ */
+declare const queryErrorResponseFromLegacyError: (error: RequestError) => QueryErrorResponse;
+type LegacyQueryErrorSource = {
+    /** Bind to `<et-query-error [error]="…">`. */
+    error: Signal<QueryErrorResponse | null>;
+    /** Re-runs the legacy query, bypassing its cache. */
+    retry: () => void;
+    /** Bind to `<et-query-error [query]="…">` to have the retry button call `retry` for you. */
+    retryTarget: QueryErrorRetryTarget;
+};
+/**
+ * Bridges a legacy query into `<et-query-error>`, so an app still on the V2 client gets the components-lib
+ * error UI without the component ever naming a legacy type.
+ *
+ * A separate adapter rather than a union-typed input — the same split as the select and table query adapters —
+ * so the component's API describes one client, and this file is the only thing to delete when the last legacy
+ * query is gone.
+ *
+ * The error is passed in rather than read off the query because legacy query state is an `Observable`, not a
+ * signal: how you get from `state$` to a signal is the app's choice (`toSignal`, a store, an `async` pipe
+ * feeding an input), and this adapter should not make it for you.
+ *
+ * @example
+ * private legacyUsers = legacyQueryErrorSource({
+ *   error: toSignal(this.usersQuery.state$.pipe(map((s) => (isQueryStateFailure(s) ? s.error : null)))),
+ *   query: () => this.usersQuery,
+ * });
+ *
+ * // template:
+ * @if (legacyUsers.error(); as error) {
+ *   <et-query-error [error]="error" [query]="legacyUsers.retryTarget" />
+ * }
+ */
+declare const legacyQueryErrorSource: (config: {
+    error: () => RequestError | null | undefined;
+    query?: () => AnyV2Query | AnyLegacyQuery | AnyQueryCollection | null | undefined;
+}) => LegacyQueryErrorSource;
+
+/**
+ * The default rendering of a failed query: a heading from the status, the message (or the violation list), and a
+ * retry button when the failure is one worth repeating.
+ *
+ * Render it conditionally on the error, which is also what makes the `role="alert"` announce:
+ *
+ * @example
+ * @if (usersQuery.error(); as error) {
+ *   <et-query-error [error]="error" [query]="usersQuery" />
+ * }
+ *
+ * Both the title and the whole actions row are replaceable via `etQueryErrorTitle` / `etQueryErrorActions`, so
+ * an app can key the wording off the status or add a support link without forking the component.
+ */
+declare class QueryErrorComponent {
+    /** @internal Read from the template; also the handle for a consumer reaching in with `viewChild`. */
+    queryError: QueryErrorDirective;
+    private provideColor;
+    private errorTheme;
+    /**
+     * The colour theme for the panel and its retry button. Defaults to the app's `type: 'error'` theme, which is
+     * what makes an error look like one — override for a failure that shouldn't read as alarming (a cancelled
+     * request, an empty search).
+     */
+    color: _angular_core.InputSignal<string | ColorTheme | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryErrorComponent, "et-query-error", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof QueryErrorDirective; inputs: { "error": "error"; "query": "query"; "alwaysAllowRetry": "alwaysAllowRetry"; "labels": "labels"; }; outputs: { "retryRequest": "retryRequest"; }; }, { directive: typeof _ethlete_core.ProvideColorDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const QUERY_ERROR_IMPORTS: readonly [typeof QueryErrorComponent, typeof QueryErrorDirective, typeof QueryErrorTitleDirective, typeof QueryErrorActionsDirective];
+
 /** The common placeholder shapes. Anything else is your own CSS on the item. */
 type SkeletonShape = 'text' | 'rect' | 'circle';
 /**
@@ -11797,17 +13864,21 @@ declare class SkeletonTextComponent {
  * </et-skeleton>
  */
 declare class SkeletonComponent {
+    private labels;
     /**
      * What a screen reader announces in place of the shapes, which are `aria-hidden` — they carry no
-     * information, and reading "loading" once is the whole message.
+     * information, and reading "loading" once is the whole message. `null` (the default) uses
+     * `LOADER_LABELS`' `loadingContent`; set it for something more specific ("Loading results").
      */
-    loadingAllyText: _angular_core.InputSignal<string>;
+    loadingAllyText: _angular_core.InputSignal<string | null>;
     /**
      * Run the shimmer. Off leaves a static placeholder — the same shapes without motion, which is what
      * you want inside something that already animates (an opening panel), or on a very long list.
      * Independent of `prefers-reduced-motion`, which drops the shimmer regardless. @default true
      */
     animated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The announcement in effect: this instance's `loadingAllyText`, else `LOADER_LABELS`. */
+    protected resolvedLoadingAllyText: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonComponent, "et-skeleton", never, { "loadingAllyText": { "alias": "loadingAllyText"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -11835,22 +13906,11 @@ declare class StreamConsentDirective {
 }
 
 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: {
@@ -11864,7 +13924,7 @@ declare const injectStreamConsentConfig: {
 declare class StreamConsentComponent {
     private parentSurfaceProvider;
     private config;
-    private locale;
+    private labels;
     private surfaceThemes;
     protected readonly HEADING_ID: string;
     cardSurface: _angular_core.Signal<string | null>;
@@ -11889,22 +13949,11 @@ declare class StreamPlayerErrorDirective {
 }
 
 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: {
@@ -11919,7 +13968,7 @@ declare class StreamPlayerErrorComponent {
     private errorDirective;
     private parentSurfaceProvider;
     private config;
-    private locale;
+    private labels;
     private surfaceThemes;
     cardSurface: _angular_core.Signal<string | null>;
     heading: _angular_core.Signal<string>;
@@ -11947,6 +13996,7 @@ declare const injectStreamPlayerLoadingConfig: {
 };
 
 declare class StreamPlayerLoadingComponent {
+    protected labels: _angular_core.Signal<_ethlete_components.StreamLabels>;
     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>;
@@ -12177,6 +14227,7 @@ declare class PipBackDirective {
     private chrome;
     private tokenEntry;
     private pipManager;
+    protected labels: _angular_core.Signal<_ethlete_components.StreamLabels>;
     entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     back(event: Event): void;
     private resolveEntry;
@@ -12357,6 +14408,7 @@ declare class PipCloseDirective {
     private pipWindow;
     private tokenEntry;
     private pipManager;
+    protected labels: _angular_core.Signal<_ethlete_components.StreamLabels>;
     entry: _angular_core.InputSignal<StreamPipEntry | undefined>;
     close(event: Event): void;
     private resolveEntry;
@@ -12431,20 +14483,11 @@ declare class PipPlayerComponent {
 }
 
 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: {
@@ -12460,7 +14503,7 @@ declare class PipSlotPlaceholderComponent {
     private parentSurfaceProvider;
     private pipManager;
     private config;
-    private locale;
+    private labels;
     private surfaceThemes;
     private bringBackDir;
     cardSurface: _angular_core.Signal<string | null>;
@@ -12580,6 +14623,7 @@ declare const STREAM_PLAYER_TOKEN: InjectionToken<StreamPlayer>;
 
 declare const DAILYMOTION_PLAYER_TOKEN: InjectionToken<DailymotionPlayerDirective>;
 declare class DailymotionPlayerDirective implements StreamPlayer {
+    private streamLabels;
     private platformId;
     private params;
     private el;
@@ -12695,6 +14739,7 @@ declare class KickPlayerParamsDirective implements StreamPlayerParams {
 
 declare const KICK_PLAYER_TOKEN: InjectionToken<KickPlayerDirective>;
 declare class KickPlayerDirective implements StreamPlayer {
+    private streamLabels;
     private platformId;
     private document;
     private params;
@@ -12740,6 +14785,7 @@ declare class SoopPlayerParamsDirective implements StreamPlayerParams {
 
 declare const SOOP_PLAYER_TOKEN: InjectionToken<SoopPlayerDirective>;
 declare class SoopPlayerDirective implements StreamPlayer {
+    private streamLabels;
     private platformId;
     private params;
     private el;
@@ -12784,6 +14830,7 @@ declare class TikTokPlayerParamsDirective implements StreamPlayerParams {
 
 declare const TIKTOK_PLAYER_TOKEN: InjectionToken<TikTokPlayerDirective>;
 declare class TikTokPlayerDirective implements StreamPlayer {
+    private streamLabels;
     private platformId;
     private params;
     private el;
@@ -13216,6 +15263,61 @@ declare const createStreamConfig: (valueOverride?: Partial<StreamConfig>) => {
 };
 declare const provideStreamConfig: (valueOverride?: Partial<StreamConfig>) => _angular_core.Provider[];
 
+/**
+ * Every string the stream player's own chrome renders: the consent gate, the failure overlay, the
+ * picture-in-picture placeholder and the PiP window's controls.
+ *
+ * These used to live on the `StreamConsentConfig` / `StreamPlayerErrorConfig` /
+ * `PipSlotPlaceholderConfig` objects next to a `transformer(text, locale)` hook, which asked an app to
+ * translate *by matching the English string*. They are labels, so they live where every other label in
+ * this library lives; those configs keep only what is genuinely configuration (the button colors).
+ */
+type StreamLabels = {
+    /** Announced by the loading overlay while a player is starting up. */
+    loading: string;
+    /**
+     * `title` for an embedded player's iframe, given the platform's own name — announced in place of the
+     * frame's contents. The brand name is not translated; the wording around it is.
+     */
+    playerFrame: (platform: string) => string;
+    /** The consent gate's heading. */
+    consentHeading: string;
+    /** The consent gate's explanation. */
+    consentDescription: string;
+    /** The consent gate's accept button. */
+    consentAccept: string;
+    /** The failure overlay's heading. */
+    errorHeading: string;
+    /** The failure overlay's explanation. */
+    errorDescription: string;
+    /** The failure overlay's retry button. */
+    errorRetry: string;
+    /** The placeholder shown where a player would be while it plays in picture-in-picture. */
+    pipPlaceholderMessage: string;
+    /** The placeholder's button that pulls the stream back into the page. */
+    pipPlaceholderBack: string;
+    /** Accessible label for the PiP window's close button. */
+    pipClose: string;
+    /** Accessible label for the PiP window's control that focuses the stream's page. */
+    pipFocus: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_STREAM_LABELS: StreamLabels;
+/**
+ * Localize the stream chrome's strings for everything below this injector, and read the set in effect
+ * here as a signal. Partial — whatever you leave out keeps its {@link DEFAULT_STREAM_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideStreamLabels({
+ *   consentHeading: 'Inhalt blockiert',
+ *   consentAccept: 'Erlauben und abspielen',
+ * });
+ */
+declare const provideStreamLabels: (labels: _ethlete_core.LabelsSource<StreamLabels>) => _angular_core.Provider;
+declare const injectStreamLabels: () => _angular_core.Signal<StreamLabels>;
+declare const STREAM_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<StreamLabels>>;
+
 declare const provideStreamManager: () => _angular_core.Provider[];
 declare const injectStreamManager: {
     (): StreamManager;
@@ -13363,17 +15465,17 @@ type TableLabels = {
 /** The built-in English labels. */
 declare const DEFAULT_TABLE_LABELS: TableLabels;
 /**
- * A label set, or a function building one for the **active locale** — called again whenever
- * `injectLocale()`'s `currentLocale` changes, so a locale switch re-renders the table's wording
- * without reloading. This is the seam an app's i18n library plugs into (same idea as `TitleConfig`'s
- * locale-aware `transformer`).
+ * A label set, or a function building one for the **active locale**. See {@link LabelsSource}.
+ *
+ * @deprecated Use {@link LabelsSource}`<`{@link TableLabels}`>` — the shape is shared by every domain
+ * in this library now.
  */
-type TableLabelsSource = Partial<TableLabels> | ((locale: string) => Partial<TableLabels>);
-/** What {@link provideTableLabels} stores. Read it through {@link injectTableLabels}, not directly. */
-declare const TABLE_LABELS: InjectionToken<TableLabelsSource>;
+type TableLabelsSource = LabelsSource<TableLabels>;
 /**
- * Localize the table's strings for everything below this injector. Partial — whatever you leave out
- * keeps its {@link DEFAULT_TABLE_LABELS} value.
+ * Localize the table's strings for everything below this injector, and read the set in effect here as
+ * a signal: the defaults with the provided set (or the set its factory builds for the current locale)
+ * layered on top. Partial — whatever you leave out keeps its {@link DEFAULT_TABLE_LABELS} value. See
+ * {@link createLabels} for the shape, which every domain in this library shares.
  *
  * @example
  * // fixed wording
@@ -13391,13 +15493,9 @@ declare const TABLE_LABELS: InjectionToken<TableLabelsSource>;
  *   sortAction: (header, next) => translate(`table.sort.${next ?? 'clear'}`, locale, { header }),
  * }));
  */
-declare const provideTableLabels: (labels: TableLabelsSource) => Provider;
-/**
- * The label set in effect here, as a signal: the defaults with the provided set (or the set its
- * factory builds for the current locale) layered on top. A signal because the locale can change at
- * runtime — read it in the template/computed, never destructure it once.
- */
-declare const injectTableLabels: () => Signal<TableLabels>;
+declare const provideTableLabels: (labels: LabelsSource<TableLabels>) => _angular_core.Provider;
+declare const injectTableLabels: () => _angular_core.Signal<TableLabels>;
+declare const TABLE_LABELS: _angular_core.InjectionToken<LabelsSource<TableLabels>>;
 
 /** Horizontal alignment of a column's header and cells. */
 type TableColumnAlign = 'start' | 'center' | 'end';
@@ -14263,7 +16361,7 @@ declare class TableComponent<T> {
      */
     loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** How many placeholder rows to draw while loading with no rows yet. @default 5 */
-    loadingRows: _angular_core.InputSignal<number>;
+    loadingRows: _angular_core.InputSignalWithTransform<number, unknown>;
     /**
      * The load's failure, if any — anything non-nullish counts (an `HttpErrorResponse`, a message, a
      * flag), so it takes a query's `error` signal as-is. Set, it replaces the body with the error
@@ -14307,7 +16405,7 @@ declare class TableComponent<T> {
      */
     sort: _angular_core.ModelSignal<TableSort[]>;
     /** Allow more than one column to be sorted at once. @default false */
-    multiSort: _angular_core.InputSignal<boolean>;
+    multiSort: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * `'client'` sorts the rows in the browser via {@link sortRows}; `'server'`
      * leaves rows untouched so the backend can sort.
@@ -15456,7 +17554,7 @@ declare class TabBarTriggerDirective {
     private elementRef;
     private scrollable;
     protected tabBar: _ethlete_components.TabBarDirective | null;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly ID: string;
     justActivated: _angular_core.WritableSignal<boolean>;
     isSelected: _angular_core.Signal<boolean>;
@@ -15503,7 +17601,7 @@ declare class TabBarDirective {
     orientation: _angular_core.InputSignal<TabBarOrientation>;
     fit: _angular_core.InputSignal<TabBarFit>;
     variant: _angular_core.InputSignal<TabBarVariant>;
-    divider: _angular_core.InputSignal<boolean>;
+    divider: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @internal */
     triggers: _angular_core.WritableSignal<TabBarTriggerDirective[]>;
     /** @internal */
@@ -15624,7 +17722,7 @@ declare class TabPanelDirective {
 declare class TabGroupDirective {
     tabBar: TabBarDirective;
     private elementRef;
-    preserveContent: _angular_core.InputSignal<boolean>;
+    preserveContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
     selectedIndex: _angular_core.ModelSignal<number>;
     sessionMemoryKey: _angular_core.InputSignal<string | null>;
     private sessionMemoryAvailable;
@@ -15666,7 +17764,7 @@ declare class TabComponent {
     private tabGroup;
     label: _angular_core.InputSignal<string>;
     icon: _angular_core.InputSignal<string | null>;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     customLabel: _angular_core.Signal<TabLabelDirective | undefined>;
     /** @internal */
     implicitLabelRef: _angular_core.Signal<TemplateRef<unknown>>;
@@ -15721,19 +17819,28 @@ type TimePickerColumn = {
  * only — string parsing/formatting belongs to the input directives.
  */
 declare class TimePickerDirective {
+    private timePickerLabels;
     private defaultFormat;
     private defaultLocale;
     /** date-fns time format the column layout derives from. Defaults to the `TIME_FORMAT` token. */
     format: _angular_core.InputSignal<string | undefined>;
     locale: _angular_core.InputSignal<Locale | null>;
-    minuteStep: _angular_core.InputSignal<number>;
-    secondStep: _angular_core.InputSignal<number>;
-    hoursLabel: _angular_core.InputSignal<string>;
-    minutesLabel: _angular_core.InputSignal<string>;
-    secondsLabel: _angular_core.InputSignal<string>;
-    periodLabel: _angular_core.InputSignal<string>;
+    minuteStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    secondStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    hoursLabel: _angular_core.InputSignal<string | null>;
+    minutesLabel: _angular_core.InputSignal<string | null>;
+    secondsLabel: _angular_core.InputSignal<string | null>;
+    periodLabel: _angular_core.InputSignal<string | null>;
     /** The selected time of day, carried on a `Date`. Stays `null` until a part is picked. */
     value: _angular_core.ModelSignal<Date | null>;
+    /** The string in effect: this instance's `hoursLabel`, else the domain's label set. */
+    resolvedHoursLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `minutesLabel`, else the domain's label set. */
+    resolvedMinutesLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `secondsLabel`, else the domain's label set. */
+    resolvedSecondsLabel: _angular_core.Signal<string>;
+    /** The string in effect: this instance's `periodLabel`, else the domain's label set. */
+    resolvedPeriodLabel: _angular_core.Signal<string>;
     private now;
     effectiveFormat: _angular_core.Signal<string>;
     effectiveLocale: _angular_core.Signal<Locale | null>;
@@ -15812,6 +17919,31 @@ declare const TIME_PICKER_ERROR_CODES: {
     readonly OPTION_OUTSIDE_COLUMN: 3021;
 };
 
+/** The strings the time picker's columns announce — each is a listbox of numbers with no visible label. */
+type TimePickerLabels = {
+    /** Accessible label for the hours column. */
+    hours: string;
+    /** Accessible label for the minutes column. */
+    minutes: string;
+    /** Accessible label for the seconds column. */
+    seconds: string;
+    /** Accessible label for the AM/PM column. */
+    period: string;
+};
+/** The built-in English labels. */
+declare const DEFAULT_TIME_PICKER_LABELS: TimePickerLabels;
+/**
+ * Localize the time picker's strings for everything below this injector, and read the set in effect here as a
+ * signal. Partial — whatever you leave out keeps its {@link DEFAULT_TIME_PICKER_LABELS} value. See {@link createLabels}
+ * for the shape, which every domain in this library shares.
+ *
+ * @example
+ * provideTimePickerLabels({ hours: 'Stunden', minutes: 'Minuten' });
+ */
+declare const provideTimePickerLabels: (labels: _ethlete_core.LabelsSource<TimePickerLabels>) => _angular_core.Provider;
+declare const injectTimePickerLabels: () => _angular_core.Signal<TimePickerLabels>;
+declare const TIME_PICKER_LABELS: _angular_core.InjectionToken<_ethlete_core.LabelsSource<TimePickerLabels>>;
+
 declare class TimePickerComponent {
     protected timePicker: TimePickerDirective;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerComponent, never>;
@@ -15832,9 +17964,15 @@ declare class ToggletipDirective {
     placement: _angular_core.InputSignal<Placement>;
     fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
     offset: _angular_core.InputSignal<OffsetOptions | null>;
+    /**
+     * How close the arrow may get to the panel's corners. Must clear the panel's border radius
+     * (`--_et-toggletip-radius`, 16px) or the arrow's base rides into the rounded corner — which is what
+     * happens on aligned placements (`bottom-end`, `left-start`, …) and whenever `shift` pushes a panel
+     * off center near a viewport edge.
+     */
     arrowPadding: _angular_core.InputSignal<Padding | null>;
     viewportPadding: _angular_core.InputSignal<Padding | null>;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     open: _angular_core.ModelSignal<boolean>;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<ToggletipComponent, unknown> | null>;
@@ -15926,10 +18064,16 @@ declare class TooltipDirective {
     placement: _angular_core.InputSignal<Placement>;
     fallbackPlacements: _angular_core.InputSignal<Placement[] | undefined>;
     offset: _angular_core.InputSignal<OffsetOptions | null>;
+    /**
+     * How close the arrow may get to the panel's corners. Must clear the panel's border radius
+     * (`--_et-tooltip-radius`, 16px) or the arrow's base rides into the rounded corner — which is what
+     * happens on aligned placements (`bottom-end`, `left-start`, …) and whenever `shift` pushes a panel
+     * off center near a viewport edge.
+     */
     arrowPadding: _angular_core.InputSignal<Padding | null>;
     viewportPadding: _angular_core.InputSignal<Padding | null>;
     showDelay: _angular_core.InputSignal<number>;
-    disabled: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @internal */
     overlayRef: _angular_core.WritableSignal<OverlayRef<TooltipComponent, unknown> | null>;
     private hasHover;
@@ -15941,6 +18085,12 @@ declare class TooltipDirective {
     show(): void;
     hide(): void;
     private setupHoverBehavior;
+    /**
+     * A tooltip can outlive the hover that opened it — a `pointercancel`, a scroll that moves the
+     * trigger out from under the pointer, or a browser that synthesizes an enter with no matching
+     * leave. A press anywhere else is unambiguous, so treat it as a dismissal.
+     */
+    private dismissOnOutsidePointer;
     private setupFocusBehavior;
     private syncHostDescription;
     private syncDescriptionElement;
@@ -15955,5 +18105,5 @@ declare const TOOLTIP_ERROR_CODES: {
 
 declare const TOOLTIP_IMPORTS: readonly [typeof TooltipDirective, typeof TooltipComponent];
 
-export { ACCORDION_ERROR_CODES, ACCORDION_GROUP_TOKEN, ACCORDION_IMPORTS, ACCORDION_TOKEN, ALIGN_CENTER_ICON, ALIGN_JUSTIFY_ICON, ALIGN_LEFT_ICON, ALIGN_RIGHT_ICON, ARROWS_LEFT_RIGHT_ICON, ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, ARROW_UP_ICON, AccordionComponent, AccordionContentDirective, AccordionDirective, AccordionGroupComponent, AccordionGroupDirective, AccordionHintDirective, AccordionLabelDirective, AccordionPanelDirective, AccordionTriggerDirective, BOLD_ICON, BRACKET_DATA_LAYOUT, BRACKET_ERROR_CODES, BRACKET_IMPORTS, BRACKET_ROUND_MIRROR_TYPE, BRACKET_SWISS_GROUP_COLOR_TYPE, BREADCRUMB_ERROR_CODES, BREADCRUMB_IMPORTS, BREADCRUMB_LABELS, BREADCRUMB_SEGMENT_TOKEN, BREADCRUMB_TOKEN, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BracketComponent, BracketDefaultContinueComponent, BracketDefaultMatchComponent, BracketDefaultRoundHeaderComponent, BracketMap, BrandLoaderComponent, BreadcrumbComponent, BreadcrumbDirective, BreadcrumbItemDirective, BreadcrumbItemTemplateDirective, BreadcrumbOutletComponent, BreadcrumbSegmentDirective, BreadcrumbSeparatorDirective, ButtonComponent, ButtonDirective, ButtonStylesDirective, CALENDAR_ERROR_CODES, CALENDAR_ICON, CALENDAR_IMPORTS, CAROUSEL_AUTOPLAY_TOKEN, CAROUSEL_ERROR_CODES, CAROUSEL_IMPORTS, CAROUSEL_LABELS, CAROUSEL_SLIDE_ALIGNMENTS, CAROUSEL_TOKEN, CAROUSEL_TRANSITIONS, CAROUSEL_TRANSITION_DRIVERS, CASCADER_ERROR_CODES, CASCADER_IMPORTS, CASCADER_SELECTABLE_LEVELS, CHECKBOX_IMPORTS, CHECK_ICON, CHEVRON_ICON, CHIP_ERROR_CODES, CHIP_IMPORTS, CHOICE_FIELD_IMPORTS, CLIPBOARD_CHECK_ICON, CLOCK_ICON, CODE_ICON, COLOR_INPUT_IMPORTS, COMMON_BRACKET_ROUND_TYPE, CalendarCellDirective, CalendarComponent, CalendarDirective, CalendarGridDirective, CarouselAutoplayDirective, CarouselComponent, CarouselDirective, CarouselItemDirective, CarouselNextDirective, CarouselPlayToggleDirective, CarouselPreviousDirective, CarouselSlideDirective, CascaderColumnDirective, CascaderComponent, CascaderDirective, CascaderNodeDirective, CascaderPanelComponent, CascaderSearchDirective, CascaderSearchOptionDirective, CascaderSurfaceDirective, CascaderTriggerDirective, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChipComponent, ChipDirective, ChipRemoveDirective, ChoiceFieldComponent, ColorInputComponent, ColorInputDirective, DAILYMOTION_PLAYER_TOKEN, DATE_FORMAT, DATE_INPUT_ERROR_CODES, DATE_INPUT_IMPORTS, DATE_LOCALE, DATE_PICKER_HOST, DATE_RANGE_INPUT_ERROR_CODES, DATE_RANGE_INPUT_IMPORTS, DATE_TIME_INPUT_ERROR_CODES, DATE_TIME_INPUT_IMPORTS, DEFAULT_BREADCRUMB_LABELS, DEFAULT_BREAKPOINTS, DEFAULT_CAROUSEL_LABELS, DEFAULT_ICON_VARIANT, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PAGINATION_LABELS, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_RICH_TEXT_EDITOR_TOOLS, DEFAULT_STREAM_PLAYER_STATE, DEFAULT_TABLE_LABELS, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, DROPZONE_ENTRY_STATUSES, DROPZONE_ERROR_CODES, DROPZONE_FILES_ERROR_KIND, DROPZONE_FILE_CONSTRAINTS, DROPZONE_FILE_REJECTION_REASONS, DROPZONE_IMPORTS, DURATION_INPUT_ERROR_CODES, DURATION_INPUT_IMPORTS, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DateInputComponent, DateInputDirective, DateInputFieldDirective, DatePickerPanelComponent, DatePickerSurfaceDirective, DatePickerTriggerDirective, DateRangeInputComponent, DateRangeInputDirective, DateRangeInputFieldDirective, DateTimeInputComponent, DateTimeInputDirective, DateTimeInputFieldDirective, DescriptionComponent, DropzoneComponent, DropzoneDirective, DurationInputComponent, DurationInputDirective, DurationInputFieldDirective, ELLIPSIS_VERTICAL_ICON, ET_BUILT_IN_ICON_NAMES, EYE_ICON, EYE_SLASH_ICON, FACEBOOK_PLAYER_TOKEN, FILE_ICON, FILTER_ICON, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_ERROR_MESSAGE_RESOLVER, 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_IMPORTS, GRID_TOKEN, GROUP_BRACKET_ROUND_TYPE, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridItemComponent, GridItemDefaultActionsComponent, GridItemDirective, GridItemRef, GridItemToolbarComponent, GridResizeDirective, HEADING_1_ICON, HEADING_2_ICON, HEADING_3_ICON, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, ICON_OVERRIDES_TOKEN, INITIAL_SUPPORT_PRESENTATION_STATE, INPUT_IMPORTS, INPUT_MASK_HOST, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, INTERACTIVE_TAGS, ITALIC_ICON, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputMaskDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LINK_ICON, LIST_BULLETED_ICON, LIST_NUMBERED_ICON, LOCK_ICON, LabelDirective, MASKED_INPUT_ERROR_CODES, MASKED_INPUT_IMPORTS, MASK_VALUE_MODES, MENU_ERROR_CODES, MENU_IMPORTS, MENU_ITEM_VARIANTS, MENU_SELECTION_GROUP_MULTIPLE, MENU_SELECTION_GROUP_TOKEN, MENU_SELECTION_ITEM_KIND, MINUS_ICON, MULTI_LANGUAGE_RICH_TEXT_EDITOR_ERROR_CODES, MULTI_LANGUAGE_RICH_TEXT_EDITOR_IMPORTS, MenuCheckboxGroupComponent, MenuCheckboxItemComponent, MenuComponent, MenuContextTriggerDirective, MenuDirective, MenuGroupLabelComponent, MenuItemComponent, MenuItemDirective, MenuItemShortcutComponent, MenuPanelDirective, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSearchDirective, MenuSelectionGroupDirective, MenuSelectionItemDirective, MenuSeparatorComponent, MenuSurfaceDirective, MenuTriggerDirective, MultiLanguageRichTextEditorComponent, MultiLanguageRichTextEditorDirective, MultiLanguageRichTextEditorLanguageToolComponent, NAV_TABS_TOKEN, NAV_TAB_IMPORTS, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NUMBER_INPUT_IMPORTS, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, NumberInputComponent, NumberInputDirective, OTP_INPUT_IMPORTS, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CONFIG_CLASS_KEYS, OVERLAY_CONTENT_IMPORTS, OVERLAY_ERROR_CODES, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_IMPORTS, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_REF, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_ROUTER_TOKEN, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OtpInputComponent, OtpInputDirective, OverlayAnchorDirective, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseDirective, OverlayContainerComponent, OverlayDirective, OverlayFooterDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayMainDirective, OverlayOriginCloneComponent, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlaySurfaceDirective, OverlayTitleDirective, OverlayTriggerDirective, PAGINATION_IMPORTS, PAGINATION_LABELS, PARAGRAPH_ICON, PASSWORD_INPUT_IMPORTS, PAUSE_ICON, PENCIL_ICON, PHONE_COUNTRIES, PHONE_INPUT_ERROR_CODES, PHONE_INPUT_IMPORTS, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLAY_ICON, PLUS_ICON, PaginationComponent, PaginationDirective, PaginationSeoDirective, PasswordInputComponent, PasswordInputDirective, PhoneInputComponent, PhoneInputDirective, PhoneInputFieldDirective, PhoneInputFlagDirective, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, QUERY_DEVTOOLS_IMPORTS, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsToggleComponent, QueryParamOverlayLinkDirective, RATING_IMPORTS, RICH_TEXT_EDITOR_HEADING_OPTIONS, RICH_TEXT_EDITOR_IMPORTS, RICH_TEXT_EDITOR_INLINE_TOOLS, RICH_TEXT_EDITOR_LANGUAGE_TOOL, RICH_TEXT_EDITOR_TOKEN_CODEC, RICH_TEXT_EDITOR_TOKEN_PALETTE_IMPORTS, RICH_TEXT_EDITOR_TOOL, RICH_TEXT_EDITOR_TOOLS, RICH_TEXT_EDITOR_TOOL_BUTTONS, RICH_TEXT_EDITOR_TRIGGERS_IMPORTS, ROTATE_RIGHT_ICON, RadioComponent, RadioGroupComponent, RangeSliderComponent, RangeSliderDirective, RatingComponent, RatingDirective, RatingIconDirective, RichTextEditorAlignToolComponent, RichTextEditorComponent, RichTextEditorDirective, RichTextEditorFloatingToolbarComponent, RichTextEditorFloatingToolbarDirective, RichTextEditorLinkEditorComponent, RichTextEditorLinkEditorDirective, RichTextEditorTableToolComponent, RichTextEditorTokenPaletteComponent, RichTextEditorTokenPopupComponent, RichTextEditorTriggersDirective, SCROLLABLE_ERROR_CODES, SCROLLABLE_IMPORTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SELECT_ERROR_CODES, SELECT_FILTER_MODES, SELECT_IMPORTS, SIDEBAR_OVERLAY_CONFIG, SIDEBAR_OVERLAY_TOKEN, SINGLE_ELIMINATION_BRACKET_ROUND_TYPE, SKELETON_IMPORTS, SLIDER_ERROR_CODES, SLIDER_IMPORTS, SLIDER_TOKEN, SNAP_HYSTERESIS, SOOP_PLAYER_TOKEN, SPLIT_BUTTON_ERROR_CODES, STAR_ICON, STREAM_CONSENT_TOKEN, STREAM_IMPORTS, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SUPPORT_CONTENT_STATE, SUPPORT_TRANSITION_DIRECTION, SWISS_ADVANCE_WINS, SWISS_BRACKET_ROUND_TYPE, SWISS_ELIMINATE_LOSSES, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectComponent, SelectDirective, SelectEmptyDirective, SelectErrorDirective, SelectListboxDirective, SelectLoadingDirective, SelectOptionComponent, SelectOptionDirective, SelectOptionGroupComponent, SelectOptionGroupDirective, SelectOptionTemplateDirective, SelectOptionsDirective, SelectPanelComponent, SelectSearchDirective, SelectSurfaceDirective, SelectTriggerDirective, SelectValueDirective, SelectViewportDirective, SelectVirtualOptionComponent, SelectVirtualOptionDirective, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SkeletonComponent, SkeletonItemComponent, SkeletonTextComponent, SliderComponent, SliderDirective, SliderThumbDirective, SliderThumbLabelDirective, SliderTrackDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, SplitButtonActionDirective, SplitButtonComponent, SplitButtonDirective, SplitButtonTriggerDirective, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TABLE_CELL_ERROR_TOOLTIP_IMPORTS, TABLE_COLUMN_CHOOSER_IMPORTS, TABLE_COLUMN_MENU_IMPORTS, TABLE_ERROR_CODES, TABLE_FEATURE_HOST, TABLE_FILTER_IMPORTS, TABLE_ICON, TABLE_IMPORTS, TABLE_LABELS, TABLE_REORDER_IMPORTS, TABLE_RESIZE_IMPORTS, TABLE_SELECTION_IMPORTS, TABLE_STATE_PERSISTENCE_IMPORTS, TABLE_VIRTUAL_SCROLL_IMPORTS, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_IMPORTS, TAB_PANEL_TOKEN, TAB_SIZES, TAG_INPUT_ERROR_CODES, TAG_INPUT_IMPORTS, TEXTAREA_IMPORTS, TEXTAREA_RESIZE_MODES, TEXT_ALIGNS, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TIME_FORMAT, TIME_INPUT_ERROR_CODES, TIME_INPUT_IMPORTS, TIME_PICKER_ERROR_CODES, TIME_PICKER_IMPORTS, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TOURNAMENT_MODE, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TableCellDirective, TableCellErrorMarkComponent, TableCellErrorTooltipDirective, TableCellSkeletonDirective, TableColumnChooserComponent, TableColumnMenuDirective, TableColumnMenuTriggerComponent, TableComponent, TableDetailStylesComponent, TableExpanderCellComponent, TableFilterOptionDirective, TableFilterTriggerComponent, TableFiltersDirective, TableFooterCellDirective, TableFooterDirective, TableHeaderCellDirective, TableReorderDirective, TableReorderOverlayComponent, TableResizeDirective, TableResizeGripComponent, TableSelectAllCellComponent, TableSelectCellComponent, TableSelectionDirective, TableStatePersistenceDirective, TableVirtualScrollDirective, TableVirtualScrollStylesComponent, TagInputComponent, TagInputDirective, TagInputFieldDirective, TextButtonComponent, TextFieldControlDirective, TextareaComponent, TextareaDirective, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, TimeInputComponent, TimeInputDirective, TimeInputFieldDirective, TimePickerColumnDirective, TimePickerComponent, TimePickerDirective, TimePickerOptionDirective, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, UNDERLINE_ICON, UNIT_MS, UPLOAD_ICON, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, abortFullscreenAnimation, anchoredDialogOverlayStrategy, anchoredOverlayStrategy, autoPlace, bottomSheetOverlayStrategy, buildAnchoredRuntimePositionStrategy, canHaveChildren, canRenderLayoutInTournamentMode, cascaderFromQuery, centeredOverlayStrategy, clampPosition, clampResizeRect, cleanupFullscreenAnimation, cleanupFullscreenAnimationStyles, compactLayout, computeGeometry, computeGridHeight, createAnchoredPanelController, createAutoScroller, createBracket, createBracketBase, createCardMask, createCurrencyMask, createDefaultDropzoneArgs, createDropzoneUpload, createExistingDropzoneEntry, createFileDropzoneEntry, createGridAdapter, createIbanMask, createMatchesMapBase, createNewMatchParticipantBase, createNotificationRef, createOverlayOpener, createOverlayRef, createOverlayStrategyController, createOverlayUnsavedChangesGuard, createParticipantsMapBase, createPipChromeAnimations, createPipChromeState, createRichTextEditorTrigger, createRichTextEditorTriggerWithQuery, createRoundsMapBase, createStreamConfig, createStreamPlayerSlot, createTableRowsSource, createTableStateStorage, createV2DropzoneUpload, defaultCompareWith, defaultDropzoneRejectionMessage, defineOverlay, defineQueryParamOverlay, deriveDurationFormatSpec, deserializeGridLayout, deserializeTableState, dialogOverlayStrategy, disposeDropzoneEntry, dropzoneFiles, enableDragToDismiss, filterRows, findCollision, findNextRelevantHtmlElement, findScrollableAncestor, formatDuration, formatFileSize, fromGridPosition, fullScreenDialogOverlayStrategy, generateBracketDataForEthlete, generateBracketRoundSwissGroupMaps, generateMatchPosition, generateMatchRelationPositions, generateMatchRelationsNew, generateRoundRelationsNew, generateRoundTypeFromEthleteRoundType, generateTournamentModeFormEthleteRounds, getAvailableSwissGroupsForRound, getClosestOverlay, getOriginCoordinatesAndDimensions, getSwissGroupColorType, hysteresisRound, iconRegistryKey, indexOfNode, injectAnchoredDialogStrategy, injectAnchoredDialogStrategyDefaults, injectBottomSheetStrategy, injectBottomSheetStrategyDefaults, injectBracketConfig, injectBreadcrumbLabels, injectBreadcrumbManager, injectCarouselLabels, injectDateFormat, injectDateLocale, injectDialogStrategy, injectDialogStrategyDefaults, injectFormSupport, injectFullscreenDialogStrategy, injectFullscreenDialogStrategyDefaults, injectGridConfig, injectLeftSheetStrategy, injectLeftSheetStrategyDefaults, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectOverlayRouter, injectOverlayScrollBlocker, injectOverlaySurfaceContext, injectPaginationLabels, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectRichTextEditorTools, injectRightSheetStrategy, injectRightSheetStrategyDefaults, injectSidebarOverlay, injectStreamConfig, injectStreamConsentConfig, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, injectTableFeatureHost, injectTableLabels, injectTimeFormat, injectTopSheetStrategy, injectTopSheetStrategyDefaults, isFileAccepted, isHtmlElement, isInteractiveElement, isPointerEvent, isTargetInsideOverlayTree, isTouchEvent, itemsCollide, leftSheetOverlayStrategy, mapLayoutToBreakpoint, matchCountryByDialCode, mergeOverlayBreakpointConfigs, mergeOverlayConfigs, nodesEqual, paginate, parseDuration, phoneCountryFlag, phoneCountryName, pixelRectsEqual, positionToPixelRect, positionsEqual, projectDragCell, provideAnchoredDialogStrategy, provideAnchoredDialogStrategyDefaults, provideBottomSheetStrategy, provideBottomSheetStrategyDefaults, provideBracketConfig, provideBreadcrumbLabels, provideBreadcrumbManager, provideCarouselLabels, provideDateFormat, provideDateLocale, provideDialogStrategy, provideDialogStrategyDefaults, provideFormErrorMessageResolver, provideFormSupport, provideFullscreenDialogStrategy, provideFullscreenDialogStrategyDefaults, provideGridConfig, provideIconOverrides, provideIcons, provideLeftSheetStrategy, provideLeftSheetStrategyDefaults, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlay, provideOverlayManager, provideOverlayRouter, provideOverlayRouterConfig, provideOverlayRouterService, provideOverlayScrollBlocker, providePaginationLabels, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideRichTextEditorAlignmentTool, provideRichTextEditorLanguageTool, provideRichTextEditorTableTool, provideRichTextEditorTokenRendering, provideRichTextEditorTools, provideRightSheetStrategy, provideRightSheetStrategyDefaults, provideSidebarOverlay, provideSidebarOverlayConfig, provideSidebarOverlayService, provideStreamConfig, provideStreamConsentConfig, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, provideTableLabels, provideTimeFormat, provideTopSheetStrategy, provideTopSheetStrategyDefaults, reconcileColumnOrder, reconcileColumnWidths, reconcileHiddenColumns, reduceSupportPresentation, registerSingleton, requiredLanguages, resizeSpanBounds, resolveBreakpoint, resolveClosestOverlay, resolveCollisions, rightSheetOverlayStrategy, rowsToPixelHeight, selectOptionsFromQuery, selectOptionsFromV2Query, serializeGridLayout, serializeTableState, snapResizeSpan, sortRows, spanHeight, spanWidth, startFullscreenEnterAnimation, startFullscreenLeaveAnimation, stripTrunkZero, supportPresentationIncludesState, tableFeatureConfig, tableRowsFromQuery, tableRowsFromV2Query, toChildrenObservable, toGridPosition, toPathObservable, toSearchObservable, topSheetOverlayStrategy, transformingBottomSheetToDialogOverlayStrategy, transformingFullScreenDialogToDialogOverlayStrategy, transformingFullScreenDialogToRightSheetOverlayStrategy, wireFormSupport };
-export type { AccordionHeadingLevel, AnchoredDialogOverlayStrategyOptions, AnchoredOverlayStrategyOptions, AnchoredPanelCloseInfo, AnchoredPanelOverlayRef, AnchoredPanelSurfaceLike, AnchoredPositionOptions, AnyDropzoneUploadConfig, AnyTableColumn, AutoPlaceOptions, AutoScrollPointer, AutoScroller, Bracket, BracketBase, BracketConfig, BracketDataLayout, BracketDataSource, BracketMatch, BracketMatchBase, BracketMatchFactor, BracketMatchId, BracketMatchParticipant, BracketMatchParticipantBase, BracketMatchParticipantWithRelationsBase, BracketMatchPosition, BracketMatchRelation, BracketMatchRelationNothingToOne, BracketMatchRelationOneToNothing, BracketMatchRelationOneToOne, BracketMatchRelationTwoToNothing, BracketMatchRelationTwoToOne, BracketMatchShortId, BracketMatchSource, BracketMatchStatus, BracketMatchWithRelationsBase, BracketParticipant, BracketParticipantBase, BracketParticipantMatch, BracketParticipantWithRelationsBase, BracketRound, BracketRoundBase, BracketRoundId, BracketRoundMapWithSwissData, BracketRoundMirrorType, BracketRoundPosition, BracketRoundRelation, BracketRoundRelationNothingToOne, BracketRoundRelationOneToNothing, BracketRoundRelationOneToOne, BracketRoundRelationTwoToNothing, BracketRoundRelationTwoToOne, BracketRoundShortId, BracketRoundSource, BracketRoundSwissData, BracketRoundSwissGroup, BracketRoundSwissGroupId, BracketRoundSwissGroupMap, BracketRoundType, BracketRoundWithRelationsBase, BracketSwissColors, BracketSwissConfig, BracketSwissGroupColorType, BreadcrumbCrumb, BreadcrumbLabels, BreadcrumbRenderItem, BreadcrumbSegment, ButtonIconAlignment, ButtonSize, CalendarCell, CalendarMode, CalendarRange, CalendarWeekday, CarouselAutoplayPauseReason, CarouselLabels, CarouselResolvedTransitionDriver, CarouselSlideAlign, CarouselSlideContext, CarouselSlideTemplateRef, CarouselTransition, CarouselTransitionDriver, CascaderColumnState, CascaderCompareWith, CascaderDataSource, CascaderFromQueryConfig, CascaderFromQuerySearchConfig, CascaderNode, CascaderNodeSignal, CascaderSearchState, CascaderSelectableLevels, CascaderSurfaceContext, CenteredOverlayStrategyOptions, ClampPositionOptions, CommonBracketRoundType, CompactLayoutOptions, CreateAnchoredPanelControllerOptions, CreateExistingDropzoneEntryOptions, CreateFileDropzoneEntryOptions, CreateOverlayUnsavedChangesGuardConfig, CreateTableRowsSourceOptions, CurrencyMaskOptions, DatePickerHost, DatePickerSurfaceBase, DatePickerSurfaceContext, DatePickerTriggerBase, DateRangeSide, DateRangeValue, DoubleEliminationBracketRoundType, DragToDismissContext, DragToDismissRef, DropzoneEntry, DropzoneEntrySource, DropzoneEntryStatus, DropzoneExistingFileInfo, DropzoneFileConstraints, DropzoneFileRejection, DropzoneFileRejectionReason, DropzoneFileValidationChannel, DropzoneUploadConfig, DropzoneUploadError, DropzoneUploadHandle, DropzoneUploadHandleOptions, DropzoneUploadState, DurationFormatSpec, DurationSegment, DurationUnit, EtBuiltInIconName, EthleteIconNameRegistry, EthleteIconVariantRegistry, FacebookVideoPlayer, FacebookWindow, FilterRowsConfig, FindCollisionOptions, FormErrorMessageResolver, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldSize, FormSupport, FullscreenAnimationCancellable, FullscreenAnimationDeps, FullscreenAnimationState, GenerateBracketDataOptions, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridGeometry, GridItemActionsComponent, GridItemConfig, GridItemConstraints, GridItemPosition, GridLayoutEntry, GridSerializedState, GroupBracketRoundType, HintComponentBase, IconDefinition, IconOverride, InputMaskHost, InputTextAlignment, LabelDirectiveBase, MapLayoutOptions, MaskSpec, MaskValueMode, MatchParticipantId, MatchParticipantShortId, MatchParticipantSide, MatchPositionMaps, MenuAnchorPoint, MenuCloseReason, MenuItemActivationEvent, MenuItemActivationSource, MenuItemVariant, MenuOpenSource, MenuSelectionGroupDirectiveBase, MenuSelectionGroupItem, MenuSelectionItemKind, MenuSurfaceContext, MultiLanguageRichTextEditorLanguage, MultiLanguageRichTextEditorValue, NotificationAction, NotificationConfig, NotificationEntry, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OtpInputCharset, OverlayAutoFocusTarget, OverlayBodyDividerType, OverlayBreakpointConfig, OverlayCloseGuard, OverlayConfig, OverlayDefinition, OverlayDefinitionConfig, OverlayDragToDismissConfig, OverlayLifecycleConfig, OverlayManager, OverlayMode, OverlayOpenConfig, OverlayOpener, OverlayOpenerConfig, OverlayRef, OverlayRole, OverlayRoute, OverlayRouter, OverlayRouterConfig, OverlayRouterNavigateConfig, OverlayRouterNavigationDirection, OverlayRouterResolvedPath, OverlayRouterTransitionType, OverlayStrategy, OverlayStrategyBreakpoint, OverlayStrategyContext, OverlayStrategyController, OverlayStrategyControllerMountConfig, OverlaySurfaceContext, OverlayTreeContainmentOptions, OverlayUnsavedChangesDismissSources, OverlayUnsavedChangesGuardRef, PaginateOptions, PaginationItem, PaginationItemType, PaginationLabels, PaginationRangeContext, PaginationRenderAs, ParticipantMatchResult, PhoneCountry, PhoneInputFlagContext, PhoneInputFlagCountry, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, PixelRect, QueryParamOverlayDefinition, QueryParamOverlayDefinitionConfig, QueryParamOverlayHost, QueryParamOverlayOpener, QueryParamOverlayValue, RangeSliderValue, RatingIconContext, RatingIconState, ReconcilableColumn, ReduceSupportPresentationInput, RegisteredIconName, RegisteredIconVariant, RequiredLanguagesOptions, ResizeSpanBounds, ResolveClosestOverlayOptions, ResolveCollisionsOptions, ResolvedDropzoneUploadConfig, RichTextEditorLinkEditorValue, RichTextEditorQueryTriggerConfig, RichTextEditorTool, RichTextEditorToolButton, RichTextEditorToolDefinition, RichTextEditorToolsConfig, RichTextEditorTrigger, RichTextEditorTriggerItem, RichTextEditorTriggerItemResolver, RichTextEditorTriggerItemSource, RichTextEditorTriggerType, RowFloors, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SelectAsyncOptions, SelectErrorContext, SelectFilterMode, SelectItem, SelectOptionData, SelectOptionGroupItem, SelectOptionTemplateContext, SelectOptionsFromQuery, SelectOptionsFromQueryConfig, SelectOptionsFromV2QueryConfig, SelectSelectedEntry, SelectSurfaceContext, SelectValueContext, SelectionListDirectiveBase, SelectionListItem, SerializeOptions, SidebarOverlay, SidebarOverlayConfig, SingleEliminationBracketRoundType, SkeletonShape, SliderHostBase, SliderThumbBase, SliderThumbLabelBase, SliderThumbLabelContext, SortRowsConfig, StreamConfig, StreamConsentConfig, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, SupportContentState, SupportPresentationState, SupportTransitionDirection, SwissBracketRoundType, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, TableCellContext, TableCellErrorMark, TableCellErrorTooltipConfig, TableCellSkeletonContext, TableCellState, TableCellStateValue, TableColumn, TableColumnAlign, TableColumnDef, TableColumnMenuConfig, TableColumnMeta, TableColumnState, TableColumnTemplate, TableColumnVisibilityHost, TableColumns, TableEmptyContext, TableErrorContext, TableExpandedRowContext, TableFeatureConfig, TableFeatureHost, TableFilter, TableFilterOption, TableFilterOptionContext, TableFilterOptionsProvider, TableFilterSelection, TableFiltersConfig, TableFooterContext, TableHeaderAdornment, TableHeaderContext, TableHeaderGroup, TableLabels, TableLabelsSource, TableLayer, TableLeadCellComponent, TableLeadColumn, TableReorderConfig, TableResizeConfig, TableRowKey, TableRowWindow, TableRowsDriver, TableRowsFromQuery, TableRowsFromQueryConfig, TableRowsFromV2QueryConfig, TableRowsQueryState, TableRowsSource, TableSelectionConfig, TableSort, TableSortDirection, TableSortValue, TableState, TableStatePersistenceConfig, TableStateSlice, TableStateStorage, TableStateStorageKind, TableStateStorageOptions, TableTemplateSlot, TableVirtualScrollConfig, TextAlign, TextareaResizeMode, TimePickerColumn, TimePickerOption, TimePickerUnit, ToggletipContent, TooltipContent, TournamentMode, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, V2DropzonePrepareArgsOf, V2DropzoneUploadConfig, V2PrepareArgsOf, ViewportTransformData, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };
+export { ACCORDION_ERROR_CODES, ACCORDION_GROUP_TOKEN, ACCORDION_IMPORTS, ACCORDION_TOKEN, ALIGN_CENTER_ICON, ALIGN_JUSTIFY_ICON, ALIGN_LEFT_ICON, ALIGN_RIGHT_ICON, ARROWS_LEFT_RIGHT_ICON, ARROW_OUT_UP_RIGHT_ICON, ARROW_RIGHT_ICON, ARROW_UP_ICON, AccordionComponent, AccordionContentDirective, AccordionDirective, AccordionGroupComponent, AccordionGroupDirective, AccordionHintDirective, AccordionLabelDirective, AccordionPanelDirective, AccordionTriggerDirective, BOLD_ICON, BRACKET_DATA_LAYOUT, BRACKET_ERROR_CODES, BRACKET_IMPORTS, BRACKET_ROUND_MIRROR_TYPE, BRACKET_SWISS_GROUP_COLOR_TYPE, BREADCRUMB_ERROR_CODES, BREADCRUMB_IMPORTS, BREADCRUMB_LABELS, BREADCRUMB_SEGMENT_TOKEN, BREADCRUMB_TOKEN, BUTTON_ICON_ALIGNMENTS, BUTTON_IMPORTS, BUTTON_SIZES, BUTTON_SPINNER_CONFIG, BUTTON_TYPES, BUTTON_VARIANTS, BracketComponent, BracketDefaultContinueComponent, BracketDefaultMatchComponent, BracketDefaultRoundHeaderComponent, BracketMap, BrandLoaderComponent, BreadcrumbComponent, BreadcrumbDirective, BreadcrumbItemDirective, BreadcrumbItemTemplateDirective, BreadcrumbOutletComponent, BreadcrumbSegmentDirective, BreadcrumbSeparatorDirective, ButtonComponent, ButtonDirective, ButtonStylesDirective, CALENDAR_ERROR_CODES, CALENDAR_ICON, CALENDAR_IMPORTS, CALENDAR_LABELS, CAROUSEL_AUTOPLAY_TOKEN, CAROUSEL_ERROR_CODES, CAROUSEL_IMPORTS, CAROUSEL_LABELS, CAROUSEL_SLIDE_ALIGNMENTS, CAROUSEL_TOKEN, CAROUSEL_TRANSITIONS, CAROUSEL_TRANSITION_DRIVERS, CASCADER_ERROR_CODES, CASCADER_IMPORTS, CASCADER_LABELS, CASCADER_SELECTABLE_LEVELS, CHECKBOX_IMPORTS, CHECKBOX_OPTION_VARIANTS, CHECK_ICON, CHEVRON_ICON, CHIP_ERROR_CODES, CHIP_IMPORTS, CHIP_LABELS, CHOICE_FIELD_IMPORTS, CHOICE_FIELD_VARIANTS, CLIPBOARD_CHECK_ICON, CLOCK_ICON, CODE_ICON, COLOR_INPUT_IMPORTS, COMMON_BRACKET_ROUND_TYPE, CalendarCellDirective, CalendarComponent, CalendarDirective, CalendarGridDirective, CarouselAutoplayDirective, CarouselComponent, CarouselDirective, CarouselItemDirective, CarouselNextDirective, CarouselPlayToggleDirective, CarouselPreviousDirective, CarouselSlideDirective, CascaderColumnDirective, CascaderComponent, CascaderDirective, CascaderNodeDirective, CascaderPanelComponent, CascaderSearchDirective, CascaderSearchOptionDirective, CascaderSurfaceDirective, CascaderTriggerDirective, CheckboxComponent, CheckboxDirective, CheckboxGroupComponent, CheckboxOptionComponent, ChipComponent, ChipDirective, ChipRemoveDirective, ChoiceFieldComponent, ColorInputComponent, ColorInputDirective, CounterComponent, DAILYMOTION_PLAYER_TOKEN, DATE_FORMAT, DATE_INPUT_ERROR_CODES, DATE_INPUT_IMPORTS, DATE_LOCALE, DATE_PICKER_HOST, DATE_RANGE_INPUT_ERROR_CODES, DATE_RANGE_INPUT_IMPORTS, DATE_TIME_INPUT_ERROR_CODES, DATE_TIME_INPUT_IMPORTS, DATE_TIME_LABELS, DEFAULT_BREADCRUMB_LABELS, DEFAULT_BREAKPOINTS, DEFAULT_CALENDAR_LABELS, DEFAULT_CAROUSEL_LABELS, DEFAULT_CASCADER_LABELS, DEFAULT_CHIP_LABELS, DEFAULT_DATE_TIME_LABELS, DEFAULT_DROPZONE_LABELS, DEFAULT_FILTER_OVERLAY_LABELS, DEFAULT_FORM_FIELD_LABELS, DEFAULT_GRID_LABELS, DEFAULT_ICON_VARIANT, DEFAULT_INPUT_LABELS, DEFAULT_LOADER_LABELS, DEFAULT_NOTIFICATION_LABELS, DEFAULT_NOTIFICATION_MANAGER_CONFIG, DEFAULT_PAGINATION_LABELS, DEFAULT_PHONE_INPUT_LABELS, DEFAULT_PIP_WINDOW_CONFIG, DEFAULT_QUERY_ERROR_LABELS, DEFAULT_RICH_TEXT_EDITOR_LABELS, DEFAULT_RICH_TEXT_EDITOR_TOOLS, DEFAULT_SELECT_LABELS, DEFAULT_SLIDER_LABELS, DEFAULT_STREAM_LABELS, DEFAULT_STREAM_PLAYER_STATE, DEFAULT_TABLE_LABELS, DEFAULT_TIME_PICKER_LABELS, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, DROPZONE_ENTRY_STATUSES, DROPZONE_ERROR_CODES, DROPZONE_FILES_ERROR_KIND, DROPZONE_FILE_CONSTRAINTS, DROPZONE_FILE_REJECTION_REASONS, DROPZONE_IMPORTS, DROPZONE_LABELS, DURATION_INPUT_ERROR_CODES, DURATION_INPUT_IMPORTS, DailymotionPlayerComponent, DailymotionPlayerDirective, DailymotionPlayerParamsDirective, DailymotionPlayerSlotComponent, DateInputComponent, DateInputDirective, DateInputFieldDirective, DatePickerPanelComponent, DatePickerSurfaceDirective, DatePickerTriggerDirective, DateRangeInputComponent, DateRangeInputDirective, DateRangeInputFieldDirective, DateTimeInputComponent, DateTimeInputDirective, DateTimeInputFieldDirective, DescriptionComponent, DropzoneComponent, DropzoneDirective, DurationInputComponent, DurationInputDirective, DurationInputFieldDirective, ELLIPSIS_ICON, ELLIPSIS_VERTICAL_ICON, ET_BUILT_IN_ICON_NAMES, EYE_ICON, EYE_SLASH_ICON, FACEBOOK_PLAYER_TOKEN, FILE_ICON, FILTER_ICON, FILTER_OVERLAY_ERROR_CODES, FILTER_OVERLAY_IMPORTS, FILTER_OVERLAY_LABELS, FILTER_OVERLAY_TOKEN, FLOATING_ACTION_ERROR_CODES, FLOATING_ACTION_IMPORTS, FLOATING_ACTION_STATES, FLOATING_ACTION_TOKEN, FLOPPY_DISK_ICON, FOCUS_FRAME_ICON, FORM_ERROR_MESSAGE_RESOLVER, FORM_FIELD_APPEARANCES, FORM_FIELD_CONTROL_TYPES, FORM_FIELD_ERROR_CODES, FORM_FIELD_FILLS, FORM_FIELD_IMPORTS, FORM_FIELD_LABELS, FORM_FIELD_LABEL_MODES, FORM_FIELD_SIZES, FORM_FIELD_TOKEN, FabComponent, FacebookPlayerComponent, FacebookPlayerDirective, FacebookPlayerParamsDirective, FacebookPlayerSlotComponent, FilterOverlayResetDirective, FilterOverlaySubmitDirective, FloatingActionAnchorDirective, FloatingActionDirective, FloatingActionScopeDirective, FloatingActionTopDirective, FloatingActionTriggerDirective, FocusRingDirective, FormErrorComponent, FormFieldComponent, FormFieldDirective, GERMAN_FILTER_OVERLAY_LABELS, GERMAN_QUERY_ERROR_LABELS, GRID_2X2_ICON, GRID_ERROR_CODES, GRID_IMPORTS, GRID_LABELS, GRID_TOKEN, GROUP_BRACKET_ROUND_TYPE, GridComponent, GridDebugComponent, GridDirective, GridDragDirective, GridItemComponent, GridItemDefaultActionsComponent, GridItemDirective, GridItemRef, GridItemToolbarComponent, GridResizeDirective, HEADING_1_ICON, HEADING_2_ICON, HEADING_3_ICON, HintComponent, ICONS_TOKEN, ICON_DIRECTIVE_TOKEN, ICON_ERROR_CODES, ICON_IMPORTS, ICON_OVERRIDES_TOKEN, INITIAL_SUPPORT_PRESENTATION_STATE, INPUT_IMPORTS, INPUT_LABELS, INPUT_MASK_HOST, INPUT_TEXT_ALIGNMENTS, INPUT_TYPES, INTERACTIVE_TAGS, ITALIC_ICON, IconButtonComponent, IconDirective, InputComponent, InputDirective, InputMaskDirective, InputPrefixDirective, InputSuffixDirective, KICK_PLAYER_TOKEN, KickPlayerComponent, KickPlayerDirective, KickPlayerParamsDirective, KickPlayerSlotComponent, LINK_ICON, LIST_BULLETED_ICON, LIST_NUMBERED_ICON, LOADER_LABELS, LOCK_ICON, LabelDirective, MASKED_INPUT_ERROR_CODES, MASKED_INPUT_IMPORTS, MASK_VALUE_MODES, MASONRY_ERROR_CODES, MASONRY_IMPORTS, MASONRY_TOKEN, MENU_ERROR_CODES, MENU_IMPORTS, MENU_ITEM_VARIANTS, MENU_SELECTION_GROUP_MULTIPLE, MENU_SELECTION_GROUP_TOKEN, MENU_SELECTION_ITEM_KIND, MINUS_ICON, MULTI_LANGUAGE_RICH_TEXT_EDITOR_ERROR_CODES, MULTI_LANGUAGE_RICH_TEXT_EDITOR_IMPORTS, MasonryDirective, MasonryItemDirective, MenuCheckboxGroupComponent, MenuCheckboxItemComponent, MenuComponent, MenuContextTriggerDirective, MenuDirective, MenuGroupLabelComponent, MenuItemComponent, MenuItemDirective, MenuItemShortcutComponent, MenuPanelDirective, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSearchDirective, MenuSelectionGroupDirective, MenuSelectionItemDirective, MenuSeparatorComponent, MenuSurfaceDirective, MenuTriggerDirective, MultiLanguageRichTextEditorComponent, MultiLanguageRichTextEditorDirective, MultiLanguageRichTextEditorLanguageToolComponent, NAV_TABS_TOKEN, NAV_TAB_IMPORTS, NOTIFICATION_ERROR_CODES, NOTIFICATION_IMPORTS, NOTIFICATION_LABELS, NOTIFICATION_STACK_CONTEXT_TOKEN, NOTIFICATION_STATUS, NUMBER_INPUT_IMPORTS, NavTabLinkComponent, NavTabLinkDirective, NavTabsComponent, NavTabsDirective, NavTabsOutletComponent, NavTabsOutletDirective, NotificationActionDirective, NotificationComponent, NotificationDirective, NotificationDismissDirective, NotificationItemDirective, NotificationStackDirective, NumberInputComponent, NumberInputDirective, OTP_INPUT_IMPORTS, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CONFIG_CLASS_KEYS, OVERLAY_CONTENT_IMPORTS, OVERLAY_ERROR_CODES, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_IMPORTS, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_REF, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_ROUTER_TOKEN, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OtpInputComponent, OtpInputDirective, OverlayAnchorDirective, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseDirective, OverlayContainerComponent, OverlayDirective, OverlayFooterDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayMainDirective, OverlayOriginCloneComponent, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlaySurfaceDirective, OverlayTitleDirective, OverlayTriggerDirective, PAGINATION_IMPORTS, PAGINATION_LABELS, PARAGRAPH_ICON, PASSWORD_INPUT_IMPORTS, PAUSE_ICON, PENCIL_ICON, PHONE_COUNTRIES, PHONE_INPUT_ERROR_CODES, PHONE_INPUT_IMPORTS, PHONE_INPUT_LABELS, PICTURE_IMPORTS, PICTURE_STATES, PIP_CHROME_REF_TOKEN, PIP_ENTRY_TOKEN, PIP_WINDOW_ASPECT_RATIO_TOKEN, PLAY_ICON, PLUS_ICON, PaginationComponent, PaginationDirective, PaginationSeoDirective, PasswordInputComponent, PasswordInputDirective, PhoneInputComponent, PhoneInputDirective, PhoneInputFieldDirective, PhoneInputFlagDirective, PictureComponent, PictureErrorDirective, PicturePlaceholderDirective, PipBackDirective, PipBringBackDirective, PipCellDirective, PipCloseDirective, PipCollapseOverlayDirective, PipGridToggleDirective, PipPlayerComponent, PipSlotPlaceholderComponent, PipStageDirective, PipTitleBarDirective, PipTitleBarTemplateDirective, PipWindowComponent, PipWindowParamsDirective, ProgressBarComponent, QUERY_DEVTOOLS_IMPORTS, QUERY_ERROR_ERROR_CODES, QUERY_ERROR_IMPORTS, QUERY_ERROR_LABELS, QUERY_ERROR_TOKEN, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsToggleComponent, QueryErrorActionsDirective, QueryErrorComponent, QueryErrorDirective, QueryErrorTitleDirective, QueryParamOverlayLinkDirective, RADIO_VARIANTS, RATING_IMPORTS, RICH_TEXT_EDITOR_HEADING_OPTIONS, RICH_TEXT_EDITOR_IMPORTS, RICH_TEXT_EDITOR_INLINE_TOOLS, RICH_TEXT_EDITOR_LABELS, RICH_TEXT_EDITOR_LANGUAGE_TOOL, RICH_TEXT_EDITOR_TOKEN_CODEC, RICH_TEXT_EDITOR_TOKEN_PALETTE_IMPORTS, RICH_TEXT_EDITOR_TOOL, RICH_TEXT_EDITOR_TOOLS, RICH_TEXT_EDITOR_TOOL_BUTTONS, RICH_TEXT_EDITOR_TRIGGERS_IMPORTS, ROTATE_RIGHT_ICON, RadioComponent, RadioGroupComponent, RangeSliderComponent, RangeSliderDirective, RatingComponent, RatingDirective, RatingIconDirective, RichTextEditorAlignToolComponent, RichTextEditorComponent, RichTextEditorDirective, RichTextEditorFloatingToolbarComponent, RichTextEditorFloatingToolbarDirective, RichTextEditorLinkEditorComponent, RichTextEditorLinkEditorDirective, RichTextEditorTableToolComponent, RichTextEditorTokenPaletteComponent, RichTextEditorTokenPopupComponent, RichTextEditorTriggersDirective, SCROLLABLE_ERROR_CODES, SCROLLABLE_IMPORTS, SEGMENTED_BUTTON_GROUP_VARIANTS, SELECTION_LIST_MULTIPLE, SELECTION_LIST_TOKEN, SELECT_ERROR_CODES, SELECT_FILTER_MODES, SELECT_IMPORTS, SELECT_LABELS, SIDEBAR_OVERLAY_CONFIG, SIDEBAR_OVERLAY_TOKEN, SINGLE_ELIMINATION_BRACKET_ROUND_TYPE, SKELETON_IMPORTS, SLIDER_ERROR_CODES, SLIDER_IMPORTS, SLIDER_LABELS, SLIDER_TOKEN, SNAP_HYSTERESIS, SOOP_PLAYER_TOKEN, SPLIT_BUTTON_ERROR_CODES, STAR_ICON, STREAM_CONSENT_TOKEN, STREAM_IMPORTS, STREAM_LABELS, STREAM_PLAYER_COMPONENT_TOKEN, STREAM_PLAYER_ERROR_CONTEXT_TOKEN, STREAM_PLAYER_ERROR_TOKEN, STREAM_PLAYER_PARAMS_TOKEN, STREAM_PLAYER_SLOT_TOKEN, STREAM_PLAYER_TOKEN, STREAM_SLOT_PLAYER_ID_TOKEN, STREAM_USER_CONSENT_PROVIDER_TOKEN, STRIKETHROUGH_ICON, SUPPORT_CONTENT_STATE, SUPPORT_TRANSITION_DIRECTION, SWISS_ADVANCE_WINS, SWISS_BRACKET_ROUND_TYPE, SWISS_ELIMINATE_LOSSES, SWITCH_IMPORTS, ScrollableActiveChildDirective, ScrollableButtonsDirective, ScrollableComponent, ScrollableDarkenDirective, ScrollableDirective, ScrollableDragDirective, ScrollableIgnoreChildDirective, ScrollableLoadingTemplateDirective, ScrollableMasksDirective, ScrollableNavigationDirective, ScrollableSnapDirective, SegmentedButtonComponent, SegmentedButtonGroupComponent, SelectComponent, SelectDirective, SelectEmptyDirective, SelectErrorDirective, SelectListboxDirective, SelectLoadingDirective, SelectOptionComponent, SelectOptionDirective, SelectOptionGroupComponent, SelectOptionGroupDirective, SelectOptionTemplateDirective, SelectOptionsDirective, SelectPanelComponent, SelectSearchDirective, SelectSurfaceDirective, SelectTriggerDirective, SelectValueDirective, SelectViewportDirective, SelectVirtualOptionComponent, SelectVirtualOptionDirective, SelectionListControlDirective, SelectionListDirective, SelectionOptionDirective, SkeletonComponent, SkeletonItemComponent, SkeletonTextComponent, SliderComponent, SliderDirective, SliderThumbDirective, SliderThumbLabelDirective, SliderTrackDirective, SoopPlayerComponent, SoopPlayerDirective, SoopPlayerParamsDirective, SoopPlayerSlotComponent, SpinnerComponent, SplitButtonActionDirective, SplitButtonComponent, SplitButtonDirective, SplitButtonTriggerDirective, StreamConsentAcceptDirective, StreamConsentComponent, StreamConsentDirective, StreamPipChromeComponent, StreamPlayerErrorComponent, StreamPlayerErrorDirective, StreamPlayerLoadingComponent, StreamPlayerSlotDirective, SwitchComponent, SwitchDirective, TABLE_CELL_ERROR_TOOLTIP_IMPORTS, TABLE_COLUMN_CHOOSER_IMPORTS, TABLE_COLUMN_MENU_IMPORTS, TABLE_ERROR_CODES, TABLE_FEATURE_HOST, TABLE_FILTER_IMPORTS, TABLE_ICON, TABLE_IMPORTS, TABLE_LABELS, TABLE_REORDER_IMPORTS, TABLE_RESIZE_IMPORTS, TABLE_SELECTION_IMPORTS, TABLE_STATE_PERSISTENCE_IMPORTS, TABLE_VIRTUAL_SCROLL_IMPORTS, TAB_BAR_FITS, TAB_BAR_ORIENTATIONS, TAB_BAR_TOKEN, TAB_BAR_TRIGGER_TOKEN, TAB_BAR_VARIANTS, TAB_ERROR_CODES, TAB_GROUP_TOKEN, TAB_IMPORTS, TAB_PANEL_TOKEN, TAB_SIZES, TAG_INPUT_ERROR_CODES, TAG_INPUT_IMPORTS, TEXTAREA_IMPORTS, TEXTAREA_RESIZE_MODES, TEXT_ALIGNS, TIKTOK_PLAYER_TOKEN, TIMES_ICON, TIME_FORMAT, TIME_INPUT_ERROR_CODES, TIME_INPUT_IMPORTS, TIME_PICKER_ERROR_CODES, TIME_PICKER_IMPORTS, TIME_PICKER_LABELS, TOGGLETIP_ERROR_CODES, TOGGLETIP_IMPORTS, TOOLTIP_ERROR_CODES, TOOLTIP_IMPORTS, TOURNAMENT_MODE, TRIANGLE_EXCLAMATION_ICON, TWITCH_PLAYER_TOKEN, TabBarDirective, TabBarTriggerDirective, TabBarUnderlineDirective, TabComponent, TabGroupComponent, TabGroupDirective, TabLabelDirective, TabPanelDirective, TabTriggerDirective, TableCellDirective, TableCellErrorMarkComponent, TableCellErrorTooltipDirective, TableCellSkeletonDirective, TableColumnChooserComponent, TableColumnMenuDirective, TableColumnMenuTriggerComponent, TableComponent, TableDetailStylesComponent, TableExpanderCellComponent, TableFilterOptionDirective, TableFilterTriggerComponent, TableFiltersDirective, TableFooterCellDirective, TableFooterDirective, TableHeaderCellDirective, TableReorderDirective, TableReorderOverlayComponent, TableResizeDirective, TableResizeGripComponent, TableSelectAllCellComponent, TableSelectCellComponent, TableSelectionDirective, TableStatePersistenceDirective, TableVirtualScrollDirective, TableVirtualScrollStylesComponent, TagInputComponent, TagInputDirective, TagInputFieldDirective, TextButtonComponent, TextFieldControlDirective, TextareaComponent, TextareaDirective, TikTokPlayerComponent, TikTokPlayerDirective, TikTokPlayerParamsDirective, TikTokPlayerSlotComponent, TimeInputComponent, TimeInputDirective, TimeInputFieldDirective, TimePickerColumnDirective, TimePickerComponent, TimePickerDirective, TimePickerOptionDirective, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipTriggerDirective, TooltipComponent, TooltipDirective, TwitchPlayerComponent, TwitchPlayerDirective, TwitchPlayerParamsDirective, TwitchPlayerSlotComponent, UNDERLINE_ICON, UNIT_MS, UPLOAD_ICON, VIMEO_PLAYER_TOKEN, VimeoPlayerComponent, VimeoPlayerDirective, VimeoPlayerParamsDirective, VimeoPlayerSlotComponent, WINDOW_CONTROL_BUTTON_KINDS, WINDOW_CONTROL_BUTTON_SIZES, WindowControlButtonComponent, YOUTUBE_PLAYER_SLOT_TOKEN, YOUTUBE_PLAYER_TOKEN, YoutubePlayerComponent, YoutubePlayerDirective, YoutubePlayerParamsDirective, YoutubePlayerSlotComponent, YoutubePlayerSlotDirective, abortFullscreenAnimation, anchoredDialogOverlayStrategy, anchoredOverlayStrategy, autoPlace, bottomSheetOverlayStrategy, buildAnchoredRuntimePositionStrategy, canHaveChildren, canRenderLayoutInTournamentMode, cascaderFromQuery, centeredOverlayStrategy, clampPosition, clampResizeRect, cleanupFullscreenAnimation, cleanupFullscreenAnimationStyles, compactLayout, computeGeometry, computeGridHeight, createAnchoredPanelController, createAutoScroller, createBracket, createBracketBase, createCardMask, createCurrencyMask, createDefaultDropzoneArgs, createDropzoneUpload, createExistingDropzoneEntry, createFileDropzoneEntry, createGridAdapter, createIbanMask, createMatchesMapBase, createNewMatchParticipantBase, createNotificationRef, createOverlayOpener, createOverlayRef, createOverlayStrategyController, createOverlayUnsavedChangesGuard, createParticipantsMapBase, createPipChromeAnimations, createPipChromeState, createRichTextEditorTrigger, createRichTextEditorTriggerWithQuery, createRoundsMapBase, createStreamConfig, createStreamPlayerSlot, createTableRowsSource, createTableStateStorage, createV2DropzoneUpload, defaultCompareWith, defaultDropzoneRejectionMessage, defineOverlay, defineQueryParamOverlay, deriveDurationFormatSpec, deserializeGridLayout, deserializeTableState, dialogOverlayStrategy, disposeDropzoneEntry, dropzoneFiles, enableDragToDismiss, extractFirstImageUrl, filterOverlayLabelsForLocale, filterOverlayPreviewFromQuery, filterRows, findCollision, findNextRelevantHtmlElement, findScrollableAncestor, formatDuration, formatFileSize, fromGridPosition, fullScreenDialogOverlayStrategy, generateBracketDataForEthlete, generateBracketRoundSwissGroupMaps, generateMatchPosition, generateMatchRelationPositions, generateMatchRelationsNew, generateRoundRelationsNew, generateRoundTypeFromEthleteRoundType, generateTournamentModeFormEthleteRounds, getAvailableSwissGroupsForRound, getClosestOverlay, getOriginCoordinatesAndDimensions, getSwissGroupColorType, hysteresisRound, iconRegistryKey, indexOfNode, injectAnchoredDialogStrategy, injectAnchoredDialogStrategyDefaults, injectBottomSheetStrategy, injectBottomSheetStrategyDefaults, injectBracketConfig, injectBreadcrumbLabels, injectBreadcrumbManager, injectCalendarLabels, injectCarouselLabels, injectCascaderLabels, injectChipLabels, injectDateFormat, injectDateLocale, injectDateTimeLabels, injectDialogStrategy, injectDialogStrategyDefaults, injectDropzoneLabels, injectFilterOverlay, injectFilterOverlayLabels, injectFormFieldLabels, injectFormSupport, injectFullscreenDialogStrategy, injectFullscreenDialogStrategyDefaults, injectGridConfig, injectGridLabels, injectInputLabels, injectLeftSheetStrategy, injectLeftSheetStrategyDefaults, injectLoaderLabels, injectNotificationLabels, injectNotificationManager, injectNotificationManagerConfig, injectOverlayManager, injectOverlayRouter, injectOverlayScrollBlocker, injectOverlaySurfaceContext, injectPaginationLabels, injectPhoneInputLabels, injectPictureConfig, injectPipChromeManager, injectPipManager, injectPipSlotPlaceholderConfig, injectQueryErrorLabels, injectRichTextEditorLabels, injectRichTextEditorTools, injectRightSheetStrategy, injectRightSheetStrategyDefaults, injectSelectLabels, injectSidebarOverlay, injectSliderLabels, injectStreamConfig, injectStreamConsentConfig, injectStreamLabels, injectStreamManager, injectStreamPlayerErrorConfig, injectStreamPlayerLoadingConfig, injectStreamScriptLoader, injectStreamUserConsentProvider, injectTableFeatureHost, injectTableLabels, injectTimeFormat, injectTimePickerLabels, injectTopSheetStrategy, injectTopSheetStrategyDefaults, isFileAccepted, isHtmlElement, isInteractiveElement, isPointerEvent, isTargetInsideOverlayTree, isTouchEvent, itemsCollide, leftSheetOverlayStrategy, legacyQueryErrorSource, mapLayoutToBreakpoint, matchCountryByDialCode, mergeOverlayBreakpointConfigs, mergeOverlayConfigs, nodesEqual, normalizePictureSizes, normalizePictureSource, paginate, parseDuration, phoneCountryFlag, phoneCountryName, pixelRectsEqual, positionToPixelRect, positionsEqual, projectDragCell, provideAnchoredDialogStrategy, provideAnchoredDialogStrategyDefaults, provideBottomSheetStrategy, provideBottomSheetStrategyDefaults, provideBracketConfig, provideBreadcrumbLabels, provideBreadcrumbManager, provideCalendarLabels, provideCarouselLabels, provideCascaderLabels, provideChipLabels, provideDateFormat, provideDateLocale, provideDateTimeLabels, provideDialogStrategy, provideDialogStrategyDefaults, provideDropzoneLabels, provideFilterOverlay, provideFilterOverlayLabels, provideFormErrorMessageResolver, provideFormFieldLabels, provideFormSupport, provideFullscreenDialogStrategy, provideFullscreenDialogStrategyDefaults, provideGridConfig, provideGridLabels, provideIconOverrides, provideIcons, provideInputLabels, provideLeftSheetStrategy, provideLeftSheetStrategyDefaults, provideLoaderLabels, provideNotificationLabels, provideNotificationManager, provideNotificationManagerConfig, provideNotificationManagerInstance, provideOverlay, provideOverlayManager, provideOverlayRouter, provideOverlayRouterConfig, provideOverlayRouterService, provideOverlayScrollBlocker, providePaginationLabels, providePhoneInputLabels, providePictureConfig, providePipChromeManager, providePipManager, providePipSlotPlaceholderConfig, provideQueryErrorLabels, provideRichTextEditorAlignmentTool, provideRichTextEditorLabels, provideRichTextEditorLanguageTool, provideRichTextEditorTableTool, provideRichTextEditorTokenRendering, provideRichTextEditorTools, provideRightSheetStrategy, provideRightSheetStrategyDefaults, provideSelectLabels, provideSidebarOverlay, provideSidebarOverlayConfig, provideSidebarOverlayService, provideSliderLabels, provideStreamConfig, provideStreamConsentConfig, provideStreamLabels, provideStreamManager, provideStreamPlayerErrorConfig, provideStreamPlayerLoadingConfig, provideTableLabels, provideTimeFormat, provideTimePickerLabels, provideTopSheetStrategy, provideTopSheetStrategyDefaults, queryErrorLabelsForLocale, queryErrorResponseFromLegacyError, reconcileColumnOrder, reconcileColumnWidths, reconcileHiddenColumns, reduceSupportPresentation, registerSingleton, requiredLanguages, resizeSpanBounds, resolveBreakpoint, resolveClosestOverlay, resolveCollisions, resolveFilterOverlaySubmitButton, richTextEditorToolLabel, rightSheetOverlayStrategy, rowsToPixelHeight, selectOptionsFromQuery, selectOptionsFromV2Query, serializeGridLayout, serializeTableState, snapResizeSpan, sortRows, spanHeight, spanWidth, startFullscreenEnterAnimation, startFullscreenLeaveAnimation, stripTrunkZero, supportPresentationIncludesState, tableFeatureConfig, tableRowsFromQuery, tableRowsFromV2Query, toChildrenObservable, toGridPosition, toPathObservable, toSearchObservable, topSheetOverlayStrategy, transformingBottomSheetToDialogOverlayStrategy, transformingFullScreenDialogToDialogOverlayStrategy, transformingFullScreenDialogToRightSheetOverlayStrategy, wireFormSupport, withPictureBaseUrl };
+export type { AccordionHeadingLevel, AnchoredDialogOverlayStrategyOptions, AnchoredOverlayStrategyOptions, AnchoredPanelCloseInfo, AnchoredPanelOverlayRef, AnchoredPanelSurfaceLike, AnchoredPositionOptions, AnyDropzoneUploadConfig, AnyTableColumn, AutoPlaceOptions, AutoScrollPointer, AutoScroller, Bracket, BracketBase, BracketConfig, BracketDataLayout, BracketDataSource, BracketMatch, BracketMatchBase, BracketMatchFactor, BracketMatchId, BracketMatchParticipant, BracketMatchParticipantBase, BracketMatchParticipantWithRelationsBase, BracketMatchPosition, BracketMatchRelation, BracketMatchRelationNothingToOne, BracketMatchRelationOneToNothing, BracketMatchRelationOneToOne, BracketMatchRelationTwoToNothing, BracketMatchRelationTwoToOne, BracketMatchShortId, BracketMatchSource, BracketMatchStatus, BracketMatchWithRelationsBase, BracketParticipant, BracketParticipantBase, BracketParticipantMatch, BracketParticipantWithRelationsBase, BracketRound, BracketRoundBase, BracketRoundId, BracketRoundMapWithSwissData, BracketRoundMirrorType, BracketRoundPosition, BracketRoundRelation, BracketRoundRelationNothingToOne, BracketRoundRelationOneToNothing, BracketRoundRelationOneToOne, BracketRoundRelationTwoToNothing, BracketRoundRelationTwoToOne, BracketRoundShortId, BracketRoundSource, BracketRoundSwissData, BracketRoundSwissGroup, BracketRoundSwissGroupId, BracketRoundSwissGroupMap, BracketRoundType, BracketRoundWithRelationsBase, BracketSwissColors, BracketSwissConfig, BracketSwissGroupColorType, BreadcrumbCrumb, BreadcrumbLabels, BreadcrumbRenderItem, BreadcrumbSegment, ButtonIconAlignment, ButtonSize, CalendarCell, CalendarLabels, CalendarMode, CalendarRange, CalendarWeekday, CarouselAutoplayPauseReason, CarouselLabels, CarouselResolvedTransitionDriver, CarouselSlideAlign, CarouselSlideContext, CarouselSlideTemplateRef, CarouselTransition, CarouselTransitionDriver, CascaderColumnState, CascaderCompareWith, CascaderDataSource, CascaderFromQueryConfig, CascaderFromQuerySearchConfig, CascaderLabels, CascaderNode, CascaderNodeSignal, CascaderSearchState, CascaderSelectableLevels, CascaderSurfaceContext, CenteredOverlayStrategyOptions, CheckboxOptionVariant, ChipLabels, ChoiceFieldVariant, ClampPositionOptions, CommonBracketRoundType, CompactLayoutOptions, CounterComponentBase, CreateAnchoredPanelControllerOptions, CreateExistingDropzoneEntryOptions, CreateFileDropzoneEntryOptions, CreateOverlayUnsavedChangesGuardConfig, CreateTableRowsSourceOptions, CurrencyMaskOptions, DatePickerHost, DatePickerSurfaceBase, DatePickerSurfaceContext, DatePickerTriggerBase, DateRangeSide, DateRangeValue, DateTimeLabels, DoubleEliminationBracketRoundType, DragDismissMomentum, DragToDismissContext, DragToDismissRef, DropzoneEntry, DropzoneEntrySource, DropzoneEntryStatus, DropzoneExistingFileInfo, DropzoneFileConstraints, DropzoneFileRejection, DropzoneFileRejectionReason, DropzoneFileValidationChannel, DropzoneLabels, DropzoneUploadConfig, DropzoneUploadError, DropzoneUploadHandle, DropzoneUploadHandleOptions, DropzoneUploadState, DurationFormatSpec, DurationSegment, DurationUnit, EtBuiltInIconName, EthleteIconNameRegistry, EthleteIconVariantRegistry, FacebookVideoPlayer, FacebookWindow, FilterOverlay, FilterOverlayConfig, FilterOverlayDraft, FilterOverlayLabels, FilterOverlayPreview, FilterOverlayResult, FilterOverlaySubmitButton, FilterOverlaySubmitState, FilterOverlayValueOf, FilterRowsConfig, FindCollisionOptions, FloatingActionState, FormErrorMessageResolver, FormFieldAppearance, FormFieldControl, FormFieldControlType, FormFieldDirectiveBase, FormFieldFill, FormFieldLabelMode, FormFieldLabels, FormFieldSize, FormSupport, FullscreenAnimationCancellable, FullscreenAnimationDeps, FullscreenAnimationState, GenerateBracketDataOptions, GridAdapter, GridBreakpointConfig, GridBreakpointName, GridComponentRegistration, GridConfig, GridGeometry, GridItemActionsComponent, GridItemConfig, GridItemConstraints, GridItemPosition, GridLabels, GridLayoutEntry, GridSerializedState, GroupBracketRoundType, HintComponentBase, IconDefinition, IconOverride, InputLabels, InputMaskHost, InputTextAlignment, LabelDirectiveBase, LegacyQueryErrorSource, LoaderLabels, MapLayoutOptions, MaskSpec, MaskValueMode, MasonryColumns, MasonryPacking, MasonryPlacement, MatchParticipantId, MatchParticipantShortId, MatchParticipantSide, MatchPositionMaps, MenuAnchorPoint, MenuCloseReason, MenuItemActivationEvent, MenuItemActivationSource, MenuItemVariant, MenuOpenSource, MenuSelectionGroupDirectiveBase, MenuSelectionGroupItem, MenuSelectionItemKind, MenuSurfaceContext, MultiLanguageRichTextEditorLanguage, MultiLanguageRichTextEditorValue, NotificationAction, NotificationConfig, NotificationEntry, NotificationLabels, NotificationManager, NotificationManagerConfig, NotificationRef, NotificationStackContext, NotificationStatus, OtpInputCharset, OverlayAutoFocusTarget, OverlayBodyDividerType, OverlayBreakpointConfig, OverlayCloseGuard, OverlayConfig, OverlayDefinition, OverlayDefinitionConfig, OverlayDragToDismissConfig, OverlayDragToDismissDirection, OverlayDragToDismissPhysicalDirection, OverlayLifecycleConfig, OverlayManager, OverlayMode, OverlayOpenConfig, OverlayOpener, OverlayOpenerConfig, OverlayRef, OverlayRole, OverlayRoute, OverlayRouter, OverlayRouterConfig, OverlayRouterNavigateConfig, OverlayRouterNavigationDirection, OverlayRouterResolvedPath, OverlayRouterTransitionType, OverlayStrategy, OverlayStrategyBreakpoint, OverlayStrategyContext, OverlayStrategyController, OverlayStrategyControllerMountConfig, OverlaySurfaceContext, OverlayTreeContainmentOptions, OverlayUnsavedChangesDismissSources, OverlayUnsavedChangesGuardRef, PaginateOptions, PaginationItem, PaginationItemType, PaginationLabels, PaginationRangeContext, PaginationRenderAs, ParticipantMatchResult, PhoneCountry, PhoneInputFlagContext, PhoneInputFlagCountry, PhoneInputLabels, PictureConfig, PictureSource, PictureState, PipCellData, PipChromeAnimations, PipChromeRef, PipChromeState, PipManager, PipSlotPlaceholderConfig, PixelRect, QueryErrorLabels, QueryErrorRetryTarget, QueryErrorSlotContext, QueryErrorView, QueryParamOverlayDefinition, QueryParamOverlayDefinitionConfig, QueryParamOverlayHost, QueryParamOverlayOpener, QueryParamOverlayValue, RadioVariant, RangeSliderValue, RatingIconContext, RatingIconState, ReconcilableColumn, ReduceSupportPresentationInput, RegisteredIconName, RegisteredIconVariant, RequiredLanguagesOptions, ResizeSpanBounds, ResolveClosestOverlayOptions, ResolveCollisionsOptions, ResolvedDropzoneUploadConfig, RichTextEditorLabels, RichTextEditorLinkEditorValue, RichTextEditorQueryTriggerConfig, RichTextEditorTool, RichTextEditorToolButton, RichTextEditorToolDefinition, RichTextEditorToolsConfig, RichTextEditorTrigger, RichTextEditorTriggerItem, RichTextEditorTriggerItemResolver, RichTextEditorTriggerItemSource, RichTextEditorTriggerType, RowFloors, ScrollableActiveChildRef, ScrollableButtonPosition, ScrollableDirection, ScrollableIntersectionChange, ScrollableItemSize, ScrollableLoadingTemplatePosition, ScrollableLoadingTemplateRef, ScrollableMaskVariant, ScrollableNavigation, ScrollableNavigationItem, ScrollableScrollMode, ScrollableScrollOrigin, ScrollableScrollState, SegmentedButtonGroupVariant, SelectAsyncOptions, SelectErrorContext, SelectFilterMode, SelectItem, SelectLabels, SelectOptionData, SelectOptionGroupItem, SelectOptionTemplateContext, SelectOptionsFromQuery, SelectOptionsFromQueryConfig, SelectOptionsFromV2QueryConfig, SelectSelectedEntry, SelectSurfaceContext, SelectValueContext, SelectionListDirectiveBase, SelectionListItem, SerializeOptions, SidebarOverlay, SidebarOverlayConfig, SingleEliminationBracketRoundType, SkeletonShape, SliderHostBase, SliderLabels, SliderThumbBase, SliderThumbLabelBase, SliderThumbLabelContext, SortRowsConfig, StreamConfig, StreamConsentConfig, StreamLabels, StreamManager, StreamPipEntry, StreamPipWindowConfig, StreamPlayer, StreamPlayerCapabilities, StreamPlayerEntry, StreamPlayerErrorConfig, StreamPlayerErrorContext, StreamPlayerId, StreamPlayerLoadingConfig, StreamPlayerParams, StreamPlayerSlotHandle, StreamPlayerSlotOptions, StreamPlayerState, StreamScriptLoader, StreamSlotEntry, SupportContentState, SupportPresentationState, SupportTransitionDirection, SwissBracketRoundType, TabBarFit, TabBarOrientation, TabBarVariant, TabSize, TableCellContext, TableCellErrorMark, TableCellErrorTooltipConfig, TableCellSkeletonContext, TableCellState, TableCellStateValue, TableColumn, TableColumnAlign, TableColumnDef, TableColumnMenuConfig, TableColumnMeta, TableColumnState, TableColumnTemplate, TableColumnVisibilityHost, TableColumns, TableEmptyContext, TableErrorContext, TableExpandedRowContext, TableFeatureConfig, TableFeatureHost, TableFilter, TableFilterOption, TableFilterOptionContext, TableFilterOptionsProvider, TableFilterSelection, TableFiltersConfig, TableFooterContext, TableHeaderAdornment, TableHeaderContext, TableHeaderGroup, TableLabels, TableLabelsSource, TableLayer, TableLeadCellComponent, TableLeadColumn, TableReorderConfig, TableResizeConfig, TableRowKey, TableRowWindow, TableRowsDriver, TableRowsFromQuery, TableRowsFromQueryConfig, TableRowsFromV2QueryConfig, TableRowsQueryState, TableRowsSource, TableSelectionConfig, TableSort, TableSortDirection, TableSortValue, TableState, TableStatePersistenceConfig, TableStateSlice, TableStateStorage, TableStateStorageKind, TableStateStorageOptions, TableTemplateSlot, TableVirtualScrollConfig, TextAlign, TextareaResizeMode, TimePickerColumn, TimePickerLabels, TimePickerOption, TimePickerUnit, ToggletipContent, TooltipContent, TournamentMode, TwitchEmbed, TwitchEmbedConstructor, TwitchEmbedPlayer, TwitchPlayerParams, TwitchWindow, V2DropzonePrepareArgsOf, V2DropzoneUploadConfig, V2PrepareArgsOf, ViewportTransformData, VimeoDurationChangeEvent, VimeoPlaybackEvent, VimeoPlayer, VimeoPlayerOptions, VimeoWindow, WindowControlButtonKind, WindowControlButtonSize, YtPlayer, YtPlayerConfig, YtPlayerErrorEvent, YtPlayerEvent, YtPlayerStateChangeEvent, YtPlayerVars, YtWindow };