@eagami/ui 5.53.0 → 5.55.0

package/types/eagami-ui.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
-import { AfterContentChecked, ElementRef, EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, Type } from "@angular/core";
+import { AfterContentChecked, ElementRef, EnvironmentProviders, InjectionToken, Injector, OnDestroy, OnInit, Signal, TemplateRef, Type } from "@angular/core";
 import { AbstractControl, ControlValueAccessor } from "@angular/forms";
 /**
  * BCP 47 locale tags supported out of the box. Consumers select one of these
@@ -136,6 +136,10 @@ export interface EagamiMessages {
   dropdown: {
     placeholder: string;
   };
+  fieldLabel: {
+    /** Accessible name of the button that reveals a field label's help. */
+    help: (label: string) => string;
+  };
   fileUploader: {
     prompt: string;
     promptSingle: string;
@@ -613,13 +617,19 @@ export type EaSize = '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type EaWidth = EaSize | '2xl' | 'full';
 /**
  * Single expandable section within an `ea-accordion`. Each item exposes a
- * header button with the supplied `label` and reveals its projected content
+ * header button with the supplied `label`, or with an element projected as
+ * `slot="label"` for richer content, and reveals its other projected content
  * when expanded. Inherits its size from the parent accordion. Must be
  * rendered inside an `ea-accordion`.
  */
 export declare class AccordionItemComponent implements OnInit, OnDestroy {
   private readonly accordion;
   readonly value: import("@angular/core").InputSignal<string>;
+  /**
+   * Plain-text label shown in the header button. For richer content, project
+   * an element with `slot="label"` instead: its text then names the button, so
+   * mark purely decorative parts of it `aria-hidden`.
+   */
   readonly label: import("@angular/core").InputSignal<string>;
   /** Optional icon component rendered before the label in the header button. */
   readonly icon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
@@ -641,7 +651,7 @@ export declare class AccordionItemComponent implements OnInit, OnDestroy {
     };
     "label": {
       "alias": "label";
-      "required": true;
+      "required": false;
       "isSignal": true;
     };
     "icon": {
@@ -659,7 +669,7 @@ export declare class AccordionItemComponent implements OnInit, OnDestroy {
       "required": false;
       "isSignal": true;
     };
-  }, {}, never, ["*"], true, never>;
+  }, {}, never, ["[slot=label]", "*"], true, never>;
 }
 /** Heading level exposed by each item's header for assistive technology. */
 export type AccordionHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
@@ -668,7 +678,9 @@ export type AccordionSize = EaSize;
 /**
  * Container for expandable content sections. By default only one item can be
  * open at a time; set `multi` to allow several to stay expanded together.
- * Provides a built-in chevron animation and supports per-item disabling.
+ * Which items are open is the `expandedValues` model, so items can start
+ * expanded or be controlled from outside. Provides a built-in chevron
+ * animation and supports per-item disabling.
  */
 export declare class AccordionComponent {
   readonly multi: import("@angular/core").InputSignal<boolean>;
@@ -678,6 +690,12 @@ export declare class AccordionComponent {
   readonly headingLevel: import("@angular/core").InputSignal<AccordionHeadingLevel>;
   /** Tints an open item's header and sets its label, icon, and chevron in the brand color. */
   readonly highlightExpanded: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Values of the expanded items. Set it to open items from the start, or bind
+   * `[(expandedValues)]` to control expansion from outside. Without `multi`,
+   * only the first of them in document order stays open.
+   */
+  readonly expandedValues: import("@angular/core").ModelSignal<readonly string[]>;
   readonly expandedItems: import("@angular/core").WritableSignal<Set<string>>;
   readonly registeredItems: import("@angular/core").WritableSignal<AccordionItemComponent[]>;
   constructor();
@@ -707,16 +725,25 @@ export declare class AccordionComponent {
       "required": false;
       "isSignal": true;
     };
-  }, {}, never, ["*"], true, never>;
+    "expandedValues": {
+      "alias": "expandedValues";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "expandedValues": "expandedValuesChange";
+  }, never, ["*"], true, never>;
 }
 /** Semantic colour scheme of an alert. Drives icon and palette. */
 export type AlertVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
 /** Scales the alert's text, icon, and gap together. */
 export type AlertSize = EaSize;
+/** How assistive technology announces an alert. */
+export type AlertLive = 'auto' | 'assertive' | 'polite' | 'off';
 /**
  * Inline banner for surfacing semantic messages such as success confirmations,
  * warnings, or errors. Optionally dismissible, with a two-way `visible`
- * binding and an automatically chosen ARIA role based on severity.
+ * binding and an ARIA role chosen by severity unless `live` sets one.
  */
 export declare class AlertComponent {
   protected readonly i18n: EagamiI18nService;
@@ -726,12 +753,20 @@ export declare class AlertComponent {
   readonly visible: import("@angular/core").ModelSignal<boolean>;
   /** Overrides the variant's default status icon with any icon component. */
   readonly icon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /**
+   * How assistive technology announces the alert. `auto` interrupts for
+   * `error` and `warning` (`role="alert"`) and waits its turn for the rest
+   * (`role="status"`); `assertive` and `polite` pick one of those whatever the
+   * variant, and `off` announces nothing, for static text that is part of the
+   * page rather than news about it.
+   */
+  readonly live: import("@angular/core").InputSignal<AlertLive>;
   /** Fires when the user dismisses the alert via its close button. */
   readonly dismissed: import("@angular/core").OutputEmitterRef<void>;
   readonly alertClasses: import("@angular/core").Signal<{
     [x: string]: boolean;
   }>;
-  readonly role: import("@angular/core").Signal<"alert" | "status">;
+  readonly role: import("@angular/core").Signal<"alert" | "status" | null>;
   /** Hides the alert and emits `dismissed`. */
   dismiss(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
@@ -761,6 +796,11 @@ export declare class AlertComponent {
       "required": false;
       "isSignal": true;
     };
+    "live": {
+      "alias": "live";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "visible": "visibleChange";
     "dismissed": "dismissed";
@@ -834,6 +874,8 @@ export declare class AutocompleteComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Accessible name for the input and suggestion list when no visible label is provided. */
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string>;
@@ -848,6 +890,8 @@ export declare class AutocompleteComponent implements ControlValueAccessor {
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
   readonly errorMessages: import("@angular/core").InputSignal<Partial<Record<string, string>> | undefined>;
   readonly minLength: import("@angular/core").InputSignal<number>;
+  /** Maximum number of characters the input accepts (native `maxlength`). */
+  readonly maxLength: import("@angular/core").InputSignal<number | undefined>;
   readonly maxResults: import("@angular/core").InputSignal<number>;
   readonly emptyMessage: import("@angular/core").InputSignal<string | undefined>;
   readonly id: import("@angular/core").InputSignal<string>;
@@ -922,6 +966,11 @@ export declare class AutocompleteComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "ariaLabel": {
       "alias": "ariaLabel";
       "required": false;
@@ -977,6 +1026,11 @@ export declare class AutocompleteComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "maxLength": {
+      "alias": "maxLength";
+      "required": false;
+      "isSignal": true;
+    };
     "maxResults": {
       "alias": "maxResults";
       "required": false;
@@ -1681,19 +1735,29 @@ export declare class BreadcrumbsComponent {
     "clicked": "clicked";
   }, never, never, true, never>;
 }
-/** Visual style of a button; drives colour and emphasis. */
-export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
+/**
+ * Visual style of a button; drives colour and emphasis. `link` drops the box
+ * for an inline text link in the link colour, underlined on hover and focus.
+ */
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger' | 'link';
 /** Visual size of a button. */
 export type ButtonSize = EaSize;
 /** HTML `type` attribute applied to the underlying `<button>` element. */
 export type ButtonType = 'button' | 'submit' | 'reset';
 /**
- * Standard action button supporting primary, secondary, ghost, and danger
- * variants. Includes a loading state that swaps the label for a spinner while
- * preserving the rendered width. Chrome is tunable per instance via
+ * Placement of a button's content along its inline axis when the button is
+ * wider than its content. `start` and `end` follow the text direction.
+ */
+export type ButtonAlign = 'start' | 'center' | 'end';
+/**
+ * Standard action button supporting primary, secondary, ghost, danger, and
+ * link variants. Includes a loading state that swaps the label for a spinner
+ * while preserving the rendered width. Chrome is tunable per instance via
  * `--ea-button-padding`, `--ea-button-min-height` and `--ea-button-radius`,
  * which is how an icon-only button comes down to little more than its glyph
- * and how a call-to-action becomes a pill.
+ * and how a call-to-action becomes a pill. For navigation, put
+ * `ButtonLinkComponent` on an anchor instead (`<a eaButtonLink href="...">`):
+ * it takes the same styling inputs and keeps real link behaviour.
  */
 export declare class ButtonComponent {
   readonly variant: import("@angular/core").InputSignal<ButtonVariant>;
@@ -1702,22 +1766,28 @@ export declare class ButtonComponent {
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly loading: import("@angular/core").InputSignal<boolean>;
   readonly fullWidth: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Places the content along the inline axis of a button wider than it, as a
+   * full-width one is; `start` lets a stack of buttons read as list rows.
+   */
+  readonly align: import("@angular/core").InputSignal<ButtonAlign>;
   readonly uppercase: import("@angular/core").InputSignal<boolean>;
   /** Optional icon component rendered to the left of the label. */
   readonly icon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   readonly ariaCurrent: import("@angular/core").InputSignal<string | undefined>;
+  /** Space-separated ids of the elements whose text names the button. */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+  /** Space-separated ids of the elements that describe the button, e.g. a hint. */
+  readonly ariaDescribedby: import("@angular/core").InputSignal<string | undefined>;
+  private readonly buttonEl;
   /** Fires when the button is activated; suppressed while disabled or loading. */
   readonly clicked: import("@angular/core").OutputEmitterRef<MouseEvent>;
   readonly isDisabled: import("@angular/core").Signal<boolean>;
-  readonly hostClasses: import("@angular/core").Signal<{
-    [x: string]: boolean;
-    'ea-button--full-width': boolean;
-    'ea-button--uppercase': boolean;
-    'ea-button--loading': boolean;
-    'ea-button--disabled': boolean;
-  }>;
+  readonly hostClasses: import("@angular/core").Signal<Record<string, boolean>>;
   handleClick(event: MouseEvent): void;
+  /** Moves keyboard focus to the underlying native button. */
+  focus(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "ea-button", never, {
     "variant": {
@@ -1750,6 +1820,11 @@ export declare class ButtonComponent {
       "required": false;
       "isSignal": true;
     };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
     "uppercase": {
       "alias": "uppercase";
       "required": false;
@@ -1770,10 +1845,88 @@ export declare class ButtonComponent {
       "required": false;
       "isSignal": true;
     };
+    "ariaLabelledby": {
+      "alias": "aria-labelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "aria-describedby";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "clicked": "clicked";
   }, never, ["[slot=prefix]", "*", "[slot=suffix]"], true, never>;
 }
+/**
+ * Button styling for an anchor, for navigation that should look like a button
+ * while staying a real link: middle-click and open in a new tab work, and
+ * assistive technology announces it as a link. Put it on an `<a>` with an
+ * `href`, or with Angular's `routerLink`, which binds the `href` itself
+ * (`<a eaButtonLink routerLink="/pricing">`). Takes the same styling inputs as
+ * `ea-button` and is painted by the same stylesheet.
+ *
+ * `disabled` sets `aria-disabled`, takes the link out of the tab order, and
+ * blocks activation before `routerLink` or any `(click)` handler sees it, so
+ * nothing navigates. There is no loading state: a link hands off to the
+ * browser or router, so there is no in-flight action for a spinner to cover.
+ */
+export declare class ButtonLinkComponent {
+  protected readonly authoredTabindex: string | null;
+  readonly variant: import("@angular/core").InputSignal<ButtonVariant>;
+  readonly size: import("@angular/core").InputSignal<import("@eagami/ui").EaSize>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly fullWidth: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Places the content along the inline axis of a link wider than it, as a
+   * full-width one is; `start` lets a stack of links read as list rows.
+   */
+  readonly align: import("@angular/core").InputSignal<ButtonAlign>;
+  readonly uppercase: import("@angular/core").InputSignal<boolean>;
+  /** Optional icon component rendered before the label. */
+  readonly icon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  protected readonly boxClasses: import("@angular/core").Signal<Record<string, boolean>>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<ButtonLinkComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ButtonLinkComponent, "a[eaButtonLink]", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "fullWidth": {
+      "alias": "fullWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "uppercase": {
+      "alias": "uppercase";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[slot=prefix]", "*", "[slot=suffix]"], true, never>;
+}
 /** Visual style of a card surface. */
 export type CardVariant = 'elevated' | 'outlined' | 'filled';
 /** Padding preset applied to the card's content area. */
@@ -2216,6 +2369,8 @@ export declare class ColorPickerComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
   readonly size: import("@angular/core").InputSignal<EaSize>;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
@@ -2389,6 +2544,11 @@ export declare class ColorPickerComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -2469,340 +2629,866 @@ export declare class ColorPickerComponent implements ControlValueAccessor {
     "changed": "changed";
   }, never, never, true, never>;
 }
-/** Vertical density preset for table rows and header cells. */
-export type DataTableDensity = 'compact' | 'comfortable' | 'spacious';
-/** Visual size of the table's text, paddings, and icons. */
-export type DataTableSize = EaSize;
-/** Sort direction; `null` means no sort is applied. */
-export type DataTableSortDirection = 'asc' | 'desc' | null;
-/** Column definition for the data table, including optional cell/header templates. */
-export interface DataTableColumn<T = Record<string, unknown>> {
-  key: string;
-  label: string;
-  sortable?: boolean;
-  align?: 'left' | 'center' | 'right';
-  width?: string;
-  format?: (value: unknown) => string;
-  cellTemplate?: TemplateRef<{
-    $implicit: T;
-    value: unknown;
-  }>;
-  headerTemplate?: TemplateRef<{
-    $implicit: DataTableColumn<T>;
-  }>;
+/**
+ * Placement of the popover relative to its anchor. Each outside placement names
+ * the side of the anchor the popover attaches to, optionally followed by a corner
+ * suffix (`-start` or `-end`) that decides the alignment along the perpendicular
+ * axis. The plain side names (`top`, `bottom`, `left`, `right`) centre the
+ * popover on that axis. The `inside-` placements sit over the anchor instead,
+ * see {@link PopoverInsidePlacement}.
+ */
+export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right' | PopoverInsidePlacement;
+/**
+ * Placements that sit over the anchor rather than beside it: pinned inside one of
+ * its corners (`inside-top-start`), centred along one of its edges (`inside-top`,
+ * `inside-start`), or centred on it (`inside-center`). `start` and `end` follow the
+ * reading direction, so `inside-top-start` is the top-left corner in LTR and the
+ * top-right corner in RTL. The offset insets the popover from the edges it is
+ * pinned to, and it never flips.
+ */
+export type PopoverInsidePlacement = 'inside-top-start' | 'inside-top' | 'inside-top-end' | 'inside-start' | 'inside-center' | 'inside-end' | 'inside-bottom-start' | 'inside-bottom' | 'inside-bottom-end';
+/** A point in viewport coordinates, such as a pointer event's `clientX` and `clientY`. */
+export interface PopoverAnchorPoint {
+  readonly x: number;
+  readonly y: number;
 }
-/** Current sort state: which column is sorted and in which direction. */
-export interface DataTableSortState {
-  column: string;
-  direction: DataTableSortDirection;
+export interface PopoverPositionResult {
+  /** Top coordinate in viewport (px); pairs with `position: fixed`. */
+  readonly top: number;
+  /** Left coordinate in viewport (px). */
+  readonly left: number;
+  /** Width hint when the popover should match the anchor's width. */
+  readonly width?: number;
+  /** The anchor's measured width, for a caller capping the popover against it. */
+  readonly anchorWidth: number;
+  /** Effective placement after any flip logic ran. */
+  readonly placement: PopoverPlacement;
+}
+export interface PopoverPositionOptions {
+  readonly placement: PopoverPlacement;
+  /** Gap in px between the anchor and the popover. Default 4. */
+  readonly offset?: number;
+  /** Flip to the opposite side when the requested side overflows the viewport. Default true. */
+  readonly flip?: boolean;
+  /** Clamp inside the viewport when the popover still overflows after any flip. Default true. */
+  readonly clamp?: boolean;
+  /** Margin from the viewport edge in px when clamping. Default 8. */
+  readonly margin?: number;
+  /** Set the popover's width to match the anchor's. Useful for dropdown-style menus. */
+  readonly matchAnchorWidth?: boolean;
+  /** Right-to-left context. Swaps `-start`/`-end` alignment so they track the reading direction. */
+  readonly rtl?: boolean;
+  /**
+   * Viewport point to position against instead of the anchor's box, as a zero-size
+   * anchor. The anchor still supplies the width for `matchAnchorWidth`.
+   */
+  readonly point?: PopoverAnchorPoint | null;
+}
+interface Rect {
+  readonly width: number;
+  readonly height: number;
+}
+interface AnchorRect extends Rect {
+  readonly top: number;
+  readonly bottom: number;
+  readonly left: number;
+  readonly right: number;
+}
+interface Viewport {
+  readonly width: number;
+  readonly height: number;
 }
 /**
- * Table for tabular data with sortable columns, sticky headers, and density
- * presets. Supports striping, borders, hoverable rows, and custom cell or
- * header templates via `ng-template`. Sort state is exposed as a two-way
- * `model()` binding.
+ * Computes the viewport-space top/left for a popover anchored to `anchorRect`,
+ * applying optional flip-on-overflow and edge-clamp logic. Pure function, no
+ * DOM access. Both `<ea-popover>` and `[eaTooltip]` consume this.
+ *
+ * @param anchorRect  The anchor element's `getBoundingClientRect()`.
+ * @param popoverRect Width and height of the popover (post-render measurement).
+ * @param viewport    Viewport dimensions (`window.innerWidth/Height`).
+ * @param options     Placement and behavior flags.
  */
-export declare class DataTableComponent<T = Record<string, unknown>> {
+export declare function computePopoverPosition(anchorRect: AnchorRect, popoverRect: Rect, viewport: Viewport, options: PopoverPositionOptions): PopoverPositionResult;
+/** Placement of the menu list relative to its trigger. */
+export type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+/** Visual size of the menu, shared by all of its items. */
+export type MenuSize = EaSize;
+/**
+ * Popup action menu attached to any focusable element via the
+ * `[eaMenuTrigger]` directive. Supports keyboard navigation
+ * (arrow keys, Home/End), closes on outside click or Escape, and restores
+ * focus to the trigger on close. Positioning, dismissal, and SSR-safe scroll
+ * handling are provided by `<ea-popover>`.
+ */
+export declare class MenuComponent {
+  private readonly injector;
   private readonly i18n;
-  private readonly host;
-  private readonly activeCell;
-  private static readonly PAGE_JUMP;
-  readonly columns: import("@angular/core").InputSignal<DataTableColumn<T>[]>;
-  readonly data: import("@angular/core").InputSignal<T[]>;
-  /**
-   * Rows holding each column's widest content. They are laid out but never shown,
-   * so column widths come from them rather than from whichever rows are in `data`,
-   * and stay put across pages and while data loads. Moot with `stickyHeader`, whose
-   * columns share the width equally unless given a `width`.
-   */
-  readonly sizingRows: import("@angular/core").InputSignal<T[]>;
-  /** Accessible name for the table, announced when it takes focus as a grid. */
-  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
-  /** Visible caption rendered above the table; also names it for assistive technology. */
-  readonly caption: import("@angular/core").InputSignal<string | undefined>;
-  readonly trackBy: import("@angular/core").InputSignal<keyof T | undefined>;
-  readonly density: import("@angular/core").InputSignal<DataTableDensity>;
-  /** Visual size of the table; density paddings and icons scale with it. */
+  private readonly listEl;
+  readonly placement: import("@angular/core").InputSignal<MenuPlacement>;
+  /** Visual size of the menu; every item inherits it. */
   readonly size: import("@angular/core").InputSignal<EaSize>;
-  readonly stickyHeader: import("@angular/core").InputSignal<boolean>;
-  readonly striped: import("@angular/core").InputSignal<boolean>;
-  readonly hoverable: import("@angular/core").InputSignal<boolean>;
-  readonly bordered: import("@angular/core").InputSignal<boolean>;
-  /** Keeps every cell on one line, so a narrow viewport scrolls the table sideways instead of wrapping its text. */
-  readonly nowrap: import("@angular/core").InputSignal<boolean>;
-  readonly noDataText: import("@angular/core").InputSignal<string | undefined>;
-  /** Enables grid keyboard navigation: `role="grid"`, roving tabindex, and arrow-key cell movement. */
-  readonly navigable: import("@angular/core").InputSignal<boolean>;
-  /** Marks body rows as clickable: shows a pointer cursor and emits `rowActivate` on click or Enter/Space. Independent of `hoverable` and `navigable`. */
-  readonly clickable: import("@angular/core").InputSignal<boolean>;
+  /** Max height of the scrollable list as a CSS length; tall menus scroll past it. */
+  readonly maxHeight: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Accessible label for the menu, falling back to the active locale. */
+  readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  /** Fires when the menu opens. */
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  /** Fires when the menu closes. */
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  /** Trigger element currently anchoring the menu. Signal-typed so `<ea-popover>` reacts when it changes. */
+  protected readonly triggerEl: import("@angular/core").WritableSignal<HTMLElement | undefined>;
+  protected readonly asContextMenu: import("@angular/core").WritableSignal<boolean>;
+  protected readonly anchorPoint: import("@angular/core").WritableSignal<PopoverAnchorPoint | null>;
+  readonly activeItemId: import("@angular/core").WritableSignal<string | null>;
+  constructor();
+  /** Toggles the menu open state, anchoring it to the given trigger element. */
+  toggleAt(triggerEl: HTMLElement): void;
+  /** Opens the menu anchored to the given trigger element and focuses the first item. */
+  openAt(triggerEl: HTMLElement): void;
   /**
-   * Gives a row its link target, or `null` for none. Every cell of the row then holds
-   * a real link, so the browser shows the target on hover and a modified click opens
-   * it elsewhere, while a plain click still emits `rowActivate` for the app to route.
-   * A row given `null` is inert: no link, hover highlight, focus or activation.
+   * Opens the menu as the context menu of `anchorEl`: at `point` when given (a
+   * pointer position, in viewport coordinates), else at its placement against the
+   * anchor. Focuses the first item, closes on any click or context-menu request
+   * outside the menu, and hands focus back to wherever it was on close.
    */
-  readonly rowHref: import("@angular/core").InputSignal<((row: T) => string | null) | undefined>;
-  readonly sort: import("@angular/core").ModelSignal<DataTableSortState>;
-  /** Fires whenever the sort column or direction changes via header click. */
-  readonly sorted: import("@angular/core").OutputEmitterRef<DataTableSortState>;
-  /** Fires with the row's data when a body row is activated by click or Enter/Space while `clickable` is set. */
-  readonly rowActivate: import("@angular/core").OutputEmitterRef<T>;
-  readonly noDataTemplate: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
-  /** Empty-state text, falling back to the active locale's translation. */
-  readonly resolvedNoDataText: import("@angular/core").Signal<string>;
-  readonly hostClasses: import("@angular/core").Signal<{
-    [x: string]: boolean;
-    'ea-data-table--sticky': boolean;
-    'ea-data-table--striped': boolean;
-    'ea-data-table--hoverable': boolean;
-    'ea-data-table--bordered': boolean;
-    'ea-data-table--nowrap': boolean;
-    'ea-data-table--navigable': boolean;
-    'ea-data-table--clickable': boolean;
-    'ea-data-table--linked': boolean;
-  }>;
-  constructor();
-  readonly sortedData: import("@angular/core").Signal<T[]>;
-  getCellValue(row: T, key: string): unknown;
-  onHeaderClick(col: DataTableColumn<T>): void;
-  trackByFn(_index: number, item: T): unknown;
-  headerTabindex(colIndex: number): number | null;
-  onHeaderKeydown(event: Event, col: DataTableColumn<T>): void;
-  bodyCellTabindex(row: number, colIndex: number): number | null;
-  isInert(row: T): boolean;
-  rowTabindex(row: T): number | null;
-  onRowActivate(row: T, event?: Event): void;
-  onCellFocus(row: number, col: number): void;
-  onGridKeydown(event: KeyboardEvent): void;
-  private focusCell;
-  static ɵfac: i0.ɵɵFactoryDeclaration<DataTableComponent<any>, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<DataTableComponent<any>, "ea-data-table", never, {
-    "columns": {
-      "alias": "columns";
-      "required": true;
+  openAsContextMenu(anchorEl: HTMLElement, point?: PopoverAnchorPoint | null): void;
+  private show;
+  /**
+   * Closes the menu if it is open. Pass `restoreFocus: true` to return focus
+   * to the trigger element (used when closing via Escape or item activation;
+   * not used on outside click, where the user has chosen a new focus target).
+   */
+  close(restoreFocus?: boolean): void;
+  /** Called by `<ea-popover>` when the user clicks outside the menu. */
+  onPopoverCloseRequested(): void;
+  private getEnabledItems;
+  /**
+   * `preventScroll: true` is critical here. The menu list is `position: fixed`
+   * but its DOM ancestor is whatever element hosts the menu (often a sticky
+   * header). When `.focus()` is called without `preventScroll`, Chromium uses
+   * the focused element's DOM-tree position (inside the sticky ancestor) rather
+   * than its rendered fixed position to decide whether to scroll, which on a
+   * scrolled page nudges the document up by a few pixels per open, until the
+   * trigger reaches the top edge. The same guard applies to keyboard navigation
+   * and restoring focus on close.
+   */
+  private focusFirstItem;
+  private focusItem;
+  onKeydown(event: KeyboardEvent): void;
+  onEscape(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "ea-menu", never, {
+    "placement": {
+      "alias": "placement";
+      "required": false;
       "isSignal": true;
     };
-    "data": {
-      "alias": "data";
-      "required": true;
+    "size": {
+      "alias": "size";
+      "required": false;
       "isSignal": true;
     };
-    "sizingRows": {
-      "alias": "sizingRows";
+    "maxHeight": {
+      "alias": "maxHeight";
       "required": false;
       "isSignal": true;
     };
-    "ariaLabel": {
-      "alias": "aria-label";
+    "disabled": {
+      "alias": "disabled";
       "required": false;
       "isSignal": true;
     };
-    "caption": {
-      "alias": "caption";
+    "ariaLabel": {
+      "alias": "aria-label";
       "required": false;
       "isSignal": true;
     };
-    "trackBy": {
-      "alias": "trackBy";
+    "id": {
+      "alias": "id";
       "required": false;
       "isSignal": true;
     };
-    "density": {
-      "alias": "density";
+    "open": {
+      "alias": "open";
       "required": false;
       "isSignal": true;
     };
-    "size": {
-      "alias": "size";
-      "required": false;
+  }, {
+    "open": "openChange";
+    "opened": "opened";
+    "closed": "closed";
+  }, never, ["*"], true, never>;
+}
+/** What a trigger such as `[eaContextMenuTrigger]` asked for when requesting the popover open. */
+export interface PopoverOpenRequest {
+  /** Viewport point to open at, for the parent to bind to `[anchorPoint]`; `null` places it against the anchor. */
+  readonly point: PopoverAnchorPoint | null;
+}
+/** ARIA role to apply to the popover surface. */
+export type PopoverRole = 'menu' | 'listbox' | 'dialog' | 'tooltip' | 'grid';
+/**
+ * How the popover should respond to scroll / resize events while open.
+ *
+ * - `reposition` (default): re-measure the anchor and update the popover's
+ *   coordinates so it stays attached. Suitable for menus and tooltips.
+ * - `close`: request close. Suitable for dropdown lists and the colour-picker
+ *   popover, where re-tracking a tall popover during a scroll feels intrusive.
+ * - `ignore`: do nothing. The popover stays at its initial coordinates and
+ *   may visually detach from a scrolling anchor; useful when the anchor is
+ *   guaranteed not to move (e.g. inside a non-scrolling region).
+ */
+export type PopoverScrollBehavior = 'reposition' | 'close' | 'ignore';
+/** Width cap for a popover surface: px, or the anchor's own width. */
+export type PopoverMaxWidth = number | 'anchor';
+/**
+ * Floating-element primitive. Renders projected content as `position: fixed`
+ * anchored to an external element, with flip-on-overflow, viewport clamping,
+ * outside-click and Escape dismissal, and SSR-safe scroll / resize handling.
+ *
+ * The primitive is intentionally low-level: a parent component drives the
+ * `[open]` state and listens for `(closeRequested)` to mirror it back. Internal
+ * library components (`<ea-menu>`, `<ea-dropdown>`, `<ea-color-picker>`,
+ * `<ea-date-picker>`, `[eaTooltip]`) compose on top of it; downstream apps can
+ * use it directly to build their own popover-based UI. Set `contextMenu` and
+ * pair it with `[eaContextMenuTrigger]` to open it as a context menu.
+ *
+ * @example
+ * ```html
+ * <button #trigger (click)="open.set(!open())">Open</button>
+ * <ea-popover [anchor]="trigger" [open]="open()" (closeRequested)="open.set(false)">
+ *   <div>Popover content</div>
+ * </ea-popover>
+ * ```
+ */
+export declare class PopoverComponent {
+  private readonly destroyRef;
+  private readonly press;
+  private readonly surfaceEl;
+  /** Anchor element the popover positions itself against. */
+  readonly anchor: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
+  /** Whether the popover is currently open. */
+  readonly open: import("@angular/core").InputSignal<boolean>;
+  /** Where the popover attaches relative to the anchor. */
+  readonly placement: import("@angular/core").InputSignal<PopoverPlacement>;
+  /**
+   * Viewport point to position against instead of the anchor's box, such as where
+   * a context menu was requested. The placement applies around the point, which
+   * keeps its offset from the anchor as the page scrolls.
+   */
+  readonly anchorPoint: import("@angular/core").InputSignal<PopoverAnchorPoint | null>;
+  /** ARIA role applied to the popover surface. */
+  readonly role: import("@angular/core").InputSignal<PopoverRole>;
+  /** Accessible label. Falls back to nothing; consumers should provide one when no visible heading is in the popover. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Id of the element that labels the popover surface, forwarded as `aria-labelledby`. */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+  /** Keep Tab and Shift+Tab cycling within the surface while open (dialog pattern). */
+  readonly trapFocus: import("@angular/core").InputSignal<boolean>;
+  /** DOM id for the surface so trigger elements can reference it via aria-controls. */
+  readonly surfaceId: import("@angular/core").InputSignal<string>;
+  /**
+   * Gap in px between the anchor and the popover. Defaults to 2 so an open panel
+   * clears the anchor's active focus ring instead of sitting flush over it.
+   */
+  readonly offset: import("@angular/core").InputSignal<number>;
+  /** Flip to the opposite side when the requested side overflows the viewport. */
+  readonly flip: import("@angular/core").InputSignal<boolean>;
+  /** Clamp the popover inside the viewport when it would otherwise overflow. */
+  readonly clamp: import("@angular/core").InputSignal<boolean>;
+  /** Set the popover's `min-width` to match the anchor's width (dropdown pattern). */
+  readonly matchAnchorWidth: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Widest the surface may grow: a px value, or `anchor` to cap it at the
+   * anchor's own width so long content truncates instead of widening the panel.
+   */
+  readonly maxWidth: import("@angular/core").InputSignal<PopoverMaxWidth | undefined>;
+  /** Close on click outside the popover and the anchor. */
+  readonly closeOnOutsideClick: import("@angular/core").InputSignal<boolean>;
+  /** Close on Escape. */
+  readonly closeOnEscape: import("@angular/core").InputSignal<boolean>;
+  /** What to do on scroll / resize while open. */
+  readonly scrollBehavior: import("@angular/core").InputSignal<PopoverScrollBehavior>;
+  /**
+   * Behaves as a context menu: moves focus to the first focusable element once
+   * shown and hands it back on close, and treats clicks on the anchor and
+   * context-menu requests anywhere outside the surface as outside clicks.
+   */
+  readonly contextMenu: import("@angular/core").InputSignal<boolean>;
+  /** Requested close. The parent should mirror this into `[open]`. */
+  readonly closeRequested: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * Requested open, from a trigger such as `[eaContextMenuTrigger]`. The parent
+   * should mirror this into `[open]`, and the point into `[anchorPoint]`.
+   */
+  readonly openRequested: import("@angular/core").OutputEmitterRef<PopoverOpenRequest>;
+  private readonly position;
+  private latched;
+  private pointOffset;
+  private focusReturn;
+  /** True placement after flip, for class-based styling (e.g. arrow direction). */
+  readonly effectivePlacement: import("@angular/core").Signal<PopoverPlacement>;
+  /** Latches true once the post-rAF reposition has run, so the surface is
+   * only revealed after its dimensions are guaranteed stable. Reset on close. */
+  private readonly stable;
+  /** True once the first `reposition()` has resolved a placement on a
+   * laid-out surface. Drives the `--positioned` class. */
+  readonly isPositioned: import("@angular/core").Signal<boolean>;
+  /** Class list for the surface. Computed in TS so the placement key (with
+   * its interpolated suffix) and the positioned modifier compose cleanly. */
+  readonly surfaceClass: import("@angular/core").Signal<string>;
+  /** Inline style applied to the surface element. */
+  readonly surfaceStyle: import("@angular/core").Signal<Record<string, string>>;
+  constructor();
+  requestOpen(point: PopoverAnchorPoint | null): void;
+  private resolveAnchor;
+  private reposition;
+  onDocumentClick(event: MouseEvent): void;
+  onSurfaceKeydown(event: KeyboardEvent): void;
+  private focusableElements;
+  private focusFirstElement;
+  private trackFocusReturn;
+  onEscape(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "ea-popover", never, {
+    "anchor": {
+      "alias": "anchor";
+      "required": true;
       "isSignal": true;
     };
-    "stickyHeader": {
-      "alias": "stickyHeader";
+    "open": {
+      "alias": "open";
       "required": false;
       "isSignal": true;
     };
-    "striped": {
-      "alias": "striped";
+    "placement": {
+      "alias": "placement";
       "required": false;
       "isSignal": true;
     };
-    "hoverable": {
-      "alias": "hoverable";
+    "anchorPoint": {
+      "alias": "anchorPoint";
       "required": false;
       "isSignal": true;
     };
-    "bordered": {
-      "alias": "bordered";
+    "role": {
+      "alias": "role";
       "required": false;
       "isSignal": true;
     };
-    "nowrap": {
-      "alias": "nowrap";
+    "ariaLabel": {
+      "alias": "aria-label";
       "required": false;
       "isSignal": true;
     };
-    "noDataText": {
-      "alias": "noDataText";
+    "ariaLabelledby": {
+      "alias": "aria-labelledby";
       "required": false;
       "isSignal": true;
     };
-    "navigable": {
-      "alias": "navigable";
+    "trapFocus": {
+      "alias": "trapFocus";
       "required": false;
       "isSignal": true;
     };
-    "clickable": {
-      "alias": "clickable";
+    "surfaceId": {
+      "alias": "surfaceId";
       "required": false;
       "isSignal": true;
     };
-    "rowHref": {
-      "alias": "rowHref";
+    "offset": {
+      "alias": "offset";
       "required": false;
       "isSignal": true;
     };
-    "sort": {
-      "alias": "sort";
+    "flip": {
+      "alias": "flip";
       "required": false;
       "isSignal": true;
     };
-  }, {
-    "sort": "sortChange";
-    "sorted": "sorted";
-    "rowActivate": "rowActivate";
-  }, ["noDataTemplate"], ["ea-paginator"], true, never>;
-}
-/** Visual size of each digit cell. */
-export type CodeInputSize = EaSize;
-/**
- * Verification code entry made up of one input per digit. Auto-advances on
- * input, supports paste of the full code at once, and integrates with Angular
- * forms via `ControlValueAccessor`.
- */
-export declare class CodeInputComponent implements ControlValueAccessor {
-  readonly digitEls: import("@angular/core").Signal<readonly ElementRef<HTMLInputElement>[]>;
-  protected readonly i18n: EagamiI18nService;
-  readonly label: import("@angular/core").InputSignal<string | undefined>;
-  /** Optional icon component rendered before the label text. */
-  readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
-  /** Placeholder text spread one character per cell (cell i shows character i). */
-  readonly placeholder: import("@angular/core").InputSignal<string>;
-  readonly length: import("@angular/core").InputSignal<number>;
-  readonly size: import("@angular/core").InputSignal<EaSize>;
-  readonly hint: import("@angular/core").InputSignal<string | undefined>;
-  readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
-  /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
-  readonly errorMessages: import("@angular/core").InputSignal<Partial<Record<string, string>> | undefined>;
-  readonly disabled: import("@angular/core").InputSignal<boolean>;
-  readonly readonly: import("@angular/core").InputSignal<boolean>;
-  readonly required: import("@angular/core").InputSignal<boolean>;
-  /** Allow any non-whitespace character; when false (default) only digits are accepted. */
-  readonly allowAllChars: import("@angular/core").InputSignal<boolean>;
-  readonly id: import("@angular/core").InputSignal<string>;
-  readonly value: import("@angular/core").ModelSignal<string>;
-  readonly focusedIndex: import("@angular/core").WritableSignal<number>;
-  private readonly _formDisabled;
-  /** Fires with the full code once every digit has been entered. */
-  readonly completed: import("@angular/core").OutputEmitterRef<string>;
-  private onChange;
-  private onTouched;
-  readonly isDisabled: import("@angular/core").Signal<boolean>;
-  private readonly errorState;
-  readonly errorText: import("@angular/core").Signal<string | null>;
-  readonly hasError: import("@angular/core").Signal<boolean>;
-  readonly showError: import("@angular/core").Signal<boolean>;
-  readonly showHint: import("@angular/core").Signal<boolean>;
-  readonly digits: import("@angular/core").Signal<string[]>;
-  readonly placeholders: import("@angular/core").Signal<string[]>;
-  readonly indices: import("@angular/core").Signal<number[]>;
-  writeValue(val: string): void;
-  registerOnChange(fn: (value: string) => void): void;
-  registerOnTouched(fn: () => void): void;
-  setDisabledState(isDisabled: boolean): void;
-  handleInput(event: Event, index: number): void;
-  handleKeydown(event: KeyboardEvent, index: number): void;
-  handlePaste(event: ClipboardEvent): void;
-  handleFocus(index: number): void;
-  handleBlur(): void;
-  /** Moves keyboard focus to the next empty digit (or the last one when full). */
-  focus(): void;
-  private sanitize;
-  private focusDigit;
-  static ɵfac: i0.ɵɵFactoryDeclaration<CodeInputComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<CodeInputComponent, "ea-code-input", never, {
-    "label": {
-      "alias": "label";
+    "clamp": {
+      "alias": "clamp";
       "required": false;
       "isSignal": true;
     };
-    "labelIcon": {
-      "alias": "labelIcon";
+    "matchAnchorWidth": {
+      "alias": "matchAnchorWidth";
       "required": false;
       "isSignal": true;
     };
-    "placeholder": {
-      "alias": "placeholder";
+    "maxWidth": {
+      "alias": "maxWidth";
       "required": false;
       "isSignal": true;
     };
-    "length": {
-      "alias": "length";
+    "closeOnOutsideClick": {
+      "alias": "closeOnOutsideClick";
       "required": false;
       "isSignal": true;
     };
-    "size": {
-      "alias": "size";
+    "closeOnEscape": {
+      "alias": "closeOnEscape";
       "required": false;
       "isSignal": true;
     };
-    "hint": {
-      "alias": "hint";
+    "scrollBehavior": {
+      "alias": "scrollBehavior";
       "required": false;
       "isSignal": true;
     };
-    "errorMsg": {
-      "alias": "errorMsg";
+    "contextMenu": {
+      "alias": "contextMenu";
       "required": false;
       "isSignal": true;
     };
-    "errorMessages": {
-      "alias": "errorMessages";
+  }, {
+    "closeRequested": "closeRequested";
+    "openRequested": "openRequested";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Where `[eaContextMenuTrigger]` opens its target: at the pointer (below the
+ * focused element for a keyboard request), or at the target's own placement
+ * against the host.
+ */
+export type ContextMenuPosition = 'pointer' | 'anchor';
+/** An overlay `[eaContextMenuTrigger]` can open as a context menu. */
+export type ContextMenuTarget = MenuComponent | PopoverComponent;
+/**
+ * Opens an `<ea-menu>` or `<ea-popover>` as the context menu of its host: on a
+ * right-click or long press, or from the keyboard with Shift+F10 or the
+ * context-menu key while focus is on the host or inside it. The browser's own
+ * menu is suppressed only when the target opens, so a `null` target, a disabled
+ * menu, or a request something inside the host has already handled leaves it be.
+ *
+ * A menu opens straight away. A popover's parent drives its `[open]` state, so it
+ * emits `openRequested` with the point to bind to `[anchorPoint]` instead; give it
+ * `[contextMenu]="true"` so it takes focus and dismisses like a context menu.
+ *
+ * @example
+ * ```html
+ * <article [eaContextMenuTrigger]="actions">Right-click me</article>
+ * <ea-menu #actions>
+ *   <ea-menu-item>Rename</ea-menu-item>
+ * </ea-menu>
+ * ```
+ */
+export declare class ContextMenuTriggerDirective {
+  private readonly el;
+  /** The menu or popover to open; `null` or `undefined` leaves the browser's own menu. */
+  readonly target: import("@angular/core").InputSignal<ContextMenuTarget | null | undefined>;
+  /**
+   * Opens at the pointer, or below the focused element for a keyboard request;
+   * `anchor` opens at the target's placement against the host instead.
+   */
+  readonly contextMenuPosition: import("@angular/core").InputSignal<ContextMenuPosition>;
+  onContextMenu(event: MouseEvent): void;
+  onKeydown(event: KeyboardEvent): void;
+  private request;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTriggerDirective, "[eaContextMenuTrigger]", never, {
+    "target": {
+      "alias": "eaContextMenuTrigger";
       "required": false;
       "isSignal": true;
     };
-    "disabled": {
-      "alias": "disabled";
+    "contextMenuPosition": {
+      "alias": "contextMenuPosition";
       "required": false;
       "isSignal": true;
     };
-    "readonly": {
-      "alias": "readonly";
-      "required": false;
+  }, {}, never, never, true, never>;
+}
+/** Vertical density preset for table rows and header cells. */
+export type DataTableDensity = 'compact' | 'comfortable' | 'spacious';
+/** Visual size of the table's text, paddings, and icons. */
+export type DataTableSize = EaSize;
+/** Sort direction; `null` means no sort is applied. */
+export type DataTableSortDirection = 'asc' | 'desc' | null;
+/** Column definition for the data table, including optional cell/header templates. */
+export interface DataTableColumn<T = Record<string, unknown>> {
+  key: string;
+  label: string;
+  sortable?: boolean;
+  align?: 'left' | 'center' | 'right';
+  width?: string;
+  format?: (value: unknown) => string;
+  cellTemplate?: TemplateRef<{
+    $implicit: T;
+    value: unknown;
+  }>;
+  headerTemplate?: TemplateRef<{
+    $implicit: DataTableColumn<T>;
+  }>;
+  /** Shown in this column's cells while the table is `loading`, in place of a skeleton bar. */
+  placeholderTemplate?: TemplateRef<{
+    $implicit: DataTableColumn<T>;
+    index: number;
+  }>;
+}
+/** A body row's context-menu request, as `rowContextMenu` emits it. */
+export interface DataTableRowContextMenuEvent<T = Record<string, unknown>> {
+  /** The row's data. */
+  readonly row: T;
+  /** The row's `<tr>`, for anchoring a menu or popover to the row. */
+  readonly rowElement: HTMLElement;
+  /** Where to open a menu: the pointer, or below the focused row or cell for a keyboard request. */
+  readonly point: PopoverAnchorPoint;
+  /** The originating event; call `preventDefault()` on it to suppress the browser's own menu. */
+  readonly event: MouseEvent | KeyboardEvent;
+}
+/** Current sort state: which column is sorted and in which direction. */
+export interface DataTableSortState {
+  column: string;
+  direction: DataTableSortDirection;
+}
+/**
+ * Table for tabular data with sortable columns, sticky headers, and density
+ * presets. Supports striping, borders, hoverable rows, and custom cell or
+ * header templates via `ng-template`. Sort state is exposed as a two-way
+ * `model()` binding.
+ */
+export declare class DataTableComponent<T = Record<string, unknown>> {
+  private readonly i18n;
+  private readonly host;
+  private readonly activeCell;
+  private static readonly PAGE_JUMP;
+  private keyboardRequestPending;
+  readonly columns: import("@angular/core").InputSignal<DataTableColumn<T>[]>;
+  readonly data: import("@angular/core").InputSignal<T[]>;
+  /**
+   * Rows holding each column's widest content. They are laid out but never shown,
+   * so column widths come from them rather than from whichever rows are in `data`,
+   * and stay put across pages and while data loads. Moot with `stickyHeader`, whose
+   * columns share the width equally unless given a `width`.
+   */
+  readonly sizingRows: import("@angular/core").InputSignal<T[]>;
+  /** Accessible name for the table, announced when it takes focus as a grid. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Visible caption rendered above the table; also names it for assistive technology. */
+  readonly caption: import("@angular/core").InputSignal<string | undefined>;
+  readonly trackBy: import("@angular/core").InputSignal<keyof T | undefined>;
+  readonly density: import("@angular/core").InputSignal<DataTableDensity>;
+  /** Visual size of the table; density paddings and icons scale with it. */
+  readonly size: import("@angular/core").InputSignal<EaSize>;
+  readonly stickyHeader: import("@angular/core").InputSignal<boolean>;
+  readonly striped: import("@angular/core").InputSignal<boolean>;
+  readonly hoverable: import("@angular/core").InputSignal<boolean>;
+  readonly bordered: import("@angular/core").InputSignal<boolean>;
+  /** Keeps every cell on one line, so a narrow viewport scrolls the table sideways instead of wrapping its text. */
+  readonly nowrap: import("@angular/core").InputSignal<boolean>;
+  readonly noDataText: import("@angular/core").InputSignal<string | undefined>;
+  /** Enables grid keyboard navigation: `role="grid"`, roving tabindex, and arrow-key cell movement. */
+  readonly navigable: import("@angular/core").InputSignal<boolean>;
+  /** Marks body rows as clickable: shows a pointer cursor and emits `rowActivate` on click or Enter/Space. Independent of `hoverable` and `navigable`. */
+  readonly clickable: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Gives a row its link target, or `null` for none. Every cell of the row then holds
+   * a real link, so the browser shows the target on hover and a modified click opens
+   * it elsewhere, while a plain click still emits `rowActivate` for the app to route.
+   * A row given `null` is inert: no link, hover highlight, focus or activation.
+   */
+  readonly rowHref: import("@angular/core").InputSignal<((row: T) => string | null) | undefined>;
+  /**
+   * Shows placeholder rows in place of the data while it loads, and marks the table
+   * busy for assistive technology. A placeholder row stands as tall as a row of text,
+   * and `sizingRows` keep the columns at their loaded widths.
+   */
+  readonly loading: import("@angular/core").InputSignal<boolean>;
+  /** How many placeholder rows to show while `loading`. */
+  readonly loadingRowCount: import("@angular/core").InputSignal<number>;
+  readonly sort: import("@angular/core").ModelSignal<DataTableSortState>;
+  /** Fires whenever the sort column or direction changes via header click. */
+  readonly sorted: import("@angular/core").OutputEmitterRef<DataTableSortState>;
+  /** Fires with the row's data when a body row is activated by click or Enter/Space while `clickable` is set. */
+  readonly rowActivate: import("@angular/core").OutputEmitterRef<T>;
+  /**
+   * Fires when a body row's context menu is requested: by right-click or long press,
+   * or by Shift+F10 or the context-menu key with focus in the row. Call
+   * `event.preventDefault()` when opening a menu of your own.
+   */
+  readonly rowContextMenu: import("@angular/core").OutputEmitterRef<DataTableRowContextMenuEvent<T>>;
+  readonly noDataTemplate: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+  /** Empty-state text, falling back to the active locale's translation. */
+  readonly resolvedNoDataText: import("@angular/core").Signal<string>;
+  readonly placeholderRows: import("@angular/core").Signal<number[]>;
+  private readonly bodyRowCount;
+  readonly hostClasses: import("@angular/core").Signal<{
+    [x: string]: boolean;
+    'ea-data-table--sticky': boolean;
+    'ea-data-table--striped': boolean;
+    'ea-data-table--hoverable': boolean;
+    'ea-data-table--bordered': boolean;
+    'ea-data-table--nowrap': boolean;
+    'ea-data-table--navigable': boolean;
+    'ea-data-table--clickable': boolean;
+    'ea-data-table--linked': boolean;
+  }>;
+  constructor();
+  readonly sortedData: import("@angular/core").Signal<T[]>;
+  getCellValue(row: T, key: string): unknown;
+  onHeaderClick(col: DataTableColumn<T>): void;
+  trackByFn(_index: number, item: T): unknown;
+  headerTabindex(colIndex: number): number | null;
+  onHeaderKeydown(event: Event, col: DataTableColumn<T>): void;
+  bodyCellTabindex(row: number, colIndex: number): number | null;
+  isInert(row: T): boolean;
+  rowTabindex(row: T): number | null;
+  onRowActivate(row: T, event?: Event): void;
+  onRowContextMenu(row: T, rowElement: HTMLElement, event: MouseEvent | KeyboardEvent): void;
+  clearKeyboardRequest(): void;
+  onCellFocus(row: number, col: number): void;
+  onGridKeydown(event: KeyboardEvent): void;
+  private focusCell;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DataTableComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DataTableComponent<any>, "ea-data-table", never, {
+    "columns": {
+      "alias": "columns";
+      "required": true;
       "isSignal": true;
     };
-    "required": {
-      "alias": "required";
-      "required": false;
+    "data": {
+      "alias": "data";
+      "required": true;
       "isSignal": true;
     };
-    "allowAllChars": {
-      "alias": "allowAllChars";
+    "sizingRows": {
+      "alias": "sizingRows";
       "required": false;
       "isSignal": true;
     };
-    "id": {
-      "alias": "id";
+    "ariaLabel": {
+      "alias": "aria-label";
       "required": false;
       "isSignal": true;
     };
-    "value": {
-      "alias": "value";
+    "caption": {
+      "alias": "caption";
       "required": false;
       "isSignal": true;
     };
-  }, {
-    "value": "valueChange";
+    "trackBy": {
+      "alias": "trackBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "density": {
+      "alias": "density";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "stickyHeader": {
+      "alias": "stickyHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "striped": {
+      "alias": "striped";
+      "required": false;
+      "isSignal": true;
+    };
+    "hoverable": {
+      "alias": "hoverable";
+      "required": false;
+      "isSignal": true;
+    };
+    "bordered": {
+      "alias": "bordered";
+      "required": false;
+      "isSignal": true;
+    };
+    "nowrap": {
+      "alias": "nowrap";
+      "required": false;
+      "isSignal": true;
+    };
+    "noDataText": {
+      "alias": "noDataText";
+      "required": false;
+      "isSignal": true;
+    };
+    "navigable": {
+      "alias": "navigable";
+      "required": false;
+      "isSignal": true;
+    };
+    "clickable": {
+      "alias": "clickable";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowHref": {
+      "alias": "rowHref";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingRowCount": {
+      "alias": "loadingRowCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "sort": "sortChange";
+    "sorted": "sorted";
+    "rowActivate": "rowActivate";
+    "rowContextMenu": "rowContextMenu";
+  }, ["noDataTemplate"], ["ea-paginator"], true, never>;
+}
+/** Visual size of each digit cell. */
+export type CodeInputSize = EaSize;
+/**
+ * Verification code entry made up of one input per digit. Auto-advances on
+ * input, supports paste of the full code at once, and integrates with Angular
+ * forms via `ControlValueAccessor`.
+ */
+export declare class CodeInputComponent implements ControlValueAccessor {
+  readonly digitEls: import("@angular/core").Signal<readonly ElementRef<HTMLInputElement>[]>;
+  protected readonly i18n: EagamiI18nService;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Optional icon component rendered before the label text. */
+  readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
+  /** Placeholder text spread one character per cell (cell i shows character i). */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly length: import("@angular/core").InputSignal<number>;
+  readonly size: import("@angular/core").InputSignal<EaSize>;
+  readonly hint: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
+  /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
+  readonly errorMessages: import("@angular/core").InputSignal<Partial<Record<string, string>> | undefined>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly readonly: import("@angular/core").InputSignal<boolean>;
+  readonly required: import("@angular/core").InputSignal<boolean>;
+  /** Allow any non-whitespace character; when false (default) only digits are accepted. */
+  readonly allowAllChars: import("@angular/core").InputSignal<boolean>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly focusedIndex: import("@angular/core").WritableSignal<number>;
+  private readonly _formDisabled;
+  /** Fires with the full code once every digit has been entered. */
+  readonly completed: import("@angular/core").OutputEmitterRef<string>;
+  private onChange;
+  private onTouched;
+  readonly isDisabled: import("@angular/core").Signal<boolean>;
+  private readonly errorState;
+  readonly errorText: import("@angular/core").Signal<string | null>;
+  readonly hasError: import("@angular/core").Signal<boolean>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  readonly showHint: import("@angular/core").Signal<boolean>;
+  readonly digits: import("@angular/core").Signal<string[]>;
+  readonly placeholders: import("@angular/core").Signal<string[]>;
+  readonly indices: import("@angular/core").Signal<number[]>;
+  writeValue(val: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  handleInput(event: Event, index: number): void;
+  handleKeydown(event: KeyboardEvent, index: number): void;
+  handlePaste(event: ClipboardEvent): void;
+  handleFocus(index: number): void;
+  handleBlur(): void;
+  /** Moves keyboard focus to the next empty digit (or the last one when full). */
+  focus(): void;
+  private sanitize;
+  private focusDigit;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CodeInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CodeInputComponent, "ea-code-input", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "labelIcon": {
+      "alias": "labelIcon";
+      "required": false;
+      "isSignal": true;
+    };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "length": {
+      "alias": "length";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMsg": {
+      "alias": "errorMsg";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessages": {
+      "alias": "errorMessages";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "allowAllChars": {
+      "alias": "allowAllChars";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
     "completed": "completed";
   }, never, never, true, never>;
 }
@@ -2840,6 +3526,8 @@ export declare class DatePickerComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Placeholder shown in the field when no date is selected. */
   readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
   readonly size: import("@angular/core").InputSignal<EaSize>;
@@ -2962,6 +3650,11 @@ export declare class DatePickerComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -3060,6 +3753,10 @@ export type DialogWidth = EaWidth;
  * `--ea-dialog-body-padding`, and `--ea-dialog-status-padding`; an
  * edge-to-edge media surface zeroes the inset, radius, and paddings.
  *
+ * The first dialog rendered by a component opened through `DialogService`
+ * answers to its `DialogRef`: it opens as soon as it renders, and a dismissal
+ * closes the ref with `undefined`.
+ *
  * Specs running under jsdom need `installNativeDialogShim()` from
  * `@eagami/ui/testing` before opening one.
  */
@@ -3072,6 +3769,7 @@ export declare class DialogComponent implements AfterContentChecked {
   private readonly press;
   private readonly scrollLock;
   private holdsScroll;
+  private boundRef;
   readonly width: import("@angular/core").InputSignal<EaWidth>;
   /**
    * Modal by default: shown via `showModal()`, with the backdrop overlay and
@@ -3115,6 +3813,7 @@ export declare class DialogComponent implements AfterContentChecked {
   protected readonly hasHeader: import("@angular/core").WritableSignal<boolean>;
   ngAfterContentChecked(): void;
   constructor();
+  private closeSurface;
   private holdScroll;
   private dropScroll;
   handleClose(): void;
@@ -3183,6 +3882,64 @@ export declare class DialogComponent implements AfterContentChecked {
     "closeRequested": "closeRequested";
   }, never, ["[slot=header]", "*", "[slot=status]", "[slot=footer]"], true, never>;
 }
+/**
+ * Handle on one dialog opened through `DialogService`. The component it opened
+ * injects it to close with an answer, which settles `result` for whoever
+ * opened it; a dismissal (Escape, the backdrop, the close button) closes it
+ * with `undefined`. Construct one directly to stand in for the service in a
+ * spec.
+ */
+export declare class DialogRef<R = unknown> {
+  private readonly isClosed;
+  private settler;
+  /** Whether the dialog has closed. */
+  readonly closed: Signal<boolean>;
+  /**
+   * Settles when the dialog closes: with the value passed to `close`, or with
+   * `undefined` when it was dismissed.
+   */
+  readonly result: Promise<R | undefined>;
+  /** Closes the dialog and settles `result` with `value`. Only the first call has any effect. */
+  close(value?: R): void;
+}
+/** Options for {@link DialogService.open}. */
+export interface DialogOptions {
+  /** Values for the component's inputs, keyed by input name and set before it first renders. */
+  inputs?: Readonly<Record<string, unknown>>;
+  /**
+   * Injector the component resolves its dependencies through, such as the
+   * opener's own so providers scoped to it reach the dialog. Defaults to the
+   * application's root injector.
+   */
+  injector?: Injector;
+}
+/**
+ * Opens dialogs from code. `open` renders a component at the end of `<body>`
+ * and returns its {@link DialogRef}. The component lays out its own
+ * `<ea-dialog>`, which shows itself straight away and closes the ref with
+ * `undefined` on any dismissal, and injects the ref to close it with an
+ * answer. Closing the ref takes the component down and hands focus back to
+ * wherever it was when the dialog opened. A dialog opened while another is up
+ * stacks on top of it.
+ *
+ * On the server nothing is rendered and the ref closes at once.
+ */
+export declare class DialogService {
+  private readonly appRef;
+  private readonly document;
+  private readonly injector;
+  private readonly isBrowser;
+  private readonly openDialogs;
+  /** Dialogs currently open, oldest first. */
+  readonly dialogs: Signal<readonly DialogRef<unknown>[]>;
+  constructor();
+  /** Opens `component` as a dialog and returns its ref, whose `result` settles when it closes. */
+  open<R = unknown>(component: Type<unknown>, options?: DialogOptions): DialogRef<R>;
+  /** Closes every open dialog, newest first, settling each `result` with `undefined`. */
+  closeAll(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /** Orientation of the divider rule. */
 export type DividerOrientation = 'horizontal' | 'vertical';
 /**
@@ -3398,6 +4155,8 @@ export declare class DropdownComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
   /** Selectable options, either flat or split into groups. */
   readonly options: import("@angular/core").InputSignal<SelectOptions>;
@@ -3482,6 +4241,11 @@ export declare class DropdownComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -3646,12 +4410,33 @@ export declare class EmptyStateComponent {
   }, {}, never, ["[slot=media]", "[slot=actions]"], true, never>;
 }
 export declare class FieldLabelComponent {
+  private readonly i18n;
+  private readonly press;
+  private readonly renderer;
   readonly text: import("@angular/core").InputSignal<string>;
   /** Optional icon component rendered before the label text. */
   readonly icon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /**
+   * Help revealed by an info button beside the label, as plain text or a
+   * template. Click, tap, Enter or Space toggles it, and it is announced when
+   * shown; Escape, a click outside, or moving focus away closes it.
+   */
+  readonly help: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly forId: import("@angular/core").InputSignal<string | undefined>;
   readonly required: import("@angular/core").InputSignal<boolean>;
   readonly labelId: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly helpOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly helpId: string;
+  protected readonly helpTemplate: import("@angular/core").Signal<TemplateRef<unknown> | null>;
+  protected readonly helpTriggerLabel: import("@angular/core").Signal<string>;
+  private readonly helpEl;
+  private readonly helpTrigger;
+  private readonly helpBubble;
+  constructor();
+  protected toggleHelp(): void;
+  protected onHelpFocusout(event: FocusEvent): void;
+  /** Raises and places an open bubble and wires its dismissal; returns the teardown. */
+  private attachHelpBubble;
   static ɵfac: i0.ɵɵFactoryDeclaration<FieldLabelComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<FieldLabelComponent, "ea-field-label", never, {
     "text": {
@@ -3664,6 +4449,11 @@ export declare class FieldLabelComponent {
       "required": false;
       "isSignal": true;
     };
+    "help": {
+      "alias": "help";
+      "required": false;
+      "isSignal": true;
+    };
     "forId": {
       "alias": "forId";
       "required": false;
@@ -3725,6 +4515,8 @@ export declare class FormFieldComponent {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Helper text shown below the control; hidden while an error is showing. */
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   /** Error message shown below the control; replaces the hint and flags the field invalid. */
@@ -3760,6 +4552,11 @@ export declare class FormFieldComponent {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -3842,6 +4639,8 @@ declare function controlErrorStateFrom(control: Signal<AbstractControl | null>,
 declare function injectControlErrorState(config: ControlErrorStateConfig): ControlErrorState;
 /** Visual size of the file uploader. */
 export type FileUploaderSize = EaSize;
+/** Presentation of the uploader: a drag-and-drop zone, or a compact picker button. */
+export type FileUploaderVariant = 'dropzone' | 'button';
 /** Reason a file was rejected during selection. */
 export type FileUploaderRejectionReason = 'type' | 'size' | 'count';
 /** Detail object emitted on the `rejected` output when one or more files fail validation. */
@@ -3859,25 +4658,56 @@ export interface FileUploaderRejection {
  * slot via the `icon` attribute: project any element to override it, and the
  * dropzone's size-aware wrapper handles sizing automatically.
  *
+ * Where a dropzone is too large, `variant="button"` swaps it for a compact
+ * `ea-button` that opens the file picker, keeping the same validation, file
+ * list and outputs.
+ *
  * @example
  * ```html
  * <ea-file-uploader label="Attach files">
  *   <ea-icon-paperclip icon />
  * </ea-file-uploader>
+ *
+ * <ea-file-uploader
+ *   variant="button"
+ *   accept=".csv"
+ *   buttonLabel="Import CSV"
+ *   [buttonIcon]="uploadIcon"
+ *   [multiple]="false" />
  * ```
  */
 export declare class FileUploaderComponent implements ControlValueAccessor {
   private readonly fileInputEl;
   private readonly dropzoneEl;
+  private readonly pickerButton;
   protected readonly i18n: EagamiI18nService;
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
   readonly errorMessages: import("@angular/core").InputSignal<Partial<Record<string, string>> | undefined>;
   readonly size: import("@angular/core").InputSignal<EaSize>;
+  /**
+   * `dropzone` renders the drag-and-drop area; `button` renders a compact
+   * secondary `ea-button` that opens the file picker instead, without drop support.
+   */
+  readonly variant: import("@angular/core").InputSignal<FileUploaderVariant>;
+  /**
+   * Visible text of the `button` variant, falling back to the localized "Browse
+   * files". An empty string together with a `buttonIcon` leaves an icon-only button.
+   */
+  readonly buttonLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Optional icon component rendered before the `button` variant's text. */
+  readonly buttonIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /**
+   * Accessible name when nothing visible names the control: no `label`, and in
+   * the `button` variant no button text either.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly required: import("@angular/core").InputSignal<boolean>;
   /**
@@ -3895,7 +4725,12 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
   /** Toggle the file list under the dropzone. */
   readonly showFileList: import("@angular/core").InputSignal<boolean>;
   /**
-   * Optional per-file progress (0-100). Keyed by `File` object identity, so
+   * Toggle the line listing the accepted types, size and file count limits, for a
+   * compact placement (an icon button in a toolbar) where it would crowd the control.
+   */
+  readonly showConstraints: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Optional per-file progress (0-100). Keyed by `File` object identity, so
    * consumers must keep the same `File` references between change-detection
    * runs. When unset, no progress bar is rendered.
    */
@@ -3926,6 +4761,7 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
   protected readonly showHint: import("@angular/core").Signal<boolean>;
   protected readonly hostClasses: import("@angular/core").Signal<{
     [x: string]: boolean;
+    'ea-file-uploader-field--button': boolean;
     'ea-file-uploader-field--error': boolean;
     'ea-file-uploader-field--disabled': boolean;
     'ea-file-uploader-field--drag-over': boolean;
@@ -3938,6 +4774,12 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
   /** Joined human-readable description of accept / maxSize / maxFiles limits. */
   protected readonly constraintsText: import("@angular/core").Signal<string>;
   protected readonly promptText: import("@angular/core").Signal<string>;
+  protected readonly dropzoneLabel: import("@angular/core").Signal<string>;
+  protected readonly labelId: import("@angular/core").Signal<string>;
+  protected readonly buttonTextId: import("@angular/core").Signal<string>;
+  protected readonly buttonText: import("@angular/core").Signal<string>;
+  protected readonly buttonLabelledBy: import("@angular/core").Signal<string | undefined>;
+  protected readonly buttonAriaLabel: import("@angular/core").Signal<string | undefined>;
   writeValue(value: readonly File[] | null | undefined): void;
   registerOnChange(fn: (value: readonly File[]) => void): void;
   registerOnTouched(fn: () => void): void;
@@ -3946,6 +4788,7 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
   protected onDropzoneKeydown(event: KeyboardEvent): void;
   protected onDropzoneFocus(): void;
   protected onDropzoneBlur(): void;
+  protected onPickerButtonFocusOut(): void;
   protected onFileSelected(event: Event): void;
   protected onDragEnter(event: DragEvent): void;
   protected onDragOver(event: DragEvent): void;
@@ -3971,6 +4814,11 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -3991,6 +4839,26 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "buttonLabel": {
+      "alias": "buttonLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "buttonIcon": {
+      "alias": "buttonIcon";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
     "disabled": {
       "alias": "disabled";
       "required": false;
@@ -4026,6 +4894,11 @@ export declare class FileUploaderComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "showConstraints": {
+      "alias": "showConstraints";
+      "required": false;
+      "isSignal": true;
+    };
     "progress": {
       "alias": "progress";
       "required": false;
@@ -4066,6 +4939,8 @@ export declare class InputComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Accessible name for the control when no visible `label` is set. */
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   /** ARIA role applied to the native input, e.g. `combobox` for a typeahead host. */
@@ -4185,6 +5060,11 @@ export declare class InputComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "ariaLabel": {
       "alias": "aria-label";
       "required": false;
@@ -4398,9 +5278,9 @@ interface XDomain {
  * Plots one or more series of values as lines, with optional points and area
  * fills. Points are spaced evenly by default, or placed along a numeric scale
  * by `xValues`, with the x-axis labelled per point or by `xTicks`. A
- * `visibleXSpan` window makes a long run of data pannable. Hovering or
- * arrowing through the chart reveals each point's values in a tooltip, and a
- * visually hidden table carries the full data for screen readers.
+ * `visibleXSpan` window makes a long run of data pannable. Hovering, tapping,
+ * or arrowing through the chart reveals each point's values in a tooltip, and
+ * a visually hidden table carries the full data for screen readers.
  */
 export declare class LineChartComponent {
   protected readonly i18n: EagamiI18nService;
@@ -4469,6 +5349,7 @@ export declare class LineChartComponent {
   readonly visibleRangeChange: import("@angular/core").OutputEmitterRef<LineChartVisibleRange>;
   private readonly viewport;
   private readonly format;
+  private readonly plotEl;
   protected readonly active: import("@angular/core").WritableSignal<ActivePoint | null>;
   protected readonly clipId: string;
   protected readonly breakMaskId: string;
@@ -4478,6 +5359,7 @@ export declare class LineChartComponent {
   protected readonly panning: import("@angular/core").WritableSignal<boolean>;
   private drag;
   private suppressClick;
+  private releaseTap;
   protected readonly label: import("@angular/core").Signal<string>;
   protected readonly count: import("@angular/core").Signal<number>;
   protected readonly hasData: import("@angular/core").Signal<boolean>;
@@ -4528,568 +5410,222 @@ export declare class LineChartComponent {
       value: string;
       active: boolean;
     }[];
-    key: string;
-  } | null>;
-  protected readonly tooltips: import("@angular/core").Signal<{
-    x: number;
-    y: number;
-    title: string;
-    rows: {
-      name: string;
-      color: string;
-      value: string;
-      active: boolean;
-    }[];
-    key: string;
-  }[]>;
-  protected readonly announcement: import("@angular/core").Signal<string>;
-  protected readonly showsLegend: import("@angular/core").Signal<boolean>;
-  protected seriesColor(index: number): string;
-  protected isDimmed(index: number): boolean;
-  protected isActivePoint(seriesIndex: number, index: number): boolean;
-  protected tableValue(value: number | null | undefined): string;
-  protected onPointerDown(event: PointerEvent): void;
-  protected onPointerMove(event: PointerEvent): void;
-  protected onPointerUp(event: PointerEvent): void;
-  protected onPointerLeave(): void;
-  protected onWheel(event: WheelEvent): void;
-  protected onClick(): void;
-  protected onFocus(): void;
-  protected onBlur(): void;
-  protected onKeydown(event: KeyboardEvent): void;
-  private isValue;
-  private yScale;
-  private atPosition;
-  private xLabelCandidates;
-  private labelsFit;
-  private xLabels;
-  private widestXLabel;
-  protected onGestureStart(event: Event): void;
-  protected onGestureChange(event: Event): void;
-  protected onGestureEnd(): void;
-  private zoomTo;
-  private minSpan;
-  private unitsPerPx;
-  private panTo;
-  private endDrag;
-  private reveal;
-  private indexAt;
-  private valueAt;
-  private firstPoint;
-  private nearestValid;
-  private eventFor;
-  private setActive;
-  static ɵfac: i0.ɵɵFactoryDeclaration<LineChartComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<LineChartComponent, "ea-line-chart", never, {
-    "labels": {
-      "alias": "labels";
-      "required": false;
-      "isSignal": true;
-    };
-    "series": {
-      "alias": "series";
-      "required": false;
-      "isSignal": true;
-    };
-    "xValues": {
-      "alias": "xValues";
-      "required": false;
-      "isSignal": true;
-    };
-    "xTicks": {
-      "alias": "xTicks";
-      "required": false;
-      "isSignal": true;
-    };
-    "visibleXSpan": {
-      "alias": "visibleXSpan";
-      "required": false;
-      "isSignal": true;
-    };
-    "curve": {
-      "alias": "curve";
-      "required": false;
-      "isSignal": true;
-    };
-    "showArea": {
-      "alias": "showArea";
-      "required": false;
-      "isSignal": true;
-    };
-    "showPoints": {
-      "alias": "showPoints";
-      "required": false;
-      "isSignal": true;
-    };
-    "showGrid": {
-      "alias": "showGrid";
-      "required": false;
-      "isSignal": true;
-    };
-    "showLegend": {
-      "alias": "showLegend";
-      "required": false;
-      "isSignal": true;
-    };
-    "yMin": {
-      "alias": "yMin";
-      "required": false;
-      "isSignal": true;
-    };
-    "yMax": {
-      "alias": "yMax";
-      "required": false;
-      "isSignal": true;
-    };
-    "xLabelOrientation": {
-      "alias": "xLabelOrientation";
-      "required": false;
-      "isSignal": true;
-    };
-    "showAxisBreak": {
-      "alias": "showAxisBreak";
-      "required": false;
-      "isSignal": true;
-    };
-    "height": {
-      "alias": "height";
-      "required": false;
-      "isSignal": true;
-    };
-    "size": {
-      "alias": "size";
-      "required": false;
-      "isSignal": true;
-    };
-    "animation": {
-      "alias": "animation";
-      "required": false;
-      "isSignal": true;
-    };
-    "animationDuration": {
-      "alias": "animationDuration";
-      "required": false;
-      "isSignal": true;
-    };
-    "formatValue": {
-      "alias": "formatValue";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "aria-label";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "pointClick": "pointClick";
-    "activePointChange": "activePointChange";
-    "visibleRangeChange": "visibleRangeChange";
-  }, never, never, true, never>;
-}
-/** Placement of the menu list relative to its trigger. */
-export type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
-/** Visual size of the menu, shared by all of its items. */
-export type MenuSize = EaSize;
-/**
- * Popup action menu attached to any focusable element via the
- * `[eaMenuTrigger]` directive. Supports keyboard navigation
- * (arrow keys, Home/End), closes on outside click or Escape, and restores
- * focus to the trigger on close. Positioning, dismissal, and SSR-safe scroll
- * handling are provided by `<ea-popover>`.
- */
-export declare class MenuComponent {
-  private readonly injector;
-  private readonly i18n;
-  private readonly listEl;
-  readonly placement: import("@angular/core").InputSignal<MenuPlacement>;
-  /** Visual size of the menu; every item inherits it. */
-  readonly size: import("@angular/core").InputSignal<EaSize>;
-  /** Max height of the scrollable list as a CSS length; tall menus scroll past it. */
-  readonly maxHeight: import("@angular/core").InputSignal<string>;
-  readonly disabled: import("@angular/core").InputSignal<boolean>;
-  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
-  readonly id: import("@angular/core").InputSignal<string>;
-  /** Accessible label for the menu, falling back to the active locale. */
-  readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
-  readonly open: import("@angular/core").ModelSignal<boolean>;
-  /** Fires when the menu opens. */
-  readonly opened: import("@angular/core").OutputEmitterRef<void>;
-  /** Fires when the menu closes. */
-  readonly closed: import("@angular/core").OutputEmitterRef<void>;
-  /** Trigger element currently anchoring the menu. Signal-typed so `<ea-popover>` reacts when it changes. */
-  protected readonly triggerEl: import("@angular/core").WritableSignal<HTMLElement | undefined>;
-  readonly activeItemId: import("@angular/core").WritableSignal<string | null>;
-  constructor();
-  /** Toggles the menu open state, anchoring it to the given trigger element. */
-  toggleAt(triggerEl: HTMLElement): void;
-  /** Opens the menu anchored to the given trigger element and focuses the first item. */
-  openAt(triggerEl: HTMLElement): void;
-  /**
-   * Closes the menu if it is open. Pass `restoreFocus: true` to return focus
-   * to the trigger element (used when closing via Escape or item activation;
-   * not used on outside click, where the user has chosen a new focus target).
-   */
-  close(restoreFocus?: boolean): void;
-  /** Called by `<ea-popover>` when the user clicks outside the menu. */
-  onPopoverCloseRequested(): void;
-  private getEnabledItems;
-  /**
-   * `preventScroll: true` is critical here. The menu list is `position: fixed`
-   * but its DOM ancestor is whatever element hosts the menu (often a sticky
-   * header). When `.focus()` is called without `preventScroll`, Chromium uses
-   * the focused element's DOM-tree position (inside the sticky ancestor) rather
-   * than its rendered fixed position to decide whether to scroll, which on a
-   * scrolled page nudges the document up by a few pixels per open, until the
-   * trigger reaches the top edge. The same guard applies to keyboard navigation
-   * and restoring focus on close.
-   */
-  private focusFirstItem;
-  private focusItem;
-  onKeydown(event: KeyboardEvent): void;
-  onEscape(event: Event): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "ea-menu", never, {
-    "placement": {
-      "alias": "placement";
-      "required": false;
-      "isSignal": true;
-    };
-    "size": {
-      "alias": "size";
-      "required": false;
-      "isSignal": true;
-    };
-    "maxHeight": {
-      "alias": "maxHeight";
-      "required": false;
-      "isSignal": true;
-    };
-    "disabled": {
-      "alias": "disabled";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "aria-label";
-      "required": false;
-      "isSignal": true;
-    };
-    "id": {
-      "alias": "id";
-      "required": false;
-      "isSignal": true;
-    };
-    "open": {
-      "alias": "open";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "open": "openChange";
-    "opened": "opened";
-    "closed": "closed";
-  }, never, ["*"], true, never>;
-}
-/** Visual style of a menu item; `danger` for destructive actions. */
-export type MenuItemVariant = 'default' | 'danger';
-/**
- * Selectable row inside an `ea-menu`. Supports leading icons via the `icon`
- * content slot, a disabled state, and a `danger` variant for destructive
- * actions. Inherits its size from the parent menu, and activating an item
- * closes that menu.
- */
-export declare class MenuItemComponent {
-  private readonly menu;
-  protected readonly itemId: string;
-  protected readonly tabIndex: import("@angular/core").Signal<0 | -1>;
-  readonly disabled: import("@angular/core").InputSignal<boolean>;
-  readonly variant: import("@angular/core").InputSignal<MenuItemVariant>;
-  /** Fires when the item is activated; the parent menu closes immediately afterwards. */
-  readonly clicked: import("@angular/core").OutputEmitterRef<MouseEvent>;
-  handleClick(event: MouseEvent): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "ea-menu-item", never, {
-    "disabled": {
-      "alias": "disabled";
-      "required": false;
-      "isSignal": true;
-    };
-    "variant": {
-      "alias": "variant";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "clicked": "clicked";
-  }, never, ["[slot=icon]", "*"], true, never>;
-}
-/**
- * Wires a focusable host element (typically a button) to an `ea-menu`,
- * handling click and keyboard activation (ArrowDown/Enter/Space to open,
- * Escape to close) and applying the appropriate ARIA attributes.
- */
-export declare class MenuTriggerDirective {
-  private readonly el;
-  private readonly renderer;
-  readonly menu: import("@angular/core").InputSignal<MenuComponent>;
-  constructor();
-  handleClick(): void;
-  handleKeydown(event: KeyboardEvent): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[eaMenuTrigger]", never, {
-    "menu": {
-      "alias": "eaMenuTrigger";
-      "required": true;
-      "isSignal": true;
-    };
-  }, {}, never, never, true, never>;
-}
-/**
- * Placement of the popover relative to its anchor. Each placement names the
- * side of the anchor the popover attaches to, optionally followed by a corner
- * suffix (`-start` or `-end`) that decides the alignment along the perpendicular
- * axis. The plain side names (`top`, `bottom`, `left`, `right`) centre the
- * popover on that axis.
- */
-export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
-export interface PopoverPositionResult {
-  /** Top coordinate in viewport (px); pairs with `position: fixed`. */
-  readonly top: number;
-  /** Left coordinate in viewport (px). */
-  readonly left: number;
-  /** Width hint when the popover should match the anchor's width. */
-  readonly width?: number;
-  /** The anchor's measured width, for a caller capping the popover against it. */
-  readonly anchorWidth: number;
-  /** Effective placement after any flip logic ran. */
-  readonly placement: PopoverPlacement;
-}
-export interface PopoverPositionOptions {
-  readonly placement: PopoverPlacement;
-  /** Gap in px between the anchor and the popover. Default 4. */
-  readonly offset?: number;
-  /** Flip to the opposite side when the requested side overflows the viewport. Default true. */
-  readonly flip?: boolean;
-  /** Clamp inside the viewport when the popover still overflows after any flip. Default true. */
-  readonly clamp?: boolean;
-  /** Margin from the viewport edge in px when clamping. Default 8. */
-  readonly margin?: number;
-  /** Set the popover's width to match the anchor's. Useful for dropdown-style menus. */
-  readonly matchAnchorWidth?: boolean;
-  /** Right-to-left context. Swaps `-start`/`-end` alignment so they track the reading direction. */
-  readonly rtl?: boolean;
-}
-interface Rect {
-  readonly width: number;
-  readonly height: number;
-}
-interface AnchorRect extends Rect {
-  readonly top: number;
-  readonly bottom: number;
-  readonly left: number;
-  readonly right: number;
-}
-interface Viewport {
-  readonly width: number;
-  readonly height: number;
-}
-/**
- * Computes the viewport-space top/left for a popover anchored to `anchorRect`,
- * applying optional flip-on-overflow and edge-clamp logic. Pure function, no
- * DOM access. Both `<ea-popover>` and `[eaTooltip]` consume this.
- *
- * @param anchorRect  The anchor element's `getBoundingClientRect()`.
- * @param popoverRect Width and height of the popover (post-render measurement).
- * @param viewport    Viewport dimensions (`window.innerWidth/Height`).
- * @param options     Placement and behavior flags.
- */
-export declare function computePopoverPosition(anchorRect: AnchorRect, popoverRect: Rect, viewport: Viewport, options: PopoverPositionOptions): PopoverPositionResult;
-/** ARIA role to apply to the popover surface. */
-export type PopoverRole = 'menu' | 'listbox' | 'dialog' | 'tooltip' | 'grid';
-/**
- * How the popover should respond to scroll / resize events while open.
- *
- * - `reposition` (default): re-measure the anchor and update the popover's
- *   coordinates so it stays attached. Suitable for menus and tooltips.
- * - `close`: request close. Suitable for dropdown lists and the colour-picker
- *   popover, where re-tracking a tall popover during a scroll feels intrusive.
- * - `ignore`: do nothing. The popover stays at its initial coordinates and
- *   may visually detach from a scrolling anchor; useful when the anchor is
- *   guaranteed not to move (e.g. inside a non-scrolling region).
- */
-export type PopoverScrollBehavior = 'reposition' | 'close' | 'ignore';
-/** Width cap for a popover surface: px, or the anchor's own width. */
-export type PopoverMaxWidth = number | 'anchor';
-/**
- * Floating-element primitive. Renders projected content as `position: fixed`
- * anchored to an external element, with flip-on-overflow, viewport clamping,
- * outside-click and Escape dismissal, and SSR-safe scroll / resize handling.
- *
- * The primitive is intentionally low-level: a parent component drives the
- * `[open]` state and listens for `(closeRequested)` to mirror it back. Internal
- * library components (`<ea-menu>`, `<ea-dropdown>`, `<ea-color-picker>`,
- * `<ea-date-picker>`, `[eaTooltip]`) compose on top of it; downstream apps can
- * use it directly to build their own popover-based UI.
- *
- * @example
- * ```html
- * <button #trigger (click)="open.set(!open())">Open</button>
- * <ea-popover [anchor]="trigger" [open]="open()" (closeRequested)="open.set(false)">
- *   <div>Popover content</div>
- * </ea-popover>
- * ```
- */
-export declare class PopoverComponent {
-  private readonly destroyRef;
-  private readonly press;
-  private readonly surfaceEl;
-  /** Anchor element the popover positions itself against. */
-  readonly anchor: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
-  /** Whether the popover is currently open. */
-  readonly open: import("@angular/core").InputSignal<boolean>;
-  /** Where the popover attaches relative to the anchor. */
-  readonly placement: import("@angular/core").InputSignal<PopoverPlacement>;
-  /** ARIA role applied to the popover surface. */
-  readonly role: import("@angular/core").InputSignal<PopoverRole>;
-  /** Accessible label. Falls back to nothing; consumers should provide one when no visible heading is in the popover. */
-  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
-  /** Id of the element that labels the popover surface, forwarded as `aria-labelledby`. */
-  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
-  /** Keep Tab and Shift+Tab cycling within the surface while open (dialog pattern). */
-  readonly trapFocus: import("@angular/core").InputSignal<boolean>;
-  /** DOM id for the surface so trigger elements can reference it via aria-controls. */
-  readonly surfaceId: import("@angular/core").InputSignal<string>;
-  /**
-   * Gap in px between the anchor and the popover. Defaults to 2 so an open panel
-   * clears the anchor's active focus ring instead of sitting flush over it.
-   */
-  readonly offset: import("@angular/core").InputSignal<number>;
-  /** Flip to the opposite side when the requested side overflows the viewport. */
-  readonly flip: import("@angular/core").InputSignal<boolean>;
-  /** Clamp the popover inside the viewport when it would otherwise overflow. */
-  readonly clamp: import("@angular/core").InputSignal<boolean>;
-  /** Set the popover's `min-width` to match the anchor's width (dropdown pattern). */
-  readonly matchAnchorWidth: import("@angular/core").InputSignal<boolean>;
-  /**
-   * Widest the surface may grow: a px value, or `anchor` to cap it at the
-   * anchor's own width so long content truncates instead of widening the panel.
-   */
-  readonly maxWidth: import("@angular/core").InputSignal<PopoverMaxWidth | undefined>;
-  /** Close on click outside the popover and the anchor. */
-  readonly closeOnOutsideClick: import("@angular/core").InputSignal<boolean>;
-  /** Close on Escape. */
-  readonly closeOnEscape: import("@angular/core").InputSignal<boolean>;
-  /** What to do on scroll / resize while open. */
-  readonly scrollBehavior: import("@angular/core").InputSignal<PopoverScrollBehavior>;
-  /** Requested close. The parent should mirror this into `[open]`. */
-  readonly closeRequested: import("@angular/core").OutputEmitterRef<void>;
-  private readonly position;
-  private latched;
-  /** True placement after flip, for class-based styling (e.g. arrow direction). */
-  readonly effectivePlacement: import("@angular/core").Signal<PopoverPlacement>;
-  /** Latches true once the post-rAF reposition has run, so the surface is
-   * only revealed after its dimensions are guaranteed stable. Reset on close. */
-  private readonly stable;
-  /** True once the first `reposition()` has resolved a placement on a
-   * laid-out surface. Drives the `--positioned` class. */
-  readonly isPositioned: import("@angular/core").Signal<boolean>;
-  /** Class list for the surface. Computed in TS so the placement key (with
-   * its interpolated suffix) and the positioned modifier compose cleanly. */
-  readonly surfaceClass: import("@angular/core").Signal<string>;
-  /** Inline style applied to the surface element. */
-  readonly surfaceStyle: import("@angular/core").Signal<Record<string, string>>;
+    key: string;
+  } | null>;
+  protected readonly tooltips: import("@angular/core").Signal<{
+    x: number;
+    y: number;
+    title: string;
+    rows: {
+      name: string;
+      color: string;
+      value: string;
+      active: boolean;
+    }[];
+    key: string;
+  }[]>;
+  protected readonly announcement: import("@angular/core").Signal<string>;
+  protected readonly showsLegend: import("@angular/core").Signal<boolean>;
   constructor();
-  private resolveAnchor;
-  private reposition;
-  onDocumentClick(event: MouseEvent): void;
-  onSurfaceKeydown(event: KeyboardEvent): void;
-  onEscape(event: Event): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "ea-popover", never, {
-    "anchor": {
-      "alias": "anchor";
-      "required": true;
+  protected seriesColor(index: number): string;
+  protected isDimmed(index: number): boolean;
+  protected isActivePoint(seriesIndex: number, index: number): boolean;
+  protected tableValue(value: number | null | undefined): string;
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected onPointerUp(event: PointerEvent): void;
+  protected onPointerCancel(event: PointerEvent): void;
+  protected onPointerLeave(): void;
+  protected onWheel(event: WheelEvent): void;
+  protected onClick(): void;
+  protected onFocus(): void;
+  protected onBlur(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  private isValue;
+  private yScale;
+  private atPosition;
+  private xLabelCandidates;
+  private labelsFit;
+  private xLabels;
+  private widestXLabel;
+  protected onGestureStart(event: Event): void;
+  protected onGestureChange(event: Event): void;
+  protected onGestureEnd(): void;
+  private zoomTo;
+  private minSpan;
+  private unitsPerPx;
+  private panTo;
+  private endDrag;
+  private holdTap;
+  private endTapHold;
+  private reveal;
+  private indexAt;
+  private valueAt;
+  private firstPoint;
+  private nearestValid;
+  private eventFor;
+  private setActive;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LineChartComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LineChartComponent, "ea-line-chart", never, {
+    "labels": {
+      "alias": "labels";
+      "required": false;
       "isSignal": true;
     };
-    "open": {
-      "alias": "open";
+    "series": {
+      "alias": "series";
       "required": false;
       "isSignal": true;
     };
-    "placement": {
-      "alias": "placement";
+    "xValues": {
+      "alias": "xValues";
       "required": false;
       "isSignal": true;
     };
-    "role": {
-      "alias": "role";
+    "xTicks": {
+      "alias": "xTicks";
       "required": false;
       "isSignal": true;
     };
-    "ariaLabel": {
-      "alias": "aria-label";
+    "visibleXSpan": {
+      "alias": "visibleXSpan";
       "required": false;
       "isSignal": true;
     };
-    "ariaLabelledby": {
-      "alias": "aria-labelledby";
+    "curve": {
+      "alias": "curve";
       "required": false;
       "isSignal": true;
     };
-    "trapFocus": {
-      "alias": "trapFocus";
+    "showArea": {
+      "alias": "showArea";
       "required": false;
       "isSignal": true;
     };
-    "surfaceId": {
-      "alias": "surfaceId";
+    "showPoints": {
+      "alias": "showPoints";
       "required": false;
       "isSignal": true;
     };
-    "offset": {
-      "alias": "offset";
+    "showGrid": {
+      "alias": "showGrid";
       "required": false;
       "isSignal": true;
     };
-    "flip": {
-      "alias": "flip";
+    "showLegend": {
+      "alias": "showLegend";
       "required": false;
       "isSignal": true;
     };
-    "clamp": {
-      "alias": "clamp";
+    "yMin": {
+      "alias": "yMin";
       "required": false;
       "isSignal": true;
     };
-    "matchAnchorWidth": {
-      "alias": "matchAnchorWidth";
+    "yMax": {
+      "alias": "yMax";
       "required": false;
       "isSignal": true;
     };
-    "maxWidth": {
-      "alias": "maxWidth";
+    "xLabelOrientation": {
+      "alias": "xLabelOrientation";
       "required": false;
       "isSignal": true;
     };
-    "closeOnOutsideClick": {
-      "alias": "closeOnOutsideClick";
+    "showAxisBreak": {
+      "alias": "showAxisBreak";
       "required": false;
       "isSignal": true;
     };
-    "closeOnEscape": {
-      "alias": "closeOnEscape";
+    "height": {
+      "alias": "height";
       "required": false;
       "isSignal": true;
     };
-    "scrollBehavior": {
-      "alias": "scrollBehavior";
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "animation": {
+      "alias": "animation";
+      "required": false;
+      "isSignal": true;
+    };
+    "animationDuration": {
+      "alias": "animationDuration";
+      "required": false;
+      "isSignal": true;
+    };
+    "formatValue": {
+      "alias": "formatValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
       "required": false;
       "isSignal": true;
     };
   }, {
-    "closeRequested": "closeRequested";
-  }, never, ["*"], true, never>;
+    "pointClick": "pointClick";
+    "activePointChange": "activePointChange";
+    "visibleRangeChange": "visibleRangeChange";
+  }, never, never, true, never>;
+}
+/** Visual style of a menu item; `danger` for destructive actions. */
+export type MenuItemVariant = 'default' | 'danger';
+/**
+ * Selectable row inside an `ea-menu`. Supports leading icons via the `icon`
+ * content slot, a disabled state, and a `danger` variant for destructive
+ * actions. Inherits its size from the parent menu, and activating an item
+ * closes that menu.
+ */
+export declare class MenuItemComponent {
+  private readonly menu;
+  protected readonly itemId: string;
+  protected readonly tabIndex: import("@angular/core").Signal<0 | -1>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly variant: import("@angular/core").InputSignal<MenuItemVariant>;
+  /** Fires when the item is activated; the parent menu closes immediately afterwards. */
+  readonly clicked: import("@angular/core").OutputEmitterRef<MouseEvent>;
+  handleClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "ea-menu-item", never, {
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "clicked": "clicked";
+  }, never, ["[slot=icon]", "*"], true, never>;
+}
+/**
+ * Wires a focusable host element (typically a button) to an `ea-menu`,
+ * handling click and keyboard activation (ArrowDown/Enter/Space to open,
+ * Escape to close) and applying the appropriate ARIA attributes.
+ */
+export declare class MenuTriggerDirective {
+  private readonly el;
+  private readonly renderer;
+  readonly menu: import("@angular/core").InputSignal<MenuComponent>;
+  constructor();
+  handleClick(): void;
+  handleKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[eaMenuTrigger]", never, {
+    "menu": {
+      "alias": "eaMenuTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Visual size of the multi-select trigger. */
 export type MultiSelectSize = EaSize;
@@ -5114,6 +5650,8 @@ export declare class MultiSelectComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Accessible name for the combobox when no visible `label` is set. */
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
@@ -5302,6 +5840,11 @@ export declare class MultiSelectComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "ariaLabel": {
       "alias": "aria-label";
       "required": false;
@@ -5423,6 +5966,8 @@ export declare class NumberInputComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Placeholder shown while the field is empty. */
   readonly placeholder: import("@angular/core").InputSignal<string>;
   /** Visual size of the field. */
@@ -5511,6 +6056,11 @@ export declare class NumberInputComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -5998,6 +6548,8 @@ export declare class RadioGroupComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
@@ -6063,6 +6615,11 @@ export declare class RadioGroupComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -6162,6 +6719,8 @@ export declare class RangeSliderComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
@@ -6237,6 +6796,11 @@ export declare class RangeSliderComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -6353,6 +6917,8 @@ export declare class RatingComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
@@ -6433,6 +6999,11 @@ export declare class RatingComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -6527,6 +7098,8 @@ export declare class SegmentedComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
@@ -6584,6 +7157,11 @@ export declare class SegmentedComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -6688,6 +7266,8 @@ export declare class SliderComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly hint: import("@angular/core").InputSignal<string | undefined>;
   readonly errorMsg: import("@angular/core").InputSignal<string | undefined>;
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
@@ -6765,6 +7345,11 @@ export declare class SliderComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "hint": {
       "alias": "hint";
       "required": false;
@@ -7018,6 +7603,8 @@ export declare class StepperComponent {
 }
 /** Visual size of the switch. */
 export type SwitchSize = EaSize;
+/** Status tone applied to the switch track in both states. */
+export type SwitchVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
 /**
  * On/off toggle styled as a sliding switch. Backed by a visually hidden
  * native checkbox and integrates with Angular forms via
@@ -7030,6 +7617,15 @@ export declare class SwitchComponent implements ControlValueAccessor {
   /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
   readonly errorMessages: import("@angular/core").InputSignal<Partial<Record<string, string>> | undefined>;
   readonly size: import("@angular/core").InputSignal<EaSize>;
+  /**
+   * Status tone for the track: a tinted wash with a toned border while off and
+   * the solid tone while on. `default` keeps the neutral off track and brand on track.
+   */
+  readonly variant: import("@angular/core").InputSignal<SwitchVariant>;
+  /** Optional icon component drawn in the thumb while the switch is on. */
+  readonly onIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Optional icon component drawn in the thumb while the switch is off. */
+  readonly offIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly required: import("@angular/core").InputSignal<boolean>;
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
@@ -7052,6 +7648,7 @@ export declare class SwitchComponent implements ControlValueAccessor {
     'ea-switch--disabled': boolean;
     'ea-switch--error': boolean;
   }>;
+  protected readonly thumbIcon: import("@angular/core").Signal<Type<unknown> | undefined>;
   writeValue(val: boolean): void;
   registerOnChange(fn: (value: boolean) => void): void;
   registerOnTouched(fn: () => void): void;
@@ -7084,6 +7681,21 @@ export declare class SwitchComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "onIcon": {
+      "alias": "onIcon";
+      "required": false;
+      "isSignal": true;
+    };
+    "offIcon": {
+      "alias": "offIcon";
+      "required": false;
+      "isSignal": true;
+    };
     "disabled": {
       "alias": "disabled";
       "required": false;
@@ -7375,11 +7987,19 @@ export declare class TagComponent {
    */
   readonly maxWidth: import("@angular/core").InputSignal<string | number | undefined>;
   /**
-   * Fill colour as a hex value, for a tag carrying a colour of its own (a
-   * user-chosen label). Paints the chip and its border, and picks whichever ink
-   * reads better on it. Takes precedence over `variant`.
+   * Fill colour, for a tag carrying a colour of its own (a user-chosen label).
+   * Paints the chip and its border, and takes precedence over `variant`. On
+   * its own it must be a hex value, from which the tag picks whichever ink
+   * reads better; alongside `ink` it takes any CSS colour, such as a
+   * theme-aware `var(--my-token)`.
    */
   readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Text colour, as any CSS colour, overriding the ink the tag would pick for
+   * `color`. Supplying it lets `color` be a value the tag cannot measure, so
+   * the contrast between the two rests with the caller.
+   */
+  readonly ink: import("@angular/core").InputSignal<string | undefined>;
   /**
    * Where a label clipped by `maxWidth` reveals its full text. Set `none` for
    * a tag rendered inside a tooltip, which would otherwise stack a second
@@ -7409,7 +8029,7 @@ export declare class TagComponent {
   }>;
   /** `maxWidth` as a CSS length; a bare number is px, as the input documents. */
   protected readonly resolvedMaxWidth: import("@angular/core").Signal<string | null>;
-  /** Ink that reads on `color`, or `null` when it is not a hex the library can measure. */
+  /** The caller's `ink`, else one that reads on a hex `color`, else `null`. */
   protected readonly resolvedInk: import("@angular/core").Signal<string | null>;
   protected readonly resolvedColor: import("@angular/core").Signal<string | null>;
   constructor();
@@ -7457,6 +8077,11 @@ export declare class TagComponent {
       "required": false;
       "isSignal": true;
     };
+    "ink": {
+      "alias": "ink";
+      "required": false;
+      "isSignal": true;
+    };
     "tooltip": {
       "alias": "tooltip";
       "required": false;
@@ -7480,9 +8105,15 @@ export declare class TagComponent {
 export type TextareaSize = EaSize;
 /** Axis along which the user is allowed to resize the textarea. */
 export type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
+/** Selected character range in the textarea; `start` equals `end` for a bare caret. */
+export interface TextareaSelection {
+  readonly start: number;
+  readonly end: number;
+}
 /**
  * Multiline text field that mirrors the `ea-input` API. Supports configurable
- * `resize` direction and `maxlength`, and integrates with Angular
+ * `resize` direction and `maxlength`, exposes the caret through
+ * `getSelection()` and `insertText()`, and integrates with Angular
  * forms via `ControlValueAccessor`.
  */
 export declare class TextareaComponent implements ControlValueAccessor {
@@ -7490,6 +8121,8 @@ export declare class TextareaComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   /** Accessible name for the control when no visible `label` is set. */
   readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string>;
@@ -7542,6 +8175,19 @@ export declare class TextareaComponent implements ControlValueAccessor {
   handleBlur(event: FocusEvent): void;
   /** Moves keyboard focus to the underlying native textarea element. */
   focus(): void;
+  /**
+   * Returns the selected range as character offsets into the value. The browser
+   * keeps it after the field loses focus, so it still reflects where the caret
+   * was left once the user has moved on to a button or a dialog.
+   */
+  getSelection(): TextareaSelection;
+  /**
+   * Replaces the current selection with `text` and places the caret after it,
+   * notifying the value model, a bound form control and native `input`
+   * listeners exactly as typing does. Does nothing while disabled or read-only,
+   * and leaves focus where it is.
+   */
+  insertText(text: string): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "ea-textarea", never, {
     "label": {
@@ -7554,6 +8200,11 @@ export declare class TextareaComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "ariaLabel": {
       "alias": "aria-label";
       "required": false;
@@ -7681,6 +8332,8 @@ export declare class TimePickerComponent implements ControlValueAccessor {
   readonly label: import("@angular/core").InputSignal<string | undefined>;
   /** Optional icon component rendered before the label text. */
   readonly labelIcon: import("@angular/core").InputSignal<Type<unknown> | undefined>;
+  /** Help revealed by an info button beside the label, as plain text or a template. */
+  readonly labelHelp: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
   readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
   readonly size: import("@angular/core").InputSignal<EaSize>;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
@@ -7851,6 +8504,11 @@ export declare class TimePickerComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "labelHelp": {
+      "alias": "labelHelp";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;