@bitforgehq/ui 0.3.0

package/types/bitforgehq-ui.d.ts

@@ -0,0 +1,3499 @@
+import * as i0 from "@angular/core";
+import { ElementRef, EnvironmentProviders, InjectionToken, Provider, Signal } from "@angular/core";
+import { FormCheckboxControl, FormValueControl, ValidationError } from "@angular/forms/signals";
+/**
+ * The one control-height scale: sm 32 px, md 40 px, lg 48 px.
+ *
+ * @summary The three height steps every sized field and control shares
+ * @since 0.3.0
+ */
+type BfSize = 'sm' | 'md' | 'lg';
+/**
+ * App-wide widget defaults, read by every sized widget whose `size` input is left unset.
+ *
+ * @summary The default height steps of text fields and of actions and choice controls
+ * @since 0.3.0
+ */
+interface BfDefaults {
+  /**
+   * Height step of text fields: bf-input, bf-number-input, bf-select, bf-textarea.
+   * @default 'md'
+   */
+  readonly fieldSize: BfSize;
+  /**
+   * Height step of actions and choice controls: bf-button, bf-icon-button, bf-chip, bf-segmented,
+   * bf-checkbox, bf-toggle, bf-radio-group.
+   * @default 'md'
+   */
+  readonly controlSize: BfSize;
+}
+/**
+ * Options of `provideBfDefaults()`: any step left out keeps the parent injector's value.
+ *
+ * @summary The size steps provideBfDefaults sets, each one falling back to the parent
+ * @since 0.3.0
+ */
+interface BfDefaultsOptions extends Partial<BfDefaults> {
+  /** Sets `fieldSize` and `controlSize` together; an explicit `fieldSize`/`controlSize` wins. */
+  readonly size?: BfSize;
+}
+/**
+ * Library defaults: compact `md` everywhere (desktop first).
+ *
+ * @summary The library's built-in widget defaults, the compact md step everywhere
+ * @since 0.3.0
+ */
+export declare const BF_DEFAULT_VALUES: BfDefaults;
+/**
+ * The widget defaults in effect for the current injector; set them with `provideBfDefaults()`.
+ *
+ * @summary Injection token holding the widget defaults in effect for an injector
+ * @since 0.3.0
+ */
+export declare const BF_DEFAULTS: InjectionToken<BfDefaults>;
+/**
+ * App-wide (ApplicationConfig) or sub-tree (a component's `providers`) widget defaults, merged
+ * over the nearest parent's. Capacitor apps: `provideBfDefaults({ fieldSize: 'lg' })` keeps the
+ * 0.2 phone look; `{ size: 'lg' }` enlarges every control.
+ *
+ * @param options The steps to set; any step left out keeps the parent's.
+ * @returns The provider of `BF_DEFAULTS`.
+ * @summary Sets the default field and control sizes for an app or a sub-tree
+ * @since 0.3.0
+ */
+export declare function provideBfDefaults(options: BfDefaultsOptions): Provider;
+/**
+ * Default text per validator kind, part of `BfLabels`; override with `provideBfLabels()`.
+ *
+ * @summary The default error text of each validator kind, shown under a form field
+ * @since 0.3.0
+ */
+interface BfValidationMessages {
+  /**
+   * `required` (Signal Forms and Reactive Forms; `Validators.requiredTrue` reports `required` too).
+   * @default 'Fill in this field'
+   */
+  readonly required: string;
+  /**
+   * `email`.
+   * @default 'Enter a valid email address'
+   */
+  readonly email: string;
+  /**
+   * `pattern`.
+   * @default 'Use the expected format'
+   */
+  readonly pattern: string;
+  /**
+   * `parse`: the text could not be read as a value (e.g. a number field).
+   * @default 'Enter a valid number'
+   */
+  readonly parse: string;
+  /**
+   * `min`, given the lower limit.
+   * @default (min) => `Enter ${min} or more`
+   */
+  readonly min: (min: number) => string;
+  /**
+   * `max`, given the upper limit.
+   * @default (max) => `Enter ${max} or less`
+   */
+  readonly max: (max: number) => string;
+  /**
+   * `minLength` (Signal Forms) and `minlength` (Reactive Forms), given the required length.
+   * @default (length) => `Use at least ${length} characters`
+   */
+  readonly minLength: (length: number) => string;
+  /**
+   * `maxLength` (Signal Forms) and `maxlength` (Reactive Forms), given the allowed length.
+   * @default (length) => `Use at most ${length} characters`
+   */
+  readonly maxLength: (length: number) => string;
+  /**
+   * `minDate`, given the earliest date.
+   * @default (date) => `Pick ${date.toLocaleDateString()} or later`
+   */
+  readonly minDate: (date: Date) => string;
+  /**
+   * `maxDate`, given the latest date.
+   * @default (date) => `Pick ${date.toLocaleDateString()} or earlier`
+   */
+  readonly maxDate: (date: Date) => string;
+  /**
+   * Any other kind without its own message.
+   * @default 'Check this value'
+   */
+  readonly fallback: string;
+}
+/**
+ * The text for one error: its own `message`, else the default for its `kind` (Signal Forms kinds
+ * `required|email|pattern|parse|min|max|minLength|maxLength|minDate|maxDate`, and the Reactive
+ * interop kinds `required|email|pattern|min|max|minlength|maxlength` whose limits sit
+ * in `context`), else `fallback`. Reads limits through type guards, never `any`.
+ *
+ * @param error A Signal Forms error, or a Reactive Forms error adapted to one.
+ * @param messages The default texts, usually `inject(BF_LABELS).validation`.
+ * @returns The text to show under the field.
+ * @summary Turns one validation error into the text a form field shows under it
+ * @since 0.3.0
+ */
+export declare function bfValidationMessage(error: ValidationError, messages: BfValidationMessages): string;
+/**
+ * Every built-in user-facing string of the library; replace any of them with `provideBfLabels()`.
+ *
+ * @summary Every built-in user-facing string of the library, one key per string
+ * @since 0.3.0
+ */
+interface BfLabels {
+  /**
+   * bf-spinner's accessible name (a loading bf-button's spinner is decorative and has none).
+   * @default 'Loading'
+   */
+  readonly loading: string;
+  /**
+   * bf-alert's dismiss button.
+   * @default 'Dismiss'
+   */
+  readonly dismiss: string;
+  /**
+   * bf-tab-bar's navigation name.
+   * @default 'Main'
+   */
+  readonly tabBar: string;
+  /**
+   * bf-tab's announcement of a numeric badge.
+   * @default (count) => `${count} new`
+   */
+  readonly tabBadge: (count: number) => string;
+  /**
+   * bf-back-button's label.
+   * @default 'Back'
+   */
+  readonly back: string;
+  /**
+   * BfAlertDialogService's default button.
+   * @default 'OK'
+   */
+  readonly ok: string;
+  /**
+   * BfActionSheetService's cancel row.
+   * @default 'Cancel'
+   */
+  readonly cancel: string;
+  /**
+   * An action sheet's name when it has no title.
+   * @default 'Actions'
+   */
+  readonly actions: string;
+  /**
+   * bf-sheet's name without an ariaLabel or heading.
+   * @default 'Sheet'
+   */
+  readonly sheet: string;
+  /**
+   * bf-modal's name without an ariaLabel or heading.
+   * @default 'Modal'
+   */
+  readonly modal: string;
+  /**
+   * bf-refresher's status while refreshing.
+   * @default 'Refreshing'
+   */
+  readonly refreshing: string;
+  /**
+   * bf-dialog's close button, and bf-sheet's screen-reader Close.
+   * @default 'Close'
+   */
+  readonly close: string;
+  /**
+   * bf-sheet's grabber button below the top snap point: the next press expands the sheet.
+   * @default 'Expand'
+   */
+  readonly expand: string;
+  /**
+   * bf-sheet's grabber button at the top snap point: the next press collapses the sheet.
+   * @default 'Collapse'
+   */
+  readonly collapse: string;
+  /**
+   * bf-sheet's snap position (1-based), announced politely when it changes and part of the
+   * grabber button's name.
+   * @default (position, count) => `Sheet at ${position} of ${count}`
+   */
+  readonly sheetPosition: (position: number, count: number) => string;
+  /**
+   * A dialog's name without an ariaLabel, a bf-dialog title or a heading.
+   * @default 'Dialog'
+   */
+  readonly dialog: string;
+  /**
+   * The desktop toast stack's region name.
+   * @default 'Notifications'
+   */
+  readonly notifications: string;
+  /** Default error text per validator kind (see `BfValidationMessages`). */
+  readonly validation: BfValidationMessages;
+}
+/**
+ * Options of `provideBfLabels()`: any key left out keeps the parent injector's string.
+ *
+ * @summary The strings provideBfLabels replaces, each one falling back to the parent
+ * @since 0.3.0
+ */
+type BfLabelsOverrides = Partial<Omit<BfLabels, 'validation'>> & {
+  readonly validation?: Partial<BfValidationMessages>;
+};
+/**
+ * The library's built-in English strings.
+ *
+ * @summary The library's built-in English strings, the labels every widget starts from
+ * @since 0.3.0
+ */
+export declare const BF_DEFAULT_LABELS: BfLabels;
+/**
+ * The strings in effect for the current injector; set them with `provideBfLabels()`.
+ *
+ * @summary Injection token holding the user-facing strings in effect for an injector
+ * @since 0.3.0
+ */
+export declare const BF_LABELS: InjectionToken<BfLabels>;
+/**
+ * Replaces built-in strings, merged over the parent's (validation merged key by key); a key left
+ * out or set to `undefined` keeps the parent's string. In `ApplicationConfig.providers` it covers
+ * every string. In a component's `providers` it covers that sub-tree's widgets and form controls
+ * (`loading`, `dismiss`, `tabBar`, `tabBadge`, `back`, `refreshing`, `validation`); the overlay
+ * services (`ok`, `cancel`, `actions`, `sheet`, `modal`, `close`, `expand`, `collapse`,
+ * `sheetPosition`, `dialog`, `notifications`) are
+ * root singletons and pick it up only when the caller passes its injector:
+ * `open(…, { injector: inject(Injector) })`.
+ *
+ * @param overrides The strings to replace; any key left out keeps the parent's.
+ * @returns The provider of `BF_LABELS`.
+ * @summary Replaces built-in strings for an app or a sub-tree, such as a translation
+ * @since 0.3.0
+ */
+export declare function provideBfLabels(overrides: BfLabelsOverrides): Provider;
+/**
+ * The diameter of a `bf-spinner`: sm, md or lg.
+ *
+ * @summary The three spinner diameters, from inline text to a page loading state
+ * @since 0.1.0
+ */
+type BfSpinnerSize = 'sm' | 'md' | 'lg';
+/**
+ * Indeterminate progress indicator. Inherits `currentColor`, so place it inside a colored parent
+ * (a button, a muted paragraph) rather than coloring it directly.
+ *
+ * @example
+ * <p class="flex items-center gap-2 text-text-muted"><bf-spinner size="sm" /> Loading recipes</p>
+ * @summary Indeterminate loading spinner in three sizes that inherits its parent's text color
+ * @category Feedback
+ * @since 0.1.0
+ */
+export declare class BfSpinnerComponent {
+  /** Visual size: 16, 20 or 24 px (the `bf-icon` sizes). */
+  readonly size: import("@angular/core").InputSignal<BfSpinnerSize>;
+  /** Screen-reader text; keep it a short verb phrase. Empty falls back to `provideBfLabels()`'s
+   * `loading` ("Loading"). Not rendered while `decorative`. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Hides the spinner from assistive tech (no status role, no live region, no label), for a
+   * spinner inside a control that already reports its busy state, such as a loading `bf-button`. */
+  readonly decorative: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly labels;
+  /** The spinner's box in px (16, 20 or 24) for its `size`.
+   * @deprecated 0.3.0 use the size input; removed in 0.4.0 */
+  readonly px: import("@angular/core").Signal<number>;
+  /** @internal The ring's classes: the shared ring plus the size's box and border width. */
+  readonly ringClasses: import("@angular/core").Signal<string>;
+  /** The rendered screen-reader text: `label`, else the `loading` label. */
+  readonly name: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfSpinnerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfSpinnerComponent, "bf-spinner", never, {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "decorative": {
+      "alias": "decorative";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * The visual style of a `bf-button`: primary (filled), tonal (soft tint), outline, text or danger.
+ *
+ * @summary The five visual styles of a button, from filled primary to plain text
+ * @since 0.1.0
+ */
+type BfButtonVariant = 'primary' | 'tonal' | 'outline' | 'text' | 'danger';
+/**
+ * The height step of a `bf-button`; the same scale as every sized widget.
+ *
+ * @deprecated 0.3.0 use BfSize; removed in 1.0.0
+ * @summary Former name of the shared size scale for buttons, kept until 1.0.0
+ * @since 0.1.0
+ */
+type BfButtonSize = BfSize;
+/**
+ * The native `type` of a `bf-button`: button, submit or reset.
+ *
+ * @summary The native button types, for a plain action, a form submit or reset
+ * @since 0.1.0
+ */
+type BfButtonType = 'button' | 'submit' | 'reset';
+/** The class maps of bf-button, shared with `bf-menu-button` (`@bitforgehq/ui/overlay`) through
+ * the internal `ɵBF_BUTTON_CLASSES` export so the two never drift. */
+declare const BUTTON_CLASSES: {
+  readonly base: string;
+  readonly variant: Record<BfButtonVariant, string>;
+  readonly pressed: Record<BfButtonVariant, string>;
+  readonly size: Record<BfSize, string>;
+  readonly padding: Record<BfSize, string>;
+  readonly textPadding: Record<BfSize, string>;
+};
+/**
+ * Pill-shaped action button with five variants, three sizes, a loading state and icon slots. Put
+ * the label in the default slot and icons in the `icon-start` / `icon-end` slots; never place a
+ * `bf-button` inside another interactive element. For navigation, put `bfButton` on your own `<a>`
+ * (with `href` or `routerLink`): it renders as a real link that looks like the button.
+ *
+ * @example
+ * <bf-button (clicked)="save()">Save changes</bf-button>
+ * <bf-button variant="tonal" size="sm" [loading]="saving()">
+ *   <bf-icon bfSlot="icon-start" [icon]="Plus" />
+ *   New task
+ * </bf-button>
+ * <a bfButton variant="outline" routerLink="/projects">All projects</a>
+ * @summary Pill-shaped action button with five variants, three sizes and a loading state
+ * @category Actions
+ * @since 0.1.0
+ * @slot icon-start An icon before the label.
+ * @slot default The label.
+ * @slot icon-end An icon after the label.
+ */
+export declare class BfButtonComponent {
+  /** Visual style: primary (filled), tonal (soft tint), outline, text, danger. */
+  readonly variant: import("@angular/core").InputSignal<BfButtonVariant>;
+  /** Height step: sm 32, md 40, lg 48 px; unset follows `provideBfDefaults()` (`controlSize`,
+   * `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Native button type. Use `submit` inside a form. Ignored on `a[bfButton]`. */
+  readonly type: import("@angular/core").InputSignal<BfButtonType>;
+  /** Disables the control and swallows clicks. Ignored on `a[bfButton]`: a link is never
+   * disabled; render a disabled `bf-button` instead. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shows a spinner instead of the start icon and blocks activation. The button stays focusable
+   * (`aria-disabled` and `aria-busy`, never native `disabled`) and keeps its variant fill. Ignored
+   * on `a[bfButton]`. */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Stretches the button to its container's width. */
+  readonly fullWidth: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted on click while enabled and not loading; on `a[bfButton]`, on every click (the link
+   * still navigates). */
+  readonly clicked: import("@angular/core").OutputEmitterRef<Event>;
+  private readonly defaults;
+  /** Whether the host is the consumer's `<a>` (`a[bfButton]`) rather than a `bf-button` element. */
+  protected readonly isLink: boolean;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /** The host's classes: the whole button on a link, else the wrapper's display and width. A link
+   * adds `no-underline!`: important, so an unlayered global rule of the app
+   * (`a { text-decoration: underline }`) cannot underline it, as it would beat a layered utility. */
+  readonly hostClasses: import("@angular/core").Signal<string>;
+  /**
+   * A click on `a[bfButton]` emits `clicked`; the browser (or `routerLink`) still follows it.
+   * @internal
+   */
+  onHostClick(event: Event): void;
+  /**
+   * The inner button's click: emits `clicked` unless disabled or loading.
+   * @internal
+   */
+  onClick(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfButtonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfButtonComponent, "bf-button, a[bfButton]", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "fullWidth": {
+      "alias": "fullWidth";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "clicked": "clicked";
+  }, never, ["[bfSlot=icon-start]", "*", "[bfSlot=icon-end]"], true, never>;
+}
+/**
+ * The visual style of a `bf-icon-button`: tonal, primary, outline or text.
+ *
+ * @summary The four visual styles of an icon button, from tonal to plain text
+ * @since 0.1.0
+ */
+type BfIconButtonVariant = 'tonal' | 'primary' | 'outline' | 'text';
+/** The class maps of bf-icon-button, shared with `bf-menu-button` (`@bitforgehq/ui/overlay`)
+ * through the internal `ɵBF_ICON_BUTTON_CLASSES` export so the two never drift. */
+declare const ICON_BUTTON_CLASSES: {
+  readonly base: string;
+  readonly variant: Record<BfIconButtonVariant, string>;
+  readonly pressed: Record<BfIconButtonVariant, string>;
+  readonly size: Record<BfSize, string>;
+};
+/**
+ * Round button that holds a single icon, for toolbars, headers and list rows. The `label` is
+ * required because the icon alone gives assistive tech no name.
+ *
+ * @example
+ * <bf-icon-button label="Search" (clicked)="openSearch()">
+ *   <bf-icon [icon]="Search" />
+ * </bf-icon-button>
+ * @summary Round icon-only button for toolbars and rows, with a required accessible label
+ * @category Actions
+ * @since 0.1.0
+ * @slot default The icon, a `bf-icon`.
+ */
+export declare class BfIconButtonComponent {
+  /** Visual style: tonal (soft tint, default), primary, outline, text. */
+  readonly variant: import("@angular/core").InputSignal<BfIconButtonVariant>;
+  /** Height step: sm 32, md 40, lg 48 px (square); unset follows `provideBfDefaults()`
+   * (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Native button type. */
+  readonly type: import("@angular/core").InputSignal<BfButtonType>;
+  /** Disables the control and swallows clicks. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Accessible name announced instead of the icon. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Emitted on click while enabled. */
+  readonly clicked: import("@angular/core").OutputEmitterRef<Event>;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /**
+   * The inner button's click: emits `clicked` unless disabled.
+   * @internal
+   */
+  onClick(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfIconButtonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfIconButtonComponent, "bf-icon-button", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "clicked": "clicked";
+  }, never, ["*"], true, never>;
+}
+/**
+ * The tone of a `bf-badge`: neutral, primary, success, warning or danger.
+ *
+ * @summary The five tones of a badge, from neutral counts to danger states
+ * @since 0.1.0
+ */
+type BfBadgeVariant = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+/**
+ * Status label ("On track", "At risk") or, with `count`, a compact numeric pill for unread counts.
+ *
+ * @example
+ * <bf-badge variant="warning">At risk</bf-badge>
+ * <bf-badge [count]="unread()" countLabel="unread messages" />
+ * @summary Small status label in semantic tones, or a compact numeric pill for counts
+ * @category Data display
+ * @since 0.1.0
+ * @slot default The badge text, shown when no `count` is set.
+ */
+export declare class BfBadgeComponent {
+  /** Tint for the label style. Ignored when `count` is set. */
+  readonly variant: import("@angular/core").InputSignal<BfBadgeVariant>;
+  /** Switches to the count pill; values above 99 render as "99+". */
+  readonly count: import("@angular/core").InputSignal<number | undefined>;
+  /** What the count counts ("unread messages"), read by assistive tech after the number ("99+
+   * unread messages"); visually hidden. Only used with `count`. */
+  readonly countLabel: import("@angular/core").InputSignal<string>;
+  readonly classes: import("@angular/core").Signal<string>;
+  readonly countText: import("@angular/core").Signal<string | null>;
+  readonly countClasses = "inline-flex h-box min-w-box items-center justify-center rounded-control bg-primary px-1.75 text-micro font-bold leading-none text-on-primary";
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfBadgeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfBadgeComponent, "bf-badge", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "count": {
+      "alias": "count";
+      "required": false;
+      "isSignal": true;
+    };
+    "countLabel": {
+      "alias": "countLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** A message paragraph that never moves the layout under a pressed pointer. */
+interface HeldMessage {
+  /** The text to render: the current one, else (while pressed) the one still on screen. */
+  readonly text: Signal<string>;
+  /** Render it visually hidden (`sr-only`): a new message that arrived during the press. It is in
+   * the DOM at once, so the ids that point at it resolve and assistive tech reads it; it becomes
+   * visible, as the same element, once the press ends. */
+  readonly hidden: Signal<boolean>;
+}
+/**
+ * The paragraph state for a message `source` (an error text) under `heldWhilePressed`: a message
+ * that appears during a press renders at once but visually hidden; one that disappears stays
+ * visible until the press ends. Call it in an injection context.
+ */
+declare function heldMessage(source: () => string): HeldMessage;
+/**
+ * `source`, except that while a pointer button is held down anywhere in the document it keeps the
+ * value it had when the press began, and catches up once the press ends. Call it in an injection
+ * context (a component field initializer).
+ */
+declare function heldWhilePressed<T>(source: () => T): Signal<T>;
+/**
+ * Label, help text and error text around a form control, with the id wiring assistive tech needs.
+ * The form widgets use it internally; use it directly only to dress a custom control the same way.
+ *
+ * @example
+ * <bf-field #field label="Project name" helpText="Shown to your team" controlId="project">
+ *   <input id="project" [class]="controlClass" [attr.aria-describedby]="field.describedBy()" />
+ * </bf-field>
+ * @summary Label, help text and error text wrapper that wires ids for assistive tech
+ * @category Forms
+ * @since 0.1.0
+ * @slot default The control the field labels, such as a native input styled with `bfFieldControlClass`.
+ */
+export declare class BfFieldComponent {
+  /** Visible label; rendered as a `<label for>` pointing at `controlId`. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Helper text under the control; stays while `error` is shown. */
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  /** Error text under the help text. One that appears while a pointer button is held down (the
+   * press on a Save button that blurred the field) renders visually hidden until the press ends,
+   * so assistive tech has it at once and the layout never moves under the pointer between
+   * mousedown and mouseup. */
+  readonly error: import("@angular/core").InputSignal<string>;
+  /** Adds the required marker to the label. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Dims the label; the control carries its own disabled styling. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The id of the control inside the default slot. */
+  readonly controlId: import("@angular/core").InputSignal<string>;
+  readonly helpId: import("@angular/core").Signal<string>;
+  readonly errorId: import("@angular/core").Signal<string>;
+  /** The error paragraph: `error`, visually hidden while a press holds the layout. */
+  protected readonly message: HeldMessage;
+  /** Value for the control's `aria-describedby`: the help id and the error id, each while it is
+   * set (`"<id>-help <id>-error"`), else null; the paragraphs render whenever they are named. */
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfFieldComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfFieldComponent, "bf-field", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "controlId": {
+      "alias": "controlId";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Field box: height and type per step (32 / 40 / 48 px). */
+declare const FIELD_BOX: Record<BfSize, string>;
+/** Inline-start padding of the text, without and with an `icon-start` slot. */
+declare const FIELD_PADDING_START: Record<BfSize, Record<'text' | 'icon', string>>;
+/** Inline-end padding of the text, without and with an `icon-end` slot. */
+declare const FIELD_PADDING_END: Record<BfSize, Record<'text' | 'icon', string>>;
+/** Inset of the `icon-start` slot from the field's inline-start edge. */
+declare const FIELD_ICON_START: Record<BfSize, string>;
+/** Inset of the `icon-end` slot from the field's inline-end edge. */
+declare const FIELD_ICON_END: Record<BfSize, string>;
+/** Box of a text-entry control: shape, border width, surface, focus ring and the native states. */
+declare const FIELD_CONTROL_BASE: string;
+/**
+ * The field state `bfFieldControlClass` styles a control for.
+ *
+ * @summary The size and state a custom field control is styled for by bfFieldControlClass
+ * @since 0.3.0
+ */
+interface BfFieldControlState {
+  /** Height step: sm 32, md 40, lg 48 px, as `bf-input`'s `size`. */
+  size: BfSize;
+  /** Whether the control shows its error state (the danger border). */
+  invalid: boolean;
+  /** Whether the control is disabled; set the control's native `disabled` too. */
+  disabled: boolean;
+  /** Whether the control is read-only; set the control's native `readonly` too. */
+  readonly: boolean;
+}
+/**
+ * The class list `bf-input` puts on its native `<input>`, for a custom control inside `bf-field`
+ * (a native input with a mask, a combobox, a date picker's text box) that must look like the
+ * library's own fields: the same box, height and type per `size`, padding, focus ring and border,
+ * with the danger border while `invalid`. The disabled and read-only styles come from the
+ * control's native `disabled` / `readonly` attributes (`:disabled`, `:read-only`), so set those on
+ * the control as well; the class list is the one `bf-input` renders in the same state.
+ *
+ * @example
+ * <input [class]="controlClass()" [id]="id" [attr.aria-describedby]="field.describedBy()" />
+ * @param state The size and state to style the control for.
+ * @returns The class list, as one string for `[class]`.
+ * @summary The class list that makes a custom control look like a library text field
+ * @since 0.3.0
+ */
+export declare function bfFieldControlClass(state: BfFieldControlState): string;
+/**
+ * The native `type` of a `bf-input`; the value stays a string (for numbers, use `bf-number-input`).
+ *
+ * @summary The native input types a text field supports, all bound as strings
+ * @since 0.1.0
+ */
+type BfInputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'time' | 'datetime-local' | 'month';
+/**
+ * Native `inputmode`: the virtual keyboard a phone shows.
+ *
+ * @summary The virtual keyboards a phone can show for a text field
+ * @since 0.2.0
+ */
+type BfInputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+/**
+ * Native `enterkeyhint`: the label of the virtual keyboard's Enter key.
+ *
+ * @summary The labels a phone keyboard can put on its Enter key
+ * @since 0.2.0
+ */
+type BfEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+/**
+ * Native `autocapitalize`: how a virtual keyboard capitalises typed text.
+ *
+ * @summary How a phone keyboard capitalises the text typed into a field
+ * @since 0.2.0
+ */
+type BfAutocapitalize = 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+/**
+ * The `inputMode` of a `bf-input`: a `BfInputMode`, or `''` (the default) to leave the native
+ * `inputmode` off.
+ *
+ * @summary A text field's virtual keyboard setting, a keyboard or empty to leave it off
+ * @since 0.3.0
+ */
+type BfInputInputMode = BfInputMode | '';
+/**
+ * The `enterKeyHint` of a `bf-input` or `bf-number-input`: a `BfEnterKeyHint`, or `''` (the
+ * default) to leave the native `enterkeyhint` off.
+ *
+ * @summary A field's Enter key label setting, a label or empty to leave it off
+ * @since 0.3.0
+ */
+type BfInputEnterKeyHint = BfEnterKeyHint | '';
+/**
+ * The `autocapitalize` of a `bf-input`: a `BfAutocapitalize`, or `''` (the default) to leave the
+ * native `autocapitalize` off.
+ *
+ * @summary A text field's capitalisation setting, a mode or empty to leave it off
+ * @since 0.3.0
+ */
+type BfInputAutocapitalize = BfAutocapitalize | '';
+/**
+ * The height step of a text field; the same scale as every sized widget.
+ *
+ * @deprecated 0.3.0 use BfSize; removed in 1.0.0
+ * @summary Former name of the shared size scale for text fields, kept until 1.0.0
+ * @since 0.1.0
+ */
+type BfFieldSize = BfSize;
+/**
+ * Single-line text field with label, help and error text, icon slots and Signal Forms binding.
+ * Bind `[(value)]` directly or `[formField]` from a signal form; the field state (touched,
+ * invalid, errors, disabled, readonly, required) flows in through the matching inputs.
+ *
+ * @example
+ * <bf-input label="Email" type="email" placeholder="name@company.ch" [(value)]="email" />
+ * <bf-input label="Email" [formField]="signup.email" />
+ * @summary Single-line text field with label, help and error text, icon slots and Signal Forms binding
+ * @category Forms
+ * @since 0.1.0
+ * @slot icon-start An icon inside the field, before the text.
+ * @slot icon-end An icon inside the field, after the text.
+ */
+export declare class BfInputComponent implements FormValueControl<string> {
+  /** The text value; two-way bindable and bound by `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<string>;
+  /** Native input type; the value stays a string. For numbers use `bf-number-input`, which binds
+   * `number | null`. */
+  readonly type: import("@angular/core").InputSignal<BfInputType>;
+  /** Height step: sm 32, md 40, lg 48 px; unset follows `provideBfDefaults()` (`fieldSize`, `md`
+   * by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Visible label above the control. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /**
+   * Accessible name when no visible label is rendered (e.g. a search field). Ignored when `label`
+   * is set.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) that name the field when no visible label is rendered. Ignored when
+   * `label` is set.
+   */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Example value shown while empty. */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  /** Helper text under the control. */
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Disables the control. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Makes the control read-only. */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the control required (label marker and native attribute). */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field; errors show only once touched. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms; the first message is shown once touched. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Native name attribute. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Control id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Reserve space for an icon in the `icon-start` slot. */
+  readonly iconStart: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Reserve space for an icon in the `icon-end` slot. */
+  readonly iconEnd: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Native autocomplete hint. */
+  readonly autocomplete: import("@angular/core").InputSignal<string>;
+  /** Maximum number of characters (native `maxlength`); bound by Signal Forms `maxLength()`. */
+  readonly maxLength: import("@angular/core").InputSignal<number | undefined>;
+  /** Minimum number of characters (native `minlength`); bound by Signal Forms `minLength()`. */
+  readonly minLength: import("@angular/core").InputSignal<number | undefined>;
+  /** Lowest value (native `min`), e.g. `2026-01-01` for a date or `0` for a number. */
+  readonly min: import("@angular/core").InputSignal<string | undefined>;
+  /** Highest value (native `max`), e.g. `2026-12-31` for a date or `100` for a number. */
+  readonly max: import("@angular/core").InputSignal<string | undefined>;
+  /** Step between valid values (native `step`), e.g. `0.5` or `any`. */
+  readonly step: import("@angular/core").InputSignal<string | number | undefined>;
+  /**
+   * Patterns from Signal Forms `pattern()`; exactly one, with no flags or only `u`/`v`, is rendered
+   * as the native `pattern`.
+   */
+  readonly pattern: import("@angular/core").InputSignal<readonly RegExp[]>;
+  /** Virtual keyboard to show (native `inputmode`). */
+  readonly inputMode: import("@angular/core").InputSignal<BfInputInputMode>;
+  /** Label of the virtual keyboard's Enter key (native `enterkeyhint`). */
+  readonly enterKeyHint: import("@angular/core").InputSignal<BfInputEnterKeyHint>;
+  /** Spell checking on or off (native `spellcheck`); the browser decides while unset. */
+  readonly spellcheck: import("@angular/core").InputSignal<boolean | undefined>;
+  /** Capitalisation of typed text on virtual keyboards (native `autocapitalize`). */
+  readonly autocapitalize: import("@angular/core").InputSignal<BfInputAutocapitalize>;
+  /** Emitted with the new text right after the user changes it (each keystroke or paste). */
+  readonly changed: import("@angular/core").OutputEmitterRef<string>;
+  /** Emitted when the control gains focus. */
+  readonly focused: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted when the control loses focus. */
+  readonly blurred: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly el;
+  private readonly labels;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `fieldSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly iconStartClasses: import("@angular/core").Signal<string>;
+  readonly iconEndClasses: import("@angular/core").Signal<string>;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  /** `aria-errormessage`: the error paragraph while `aria-invalid` is set. */
+  readonly errorMessageId: import("@angular/core").Signal<string | null>;
+  /**
+   * `aria-label` value: only when there is no visible label, so the label stays the sole accessible
+   * name.
+   */
+  readonly ariaLabelAttr: import("@angular/core").Signal<string | null>;
+  /** `aria-labelledby` value, under the same rule as `ariaLabelAttr`. */
+  readonly ariaLabelledbyAttr: import("@angular/core").Signal<string | null>;
+  /**
+   * Native `pattern`: only an unambiguous single pattern whose flags HTML can honour (none, `u` or
+   * `v`; the browser compiles it anchored in `v` mode). Several patterns, or flags such as `i`,
+   * are validated by the form alone, so the native check never rejects a value the form accepts.
+   */
+  readonly patternAttr: import("@angular/core").Signal<string | null>;
+  readonly spellcheckAttr: import("@angular/core").Signal<string | null>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /**
+   * Focuses the native input; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Marks the field touched and emits `blurred`.
+   * @internal
+   */
+  onBlur(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfInputComponent, "bf-input", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconStart": {
+      "alias": "iconStart";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconEnd": {
+      "alias": "iconEnd";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxLength": {
+      "alias": "maxLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "minLength": {
+      "alias": "minLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "step": {
+      "alias": "step";
+      "required": false;
+      "isSignal": true;
+    };
+    "pattern": {
+      "alias": "pattern";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputMode": {
+      "alias": "inputMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "enterKeyHint": {
+      "alias": "enterKeyHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "spellcheck": {
+      "alias": "spellcheck";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocapitalize": {
+      "alias": "autocapitalize";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+    "focused": "focused";
+    "blurred": "blurred";
+    "touch": "touch";
+  }, never, ["[bfSlot=icon-start]", "[bfSlot=icon-end]"], true, never>;
+}
+/**
+ * Multi-line text field with the same chrome and Signal Forms binding as `bf-input`.
+ *
+ * @example
+ * <bf-textarea label="Notes" [rows]="4" [(value)]="notes" />
+ * @summary Multi-line text field with label, help and error text, and Signal Forms binding
+ * @category Forms
+ * @since 0.1.0
+ */
+export declare class BfTextareaComponent implements FormValueControl<string> {
+  /** The text value; two-way bindable and bound by `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<string>;
+  /** Padding and type step: sm, md, lg (a textarea's height comes from `rows`); unset follows
+   * `provideBfDefaults()` (`fieldSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Visible label above the control. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /**
+   * Accessible name when no visible label is rendered (e.g. an inline comment box). Ignored when
+   * `label` is set.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) that name the field when no visible label is rendered. Ignored when
+   * `label` is set.
+   */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Example value shown while empty. */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  /** Helper text under the control. */
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Disables the control. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Makes the control read-only. */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the control required. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Native name attribute. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Control id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Visible rows; with `autoResize`, the rows the empty box starts at. */
+  readonly rows: import("@angular/core").InputSignal<number>;
+  /** Grows with the content (CSS `field-sizing: content`) from `rows` up to `maxRows`. Where the
+   * browser has no `field-sizing` it keeps the fixed `rows`. */
+  readonly autoResize: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** With `autoResize`, the rows the box grows to at most; past them it scrolls. Unset, it grows
+   * without a bound. */
+  readonly maxRows: import("@angular/core").InputSignal<number | undefined>;
+  /** Maximum number of characters (native `maxlength`); bound by Signal Forms `maxLength()`. */
+  readonly maxLength: import("@angular/core").InputSignal<number | undefined>;
+  /** Minimum number of characters (native `minlength`); bound by Signal Forms `minLength()`. */
+  readonly minLength: import("@angular/core").InputSignal<number | undefined>;
+  /** Emitted with the new text right after the user changes it (each keystroke or paste). */
+  readonly changed: import("@angular/core").OutputEmitterRef<string>;
+  /** Emitted when the control gains focus. */
+  readonly focused: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted when the control loses focus. */
+  readonly blurred: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly el;
+  private readonly labels;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `fieldSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  /** Whether the browser sizes a field to its content; read once. False on the server and where
+   * `CSS.supports` is missing, so the box keeps its fixed `rows` there. */
+  private readonly fieldSizing;
+  /** Auto-resize in effect: asked for, and the browser can do it. */
+  private readonly growing;
+  /** The height of `n` lines of this step, padding and border included. */
+  private blockSize;
+  /** While growing: the empty box is as tall as `rows` lines. */
+  protected readonly minBlockSize: import("@angular/core").Signal<string | null>;
+  /** While growing with `maxRows`: it stops at `maxRows` lines. */
+  protected readonly maxBlockSize: import("@angular/core").Signal<string | null>;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  /** `aria-errormessage`: the error paragraph while `aria-invalid` is set. */
+  readonly errorMessageId: import("@angular/core").Signal<string | null>;
+  /**
+   * `aria-label` value: only when there is no visible label, so the label stays the sole accessible
+   * name.
+   */
+  readonly ariaLabelAttr: import("@angular/core").Signal<string | null>;
+  /** `aria-labelledby` value, under the same rule as `ariaLabelAttr`. */
+  readonly ariaLabelledbyAttr: import("@angular/core").Signal<string | null>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /**
+   * Focuses the native textarea; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Marks the field touched and emits `blurred`.
+   * @internal
+   */
+  onBlur(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfTextareaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfTextareaComponent, "bf-textarea", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": false;
+      "isSignal": true;
+    };
+    "autoResize": {
+      "alias": "autoResize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxRows": {
+      "alias": "maxRows";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxLength": {
+      "alias": "maxLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "minLength": {
+      "alias": "minLength";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+    "focused": "focused";
+    "blurred": "blurred";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Equality that matches a bound value to an option's value (`compareWith` of the choice controls).
+ * Called as `compareWith(optionValue, value)`: the option's value first, the bound value second.
+ *
+ * @summary Equality of choice values, for options that are objects rather than primitives
+ * @since 0.3.0
+ */
+type BfCompareWith<T> = (optionValue: T, value: T) => boolean;
+/**
+ * Index of the option whose value matches `value` under `compare`; `-1` for `null` (nothing
+ * selected) or a value no option matches. An option whose value is `null` therefore never shows as
+ * selected.
+ */
+declare function choiceIndex<T>(options: readonly {
+  readonly value: T;
+}[], value: T | null, compare: BfCompareWith<T>): number;
+/**
+ * The native `value` of an option (`<option>`, radio): `String(value)` for a string, number or
+ * boolean, so native reads, form posts and browser tests see the real value; the option index for
+ * anything else (objects). The controls map a choice back by position, never by this key, so
+ * duplicate keys still resolve to the right option.
+ */
+declare function choiceKey(value: unknown, index: number): string;
+/**
+ * One choice of `bf-select`; `value` is any type (a string by default).
+ *
+ * @summary One choice of a select with its value, its label and a disabled flag
+ * @since 0.1.0
+ */
+interface BfSelectOption<T = string> {
+  /** The value the select's `value` takes when this option is chosen. */
+  value: T;
+  /** The text of the native `option`. */
+  label: string;
+  /** Whether this option cannot be chosen. */
+  disabled?: boolean;
+}
+/**
+ * Native single-choice dropdown styled like the text field, with a placeholder option and
+ * Signal Forms binding. Generic over the option value (a string by default); `null` means nothing
+ * is selected.
+ *
+ * @example
+ * <bf-select label="Project" placeholder="Pick a project" [options]="projects" [(value)]="projectId" />
+ * <bf-select label="Team" placeholder="Pick a team" [options]="teams" [formField]="task.teamId" />
+ * @summary Native single-choice dropdown styled like the text field, with Signal Forms binding
+ * @category Forms
+ * @since 0.1.0
+ */
+export declare class BfSelectComponent<T = string> implements FormValueControl<T | null> {
+  /** The selected option's value, `null` while nothing is selected; two-way bindable and bound by
+   * `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | null>;
+  /** The options to choose from. */
+  readonly options: import("@angular/core").InputSignal<readonly BfSelectOption<T>[]>;
+  /** Equality for matching `value` to an option (default `Object.is`); pass one for object values. */
+  readonly compareWith: import("@angular/core").InputSignal<BfCompareWith<T>>;
+  /** Height step: sm 32, md 40, lg 48 px; unset follows `provideBfDefaults()` (`fieldSize`, `md`
+   * by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Visible label above the control. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /**
+   * Accessible name when no visible label is rendered (e.g. a table filter). Ignored when `label`
+   * is set.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) that name the field when no visible label is rendered. Ignored when
+   * `label` is set.
+   */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Disabled first option shown while nothing is selected. */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  /** Helper text under the control. */
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Disables the control. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shows the value but blocks changes; the select stays focusable and exposes `aria-readonly`. */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the control required. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Native name attribute. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Control id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Emitted with the chosen value after a user change (never `null`). */
+  readonly changed: import("@angular/core").OutputEmitterRef<T>;
+  /** Emitted when the control gains focus. */
+  readonly focused: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted when the control loses focus. */
+  readonly blurred: import("@angular/core").OutputEmitterRef<FocusEvent>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly el;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `fieldSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly wrapperClasses: import("@angular/core").Signal<string>;
+  /** Index of the option matching `value`, `-1` while nothing (or `null`) is selected. */
+  readonly selectedIndex: import("@angular/core").Signal<number>;
+  readonly showEmptyOption: import("@angular/core").Signal<boolean>;
+  private readonly labels;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  /** `aria-errormessage`: the error paragraph while `aria-invalid` is set. */
+  readonly errorMessageId: import("@angular/core").Signal<string | null>;
+  /**
+   * `aria-label` value: only when there is no visible label, so the label stays the sole accessible
+   * name.
+   */
+  readonly ariaLabelAttr: import("@angular/core").Signal<string | null>;
+  /** `aria-labelledby` value, under the same rule as `ariaLabelAttr`. */
+  readonly ariaLabelledbyAttr: import("@angular/core").Signal<string | null>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /** Native `value` of an option: its value for a primitive, its index for an object. */
+  protected readonly key: typeof choiceKey;
+  /**
+   * Focuses the native select; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Read-only: no picker on a mouse press. Cancelling the press also cancels its focus, so the
+   * select is focused explicitly, like any other read-only control. Touch screens open the
+   * platform picker without a cancellable press; a choice made there is reverted by `onChange`.
+   * @internal
+   */
+  onMousedown(event: MouseEvent): void;
+  /**
+   * Read-only: no picker or value change from the keyboard (arrows, Enter, Space, F4, type-ahead).
+   * @internal
+   */
+  onKeydown(event: KeyboardEvent): void;
+  /**
+   * Writes the chosen option's value to the model and emits `changed`; while read-only, restores
+   * the shown option instead.
+   * @internal
+   */
+  onChange(el: HTMLSelectElement): void;
+  /**
+   * Marks the field touched and emits `blurred`.
+   * @internal
+   */
+  onBlur(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfSelectComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfSelectComponent<any>, "bf-select", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "compareWith": {
+      "alias": "compareWith";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+    "focused": "focused";
+    "blurred": "blurred";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Checkbox with a 22 px rounded box and an optional label, implementing the Signal Forms
+ * checkbox contract so `[formField]` binds `checked`.
+ *
+ * @example
+ * <bf-checkbox [(checked)]="agree">I agree to the terms</bf-checkbox>
+ * <bf-checkbox label="Notify me" [formField]="prefs.notify" />
+ * @summary Rounded checkbox with an optional label that binds to Signal Forms
+ * @category Forms
+ * @since 0.1.0
+ * @slot default Rich label content next to the box, before the `label` text.
+ */
+export declare class BfCheckboxComponent implements FormCheckboxControl {
+  /** Whether the box is checked; two-way bindable and bound by `[formField]`. */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /** Label text; the default slot works too. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name when there is no visible `label`, e.g. a row-selection box. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Id(s) of the element(s) that name the control when no visible label is rendered (e.g. a
+   * table column header). */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Height step of the row: sm 32, md 40, lg 48 px (44 px under a coarse pointer for sm and md);
+   * unset follows `provideBfDefaults()` (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Shows the mixed state (e.g. "select all" with some rows selected); two-way bindable. A user
+   * change clears it, like the native checkbox, so the box and `aria-checked` agree. */
+  readonly indeterminate: import("@angular/core").ModelSignal<boolean>;
+  /** Disables the control. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shows the state but blocks changes; the box stays focusable and exposes `aria-readonly`. */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the control required. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Native name attribute. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Control id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Emitted with the new checked state after a user change. */
+  readonly changed: import("@angular/core").OutputEmitterRef<boolean>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly el;
+  private readonly labels;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  /** The error paragraph: `errorText`, visually hidden while a press elsewhere (that blurred
+   * this control) holds the layout, so it never moves under the pointer. */
+  protected readonly message: HeldMessage;
+  /** The id of the error paragraph (`aria-describedby`) while there is an error, else null; the
+   * paragraph renders whenever it is named. */
+  protected readonly errorId: import("@angular/core").Signal<string | null>;
+  private readonly mode;
+  readonly labelClasses: import("@angular/core").Signal<string>;
+  readonly textClasses: import("@angular/core").Signal<string>;
+  readonly errorClasses: import("@angular/core").Signal<string>;
+  readonly boxClasses: import("@angular/core").Signal<string>;
+  /**
+   * Focuses the native checkbox; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Read-only: cancels the toggle. Space activates a checkbox through a click, so this covers it.
+   * @internal
+   */
+  onClick(event: MouseEvent): void;
+  /**
+   * Writes the native checkbox state to `checked` and emits `changed`.
+   * @internal
+   */
+  onChange(next: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfCheckboxComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfCheckboxComponent, "bf-checkbox", never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "indeterminate": {
+      "alias": "indeterminate";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "indeterminate": "indeterminateChange";
+    "changed": "changed";
+    "touch": "touch";
+  }, never, ["*"], true, never>;
+}
+/**
+ * The side of a `bf-toggle`'s switch its label sits on: after it (`end`) or before it (`start`).
+ *
+ * @summary Whether a toggle's label sits after or before its switch
+ * @since 0.3.0
+ */
+type BfToggleLabelPosition = 'end' | 'start';
+/**
+ * On/off switch for settings that apply immediately. Implements the Signal Forms checkbox contract.
+ *
+ * @example
+ * <bf-toggle label="Notifications" [(checked)]="notifications" />
+ * @summary On/off switch for settings that apply immediately, with Signal Forms binding
+ * @category Forms
+ * @since 0.1.0
+ * @slot default Rich label content after the `label` text.
+ */
+export declare class BfToggleComponent implements FormCheckboxControl {
+  /** Whether the switch is on; two-way bindable and bound by `[formField]`. */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /** Label text; the default slot works too. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name when no visible label is rendered (e.g. a switch in a list row). */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Id(s) of the element(s) that name the control when no visible label is rendered (e.g. a
+   * table column header). */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Height step of the row: sm 32, md 40, lg 48 px (44 px under a coarse pointer for sm and md);
+   * unset follows `provideBfDefaults()` (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Put the label before the switch (as in settings lists). */
+  readonly labelPosition: import("@angular/core").InputSignal<BfToggleLabelPosition>;
+  /** Disables the control. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shows the state but blocks changes; the switch stays focusable and exposes `aria-readonly`. */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the control required. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Native name attribute. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Control id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Emitted with the new state after a user change. */
+  readonly changed: import("@angular/core").OutputEmitterRef<boolean>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly el;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  private readonly mode;
+  readonly labelClasses: import("@angular/core").Signal<string>;
+  readonly trackClasses: import("@angular/core").Signal<string>;
+  readonly textClasses: import("@angular/core").Signal<string>;
+  readonly knobClasses: import("@angular/core").Signal<string>;
+  private readonly labels;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  /** The error paragraph: `errorText`, visually hidden while a press elsewhere (that blurred
+   * this control) holds the layout, so it never moves under the pointer. */
+  protected readonly message: HeldMessage;
+  /** The id of the error paragraph (`aria-describedby`) while there is an error, else null; the
+   * paragraph renders whenever it is named. */
+  protected readonly errorId: import("@angular/core").Signal<string | null>;
+  /**
+   * Focuses the native switch; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Read-only: cancels the toggle. Space activates a switch through a click, so this covers it.
+   * @internal
+   */
+  onClick(event: MouseEvent): void;
+  /**
+   * Writes the native switch state to `checked` and emits `changed`.
+   * @internal
+   */
+  onChange(next: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfToggleComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfToggleComponent, "bf-toggle", never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "labelPosition": {
+      "alias": "labelPosition";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "changed": "changed";
+    "touch": "touch";
+  }, never, ["*"], true, never>;
+}
+/**
+ * How a `bf-radio-group` lays out its options: stacked (`vertical`) or in a row (`horizontal`).
+ *
+ * @summary Whether a radio group stacks its options or sets them in a row
+ * @since 0.3.0
+ */
+type BfRadioGroupOrientation = 'vertical' | 'horizontal';
+/**
+ * One choice of `bf-radio-group`; `value` is any type (a string by default).
+ *
+ * @summary One choice of a radio group with its value, label and optional description
+ * @since 0.1.0
+ */
+interface BfRadioOption<T = string> {
+  /** The value the group's `value` takes when this option is chosen. */
+  value: T;
+  /** The visible label, also the radio's accessible name. */
+  label: string;
+  /** A second line under the label, linked to the radio with `aria-describedby`. */
+  description?: string;
+  /** Whether this option cannot be chosen. */
+  disabled?: boolean;
+}
+/**
+ * A group of radio buttons for choosing one of a few options, with an optional description per
+ * option. Implements the Signal Forms value contract; generic over the option value (a string by
+ * default), `null` while nothing is selected.
+ *
+ * @example
+ * <bf-radio-group label="View" [options]="views" [(value)]="view" />
+ * @summary Group of radio buttons for choosing one option, with optional per-option descriptions
+ * @category Forms
+ * @since 0.1.0
+ */
+export declare class BfRadioGroupComponent<T = string> implements FormValueControl<T | null> {
+  /** The selected option's value, `null` while nothing is selected; two-way bindable and bound by
+   * `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | null>;
+  /** The options to choose from. */
+  readonly options: import("@angular/core").InputSignal<readonly BfRadioOption<T>[]>;
+  /** Equality for matching `value` to an option (default `Object.is`); pass one for object values. */
+  readonly compareWith: import("@angular/core").InputSignal<BfCompareWith<T>>;
+  /** Group label, rendered as the fieldset legend. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /**
+   * Accessible name of the group when no visible `label` is rendered. Ignored when `label` is set.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) that name the group when no visible `label` is rendered. Ignored when
+   * `label` is set.
+   */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** Height step of the option row: sm 32, md 40, lg 48 px (44 px under a coarse pointer for sm and md);
+   * unset follows `provideBfDefaults()` (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Stack the options vertically (default) or in a row. */
+  readonly orientation: import("@angular/core").InputSignal<BfRadioGroupOrientation>;
+  /** Disables every option. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Shows the choice but blocks changes; the options stay focusable and the group exposes
+   * `aria-readonly`.
+   */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the group required. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Shared name of the radio inputs; generated when not set. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Group id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Emitted with the newly selected value after a user change (never `null`). */
+  readonly changed: import("@angular/core").OutputEmitterRef<T>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  /** The rendered radio inputs, in option order; used by `focus()`. */
+  private readonly radios;
+  private readonly labels;
+  private readonly defaults;
+  /** Index of the option matching `value`, `-1` while nothing (or `null`) is selected. */
+  readonly selectedIndex: import("@angular/core").Signal<number>;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly textClasses: import("@angular/core").Signal<string>;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  /** The error paragraph: `errorText`, visually hidden while a press elsewhere (that blurred
+   * this control) holds the layout, so it never moves under the pointer. */
+  protected readonly message: HeldMessage;
+  /** The id of the error paragraph (`aria-describedby`) while there is an error, else null; the
+   * paragraph renders whenever it is named. */
+  protected readonly errorId: import("@angular/core").Signal<string | null>;
+  /**
+   * `aria-label` value: only when there is no visible label, so the legend stays the sole
+   * accessible name.
+   */
+  readonly ariaLabelAttr: import("@angular/core").Signal<string | null>;
+  /** `aria-labelledby` value, under the same rule as `ariaLabelAttr`. */
+  readonly ariaLabelledbyAttr: import("@angular/core").Signal<string | null>;
+  readonly optionsClasses: import("@angular/core").Signal<"flex flex-row flex-wrap gap-x-6 gap-y-2" | "flex flex-col items-start gap-1">;
+  protected optionLabelClasses(option: BfRadioOption<T>): string;
+  protected ringClasses(option: BfRadioOption<T>, index: number): string;
+  protected dotClasses(index: number): string;
+  /**
+   * Focuses the checked radio, else the first enabled one; Signal Forms calls it from
+   * `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Read-only: cancels the selection. Space activates a radio through a click, so this covers it.
+   * @internal
+   */
+  onClick(event: MouseEvent): void;
+  /**
+   * Read-only: arrow keys would move the native selection, so they do nothing.
+   * @internal
+   */
+  onKeydown(event: KeyboardEvent): void;
+  /** Native `value` of a radio: its option's value for a primitive, its index for an object. */
+  protected readonly key: typeof choiceKey;
+  /**
+   * Writes the value of the option at `index` to the model and emits `changed`.
+   * @internal
+   */
+  onChange(index: number): void;
+  private optionMode;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfRadioGroupComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfRadioGroupComponent<any>, "bf-radio-group", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "compareWith": {
+      "alias": "compareWith";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/** A chip as its group sees it. */
+interface BfChipGroupItem {
+  /** The value the chip stands for, compared with `Object.is`. */
+  readonly value: Signal<unknown>;
+  /** The chip's own `disabled` input. */
+  readonly disabled: Signal<boolean>;
+  /** Focuses the chip's button. */
+  focus(options?: FocusOptions): void;
+}
+/** The enclosing `bf-chip-group`, as its chips inject it. */
+interface BfChipGroupHost {
+  /** True in `single` mode: the chips are radios and the group owns the selection. */
+  readonly radio: Signal<boolean>;
+  /** Disables every chip of the group. */
+  readonly disabled: Signal<boolean>;
+  /** Single mode: whether `item` is the selected chip. */
+  isSelected(item: BfChipGroupItem): boolean;
+  /** Single mode: whether `item` owns the roving tab stop. */
+  isTabStop(item: BfChipGroupItem): boolean;
+  /** Single mode: selects `item`, as a click on it does. */
+  select(item: BfChipGroupItem): void;
+}
+declare const BF_CHIP_GROUP: InjectionToken<BfChipGroupHost>;
+/**
+ * The colour of a `bf-chip`: tonal or ink.
+ *
+ * @summary The two chip colours, a soft tonal tint or a dark ink fill
+ * @since 0.1.0
+ */
+type BfChipVariant = 'tonal' | 'ink';
+/**
+ * Toggleable filter chip. Selected chips carry a check mark and a tint (`tonal`) or the ink
+ * treatment used by mobile filter rows (`ink`). For a single-choice row, put the chips in a
+ * `bf-chip-group`, which makes them a radio group.
+ *
+ * @example
+ * <bf-chip [(selected)]="filters.design">Design</bf-chip>
+ * <bf-chip variant="ink" [selected]="view() === 'open'" (changed)="setView('open')">Open</bf-chip>
+ * @summary Toggleable filter chip with a check mark when selected, in tonal or ink style
+ * @category Forms
+ * @since 0.1.0
+ * @slot icon-start An icon before the label.
+ * @slot default Rich label content, before the `label` text.
+ */
+export declare class BfChipComponent implements BfChipGroupItem {
+  /** Whether the chip is selected; two-way bindable. Inside a `single`-mode `bf-chip-group` the
+   * group's `value` decides and this is ignored. */
+  readonly selected: import("@angular/core").ModelSignal<boolean>;
+  /** The value this chip stands for inside a `bf-chip-group` (compared with `Object.is`); unused
+   * outside one. */
+  readonly value: import("@angular/core").InputSignal<unknown>;
+  /** Selected treatment: tonal tint (default) or ink. */
+  readonly variant: import("@angular/core").InputSignal<BfChipVariant>;
+  /** Disables the chip. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Label text; the default slot works too. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Height step: sm 32, md 40, lg 48 px; unset follows `provideBfDefaults()` (`controlSize`, `md`
+   * by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** When false, clicking an already selected chip does nothing (single-choice rows). */
+  readonly deselectable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted with the new state after a user toggle. */
+  readonly changed: import("@angular/core").OutputEmitterRef<boolean>;
+  /**
+   * Emitted with the new state after a user toggle, together with `changed`.
+   * @deprecated 0.3.0 use changed; removed in 0.4.0
+   */
+  readonly toggled: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly markClasses = "inline-block before:block before:h-[10px] before:w-[5px] before:-translate-y-px before:rotate-45 before:border-r-2 before:border-b-2 before:border-current before:content-['']";
+  private readonly defaults;
+  private readonly group;
+  private readonly button;
+  private readonly host;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  /** Inside a `single`-mode group: a radio whose selection the group owns. */
+  protected readonly radio: import("@angular/core").Signal<boolean>;
+  /** Disabled by its own input or by its group. */
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  /** The selection shown: the group's in a single-mode group, else `selected`. */
+  protected readonly isSelected: import("@angular/core").Signal<boolean>;
+  /** Roving tab stop in a single-mode group; the native order otherwise. */
+  protected readonly tabIndex: import("@angular/core").Signal<0 | -1 | null>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /**
+   * Focuses the chip's button.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Whether `node` is this chip or inside it; the group finds the focused chip with it.
+   * @internal
+   */
+  contains(node: Node | null): boolean;
+  /**
+   * Toggles `selected` and emits `changed`, unless disabled or selected and not `deselectable`;
+   * in a single-mode group, selects this chip through the group instead.
+   * @internal
+   */
+  onClick(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfChipComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfChipComponent, "bf-chip", never, {
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "deselectable": {
+      "alias": "deselectable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selected": "selectedChange";
+    "changed": "changed";
+    "toggled": "toggled";
+  }, never, ["[bfSlot=icon-start]", "*"], true, never>;
+}
+/**
+ * How a `bf-chip-group` treats its chips: one selected at a time (`single`, a radio group) or
+ * independent toggles (`multiple`).
+ *
+ * @summary Whether a chip group picks exactly one chip or lets each chip toggle alone
+ * @since 0.3.0
+ */
+type BfChipGroupMode = 'single' | 'multiple';
+/**
+ * A named row of `bf-chip`s. In `single` mode (the default) the chips are a radio group: the
+ * group owns the selected chip's `value`, one chip is the tab stop and the arrow keys move the
+ * selection. In `multiple` mode the chips stay independent toggles and the group only names them.
+ * Not a Signal Forms control: for a form field use `bf-segmented` or `bf-radio-group`.
+ *
+ * @example
+ * <bf-chip-group label="Status" [(value)]="status">
+ *   <bf-chip value="all">All</bf-chip>
+ *   <bf-chip value="open">Open</bf-chip>
+ *   <bf-chip value="done">Done</bf-chip>
+ * </bf-chip-group>
+ * @summary Named row of chips that picks one like radios, or groups independent toggles
+ * @category Forms
+ * @since 0.3.0
+ * @slot default The `bf-chip`s of the group, each with its `value`.
+ */
+export declare class BfChipGroupComponent<T = string> implements BfChipGroupHost {
+  /** `single` (default): one chip selected, radio semantics; `multiple`: independent toggles. */
+  readonly mode: import("@angular/core").InputSignal<BfChipGroupMode>;
+  /** Accessible name of the group (required unless `ariaLabelledby` is set). */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Id(s) of the element(s) that name the group (e.g. a visible heading) when `label` is not set. */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** single: the selected chip's value (`null` = none); ignored in multiple mode. Two-way. Every
+   * chip of a single-mode group needs a `value` (of type `T`); one without it cannot be selected. */
+  readonly value: import("@angular/core").ModelSignal<T | null>;
+  /** Disables every chip of the group. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted with the new value after a user change (single mode). */
+  readonly changed: import("@angular/core").OutputEmitterRef<T | null>;
+  /** The chips of the group, in document order. */
+  private readonly chips;
+  /**
+   * True in `single` mode.
+   * @internal
+   */
+  readonly radio: import("@angular/core").Signal<boolean>;
+  /** The enabled chips, in order. */
+  private readonly enabled;
+  /** The chip matching `value`, else none. A chip without a `value` never matches, so chips
+   * that all left it `undefined` cannot all read as selected. */
+  private readonly selectedChip;
+  /** The chip that owns the roving tab stop: the selected enabled chip, else the first enabled. */
+  private readonly tabStop;
+  /**
+   * Whether `item` is the selected chip.
+   * @internal
+   */
+  isSelected(item: BfChipGroupItem): boolean;
+  /**
+   * Whether `item` owns the roving tab stop.
+   * @internal
+   */
+  isTabStop(item: BfChipGroupItem): boolean;
+  /**
+   * Selects `item` and emits `changed`, unless it is disabled, already selected or has no
+   * `value` (every chip of a single-mode group needs one).
+   * @internal
+   */
+  select(item: BfChipGroupItem): void;
+  /**
+   * Single mode: the arrow keys, Home and End move focus and the selection, wrapping and skipping
+   * disabled chips.
+   * @internal
+   */
+  onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfChipGroupComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfChipGroupComponent<any>, "bf-chip-group", never, {
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+  }, ["chips"], ["*"], true, never>;
+}
+/**
+ * One segment of `bf-segmented`; `value` is any type (a string by default).
+ *
+ * @summary One segment of a segmented control with its value, its label and a disabled flag
+ * @since 0.1.0
+ */
+interface BfSegmentOption<T = string> {
+  /** The value the control's `value` takes when this segment is selected. */
+  value: T;
+  /** The segment's visible label, also its accessible name. */
+  label: string;
+  /** Whether this segment cannot be selected. */
+  disabled?: boolean;
+}
+/**
+ * The height step of a `bf-segmented`; the same scale as every sized widget.
+ *
+ * @deprecated 0.3.0 use BfSize; removed in 1.0.0
+ * @summary Former name of the shared size scale for segmented controls, kept until 1.0.0
+ * @since 0.1.0
+ */
+type BfSegmentedSize = BfSize;
+/**
+ * Segmented control for switching between two to four views. Behaves like a radio group for
+ * keyboard and assistive tech; implements the Signal Forms value contract. Generic over the option
+ * value (a string by default), `null` while nothing is selected.
+ *
+ * @example
+ * <bf-segmented label="Range" [options]="ranges" [(value)]="range" />
+ * @summary Segmented control for switching between two to four views, keyboard-navigable like radios
+ * @category Forms
+ * @since 0.1.0
+ */
+export declare class BfSegmentedComponent<T = string> implements FormValueControl<T | null> {
+  /** The selected option's value, `null` while nothing is selected; two-way bindable and bound by
+   * `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | null>;
+  /** The segments. */
+  readonly options: import("@angular/core").InputSignal<readonly BfSegmentOption<T>[]>;
+  /** Equality for matching `value` to an option (default `Object.is`); pass one for object values. */
+  readonly compareWith: import("@angular/core").InputSignal<BfCompareWith<T>>;
+  /** Height step of the control (track): sm 32, md 40, lg 48 px; unset follows
+   * `provideBfDefaults()` (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Stretch the control and share the width between segments. */
+  readonly fullWidth: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Disables every segment. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Shows the choice but blocks changes; the tab stop stays focusable and the group exposes
+   * `aria-readonly`.
+   */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the choice required (`aria-required` on the group). */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Field validity from Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the user has left the field; errors show only once touched. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validation errors from Signal Forms; the first message is shown once touched. */
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Explicit error text; takes precedence over Signal Forms errors. */
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the group (not rendered visibly). */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name when `label` is not set. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) that name the group (e.g. a visible heading) when `label` is not set.
+   */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /**
+   * Name of the bound field. Not rendered, because the control has no native form element; kept so
+   * Signal Forms can bind it.
+   */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Group id; generated when not set. */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Emitted with the newly selected value after a user change (never `null`). */
+  readonly changed: import("@angular/core").OutputEmitterRef<T>;
+  /** Emitted on blur so Signal Forms marks the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  /** The rendered radio buttons, in option order; used to move focus after keyboard selection. */
+  readonly radios: import("@angular/core").Signal<readonly ElementRef<HTMLButtonElement>[]>;
+  /** Index of the option matching `value`, `-1` while nothing (or `null`) is selected. */
+  readonly selectedIndex: import("@angular/core").Signal<number>;
+  /** Index of the option that owns the roving tab stop: the selected enabled option, or the first
+   * enabled option when nothing valid is selected; `-1` when every option is disabled. */
+  readonly tabStop: import("@angular/core").Signal<number>;
+  private readonly labels;
+  private readonly defaults;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  readonly errorText: import("@angular/core").Signal<string>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  /** The error paragraph: `errorText`, visually hidden while a press elsewhere (that blurred
+   * this control) holds the layout, so it never moves under the pointer. */
+  protected readonly message: HeldMessage;
+  /** The id of the error paragraph (`aria-describedby`) while there is an error, else null; the
+   * paragraph renders whenever it is named. */
+  protected readonly errorId: import("@angular/core").Signal<string | null>;
+  /** `aria-label`: the `label`, else `ariaLabel`. */
+  readonly ariaLabelAttr: import("@angular/core").Signal<string | null>;
+  /** `aria-labelledby`: only while no `label` names the group. */
+  readonly ariaLabelledbyAttr: import("@angular/core").Signal<string | null>;
+  private readonly mode;
+  /** The classes of the scroller around the track. */
+  protected readonly scrollerClasses: import("@angular/core").Signal<string>;
+  readonly trackClasses: import("@angular/core").Signal<string>;
+  /**
+   * The classes of the segment at `index`.
+   * @internal
+   */
+  itemClasses(index: number): string;
+  /**
+   * Focuses the segment that owns the tab stop; Signal Forms calls it from `focusBoundControl()`.
+   * @param options Passed on to the native `focus()`, such as `{ preventScroll: true }`.
+   */
+  focus(options?: FocusOptions): void;
+  /**
+   * Selects the option whose value matches `next` under `compareWith`, as a click would.
+   * @param next The value of the option to select.
+   */
+  select(next: T): void;
+  /**
+   * Selects the option at `index` unless the control is disabled or read-only, the option is
+   * missing, or it is already selected.
+   * @param index The position of the option in `options`.
+   */
+  selectAt(index: number): void;
+  /**
+   * Arrow keys, Home and End move the selection, as in a radio group.
+   * @internal
+   */
+  onKeydown(event: KeyboardEvent): void;
+  private focusRadio;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfSegmentedComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfSegmentedComponent<any>, "bf-segmented", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "compareWith": {
+      "alias": "compareWith";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "fullWidth": {
+      "alias": "fullWidth";
+      "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;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "changed": "changed";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Container for `bf-list-item` rows. The inset style (default) wraps the rows in the warm
+ * background with rounded corners, as in the design's grouped lists.
+ *
+ * @example
+ * <bf-list>
+ *   <bf-list-item title="Notifications" subtitle="Every Monday at 8:00" />
+ * </bf-list>
+ * @summary Container for list rows, inset by default with rounded corners on a warm background
+ * @category Data display
+ * @since 0.1.0
+ * @slot default The rows, each a `bf-list-item`.
+ */
+export declare class BfListComponent {
+  /** Grouped look with the warm container; false renders rows on the page background. */
+  readonly inset: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly classes: import("@angular/core").Signal<"flex flex-col gap-1 rounded-card bg-bg p-1.5" | "flex flex-col gap-2 bg-transparent p-0">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfListComponent, "bf-list", never, {
+    "inset": {
+      "alias": "inset";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Provided by the surfaces a `bfAction` stretches over (`bf-card`, `bf-list-item`), so the nearest
+ * one, and only it, shows the clickable cues: a card holding navigation rows is not lit by the
+ * rows' links. Kept in its own file so the directive and the surfaces never import each other.
+ */
+interface BfActionHost {
+  /** Called by a `bfAction` inside the surface; returns its unregister function. */
+  registerAction(): () => void;
+  /** Whether the surface's action has keyboard focus (`:focus-visible`), for the focus ring. */
+  setActionFocusVisible(visible: boolean): void;
+}
+declare const BF_ACTION_HOST: InjectionToken<BfActionHost>;
+/**
+ * One row of a list: leading slot (avatar, icon tile), title and subtitle, trailing slot
+ * (time, toggle, badge) and an optional chevron for rows that navigate. A navigation row puts a
+ * `bfAction` link in the `title` slot, so the row stays a list item and the link covers it.
+ *
+ * @example
+ * <bf-list-item subtitle="lena@studio.ch" chevron>
+ *   <bf-avatar bfSlot="leading" initials="LM" />
+ *   <a bfSlot="title" bfAction routerLink="/account">Account</a>
+ * </bf-list-item>
+ * @summary List row with leading slot, title, subtitle, trailing slot and an optional chevron
+ * @category Data display
+ * @since 0.1.0
+ * @slot leading Content before the text, such as an avatar or an icon.
+ * @slot title Rich title content, instead of or next to the `title` text.
+ * @slot default More content under the title and subtitle.
+ * @slot trailing Content at the end, such as a toggle, a badge or a button.
+ */
+export declare class BfListItemComponent implements BfActionHost {
+  /** Primary text. For a navigation row, project an `<a bfSlot="title" bfAction>` instead. */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Secondary text under the title. */
+  readonly subtitle: import("@angular/core").InputSignal<string>;
+  /** Render the row as a button that emits `clicked` (an action row; a row that navigates puts a
+   * `bfAction` link in the `title` slot instead). */
+  readonly interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Show a trailing chevron (navigation rows). */
+  readonly chevron: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Disable an interactive row. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Keep the title, the title slot and the subtitle on one line each, cut with an ellipsis. By
+   * default they wrap, so nothing is lost at large text sizes.
+   */
+  readonly truncate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted when an interactive row is activated. */
+  readonly clicked: import("@angular/core").OutputEmitterRef<Event>;
+  /** `listitem` inside a `bf-list`, else no role. */
+  protected readonly role: string | null;
+  private readonly actions;
+  private readonly actionFocusVisible;
+  private readonly actionState;
+  /** Wrap or truncate classes of the title, the title slot and the subtitle. */
+  protected readonly textClasses: import("@angular/core").Signal<string>;
+  readonly classes: import("@angular/core").Signal<string>;
+  /** @internal Called by a `bfAction` in the row. */
+  registerAction(): () => void;
+  /** @internal Called by the row's `bfAction` on focus and blur. */
+  setActionFocusVisible(visible: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfListItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfListItemComponent, "bf-list-item", never, {
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "subtitle": {
+      "alias": "subtitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "interactive": {
+      "alias": "interactive";
+      "required": false;
+      "isSignal": true;
+    };
+    "chevron": {
+      "alias": "chevron";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "truncate": {
+      "alias": "truncate";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "clicked": "clicked";
+  }, never, ["[bfSlot=leading]", "[bfSlot=title]", "*", "[bfSlot=trailing]"], true, never>;
+}
+/**
+ * The surface of a `bf-card`: raised, tint, ink or flat.
+ *
+ * @summary The four card surfaces, from a raised panel to a flat outline
+ * @since 0.1.0
+ */
+type BfCardVariant = 'raised' | 'tint' | 'ink' | 'flat';
+/**
+ * The inner padding of a `bf-card`: md or lg.
+ *
+ * @summary The two inner paddings of a card, regular and roomy
+ * @since 0.1.0
+ */
+type BfCardPadding = 'md' | 'lg';
+/**
+ * Surface for a piece of content: a project summary, a stat, a focus prompt. Four variants from
+ * the design: raised (default), tint, ink and flat. To make the whole card clickable, put a
+ * `bfAction` link or button in its heading (the stretched-link pattern).
+ *
+ * @example
+ * <bf-card>
+ *   <span bfSlot="header" class="text-caption text-text-muted">Project</span>
+ *   <h3 class="text-heading"><a bfAction routerLink="/projects/atlas">Atlas rebrand</a></h3>
+ *   <bf-progress [value]="68" label="Progress" />
+ * </bf-card>
+ * @summary Content surface with an optional header slot, in four visual styles from raised to flat
+ * @category Data display
+ * @since 0.1.0
+ * @slot header Content above the body, such as a title row.
+ * @slot default The card body.
+ * @slot footer Content below the body, such as its actions.
+ */
+export declare class BfCardComponent implements BfActionHost {
+  /** Surface treatment: raised (default), tint, ink, flat. */
+  readonly variant: import("@angular/core").InputSignal<BfCardVariant>;
+  /** Whole card is a button that emits `clicked`.
+   * @deprecated 0.3.0 use a bfAction link or button in the card's heading; removed in 1.0.0 */
+  readonly interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Inner padding: md 18 px (`--spacing-card`), lg 24 px (`--spacing-card-lg`). */
+  readonly padding: import("@angular/core").InputSignal<BfCardPadding>;
+  /** Emitted when an interactive card is activated.
+   * @deprecated 0.3.0 use a bfAction link or button in the card's heading; removed in 1.0.0 */
+  readonly clicked: import("@angular/core").OutputEmitterRef<Event>;
+  private readonly actions;
+  private readonly actionFocusVisible;
+  readonly classes: import("@angular/core").Signal<string>;
+  private readonly actionState;
+  /** @internal Called by a `bfAction` in the card. */
+  registerAction(): () => void;
+  /** @internal Called by the card's `bfAction` on focus and blur. */
+  setActionFocusVisible(visible: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfCardComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfCardComponent, "bf-card", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "interactive": {
+      "alias": "interactive";
+      "required": false;
+      "isSignal": true;
+    };
+    "padding": {
+      "alias": "padding";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "clicked": "clicked";
+  }, never, ["[bfSlot=header]", "*", "[bfSlot=footer]"], true, never>;
+}
+/**
+ * The track height of a `bf-progress`: sm or md.
+ *
+ * @summary The two track heights of a progress bar, thin and regular
+ * @since 0.1.0
+ */
+type BfProgressSize = 'sm' | 'md';
+/**
+ * The fill colour of a `bf-progress`: primary, success, warning or danger.
+ *
+ * @summary The four fill colours of a progress bar, from primary to danger
+ * @since 0.1.0
+ */
+type BfProgressTone = 'primary' | 'success' | 'warning' | 'danger';
+/**
+ * Progress bar for completion and quotas, determinate by default, or `indeterminate` while the
+ * amount of work is unknown.
+ *
+ * @example
+ * <bf-progress [value]="68" label="Atlas rebrand" valueText="12 of 18 tasks" />
+ * <bf-progress indeterminate label="Uploading" />
+ * @summary Progress bar in two sizes and four tones for completion, quotas and unknown waits
+ * @category Data display
+ * @since 0.1.0
+ */
+export declare class BfProgressComponent {
+  /** Completion in percent; clamped to 0–100. Without it (and without `indeterminate`) the bar
+   * shows 0 %. Ignored while `indeterminate`. */
+  readonly value: import("@angular/core").InputSignal<number | undefined>;
+  /** The amount of work is unknown: the native bar carries no value (assistive tech announces it
+   * as busy) and a stripe runs across the track, a static 40 % bar under reduced motion. */
+  readonly indeterminate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The value in words for assistive tech (`aria-valuetext`), such as "12 of 18 tasks"; the
+   * percentage is announced while it is empty. */
+  readonly valueText: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the bar ("Atlas rebrand"). */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Bar height: sm 8 px (default), md 10 px. */
+  readonly size: import("@angular/core").InputSignal<BfProgressSize>;
+  /** Fill color by meaning. */
+  readonly tone: import("@angular/core").InputSignal<BfProgressTone>;
+  readonly percent: import("@angular/core").Signal<number>;
+  readonly classes: import("@angular/core").Signal<string>;
+  readonly stripeClasses: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfProgressComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfProgressComponent, "bf-progress", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "indeterminate": {
+      "alias": "indeterminate";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueText": {
+      "alias": "valueText";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * The size of a `bf-avatar`: sm, md or lg.
+ *
+ * @summary The three sizes of an avatar, from a list row to a profile header
+ * @since 0.1.0
+ */
+type BfAvatarSize = 'sm' | 'md' | 'lg';
+/**
+ * The colour scheme of a `bf-avatar`: tint, ink, warning or neutral.
+ *
+ * @summary The four colour schemes of an avatar behind its initials or icon
+ * @since 0.1.0
+ */
+type BfAvatarVariant = 'tint' | 'ink' | 'warning' | 'neutral';
+/**
+ * Round avatar showing a photo or initials.
+ *
+ * @example
+ * <bf-avatar initials="LM" />
+ * <bf-avatar src="/lena.jpg" alt="Lena Moser" size="lg" />
+ * @summary Round avatar showing a photo or initials, in three sizes and four color variants
+ * @category Data display
+ * @since 0.1.0
+ */
+export declare class BfAvatarComponent {
+  /** One or two letters shown when there is no image. */
+  readonly initials: import("@angular/core").InputSignal<string>;
+  /** Image URL; when set, the image replaces the initials. */
+  readonly src: import("@angular/core").InputSignal<string>;
+  /** Accessible name; when unset the avatar is decorative and hidden from assistive tech. */
+  readonly alt: import("@angular/core").InputSignal<string>;
+  /** Diameter: sm 30 px, md 40 px (default), lg 84 px; at least 4.5ex of the initials, so a text
+   * zoom (Android font scale) grows the circle with its initials. */
+  readonly size: import("@angular/core").InputSignal<BfAvatarSize>;
+  /** Background treatment for the initials. */
+  readonly variant: import("@angular/core").InputSignal<BfAvatarVariant>;
+  readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfAvatarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfAvatarComponent, "bf-avatar", never, {
+    "initials": {
+      "alias": "initials";
+      "required": false;
+      "isSignal": true;
+    };
+    "src": {
+      "alias": "src";
+      "required": false;
+      "isSignal": true;
+    };
+    "alt": {
+      "alias": "alt";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * The tone of a `bf-alert`: neutral, success, warning or danger.
+ *
+ * @summary The four tones of an alert, from neutral information to a danger message
+ * @since 0.1.0
+ */
+type BfAlertVariant = 'neutral' | 'success' | 'warning' | 'danger';
+/**
+ * Inline message for the outcome of an action or the state of a screen, in a polite `status`
+ * region (`urgent` makes it an assertive `alert`; `announce` makes an inserted alert heard).
+ *
+ * @example
+ * <bf-alert variant="success" title="Saved" announce>Your changes are live.</bf-alert>
+ * <bf-alert variant="danger" title="Sync failed" urgent [dismissible]="true" (dismissed)="clear()">Check your connection.</bf-alert>
+ * @summary Inline status message in four tones with a title and an optional dismiss button
+ * @category Feedback
+ * @since 0.1.0
+ * @slot icon An icon before the text, such as a `bf-icon`.
+ * @slot default The message, under the title.
+ * @slot actions Buttons under the message, such as Retry.
+ */
+export declare class BfAlertComponent {
+  /** Meaning of the message. */
+  readonly variant: import("@angular/core").InputSignal<BfAlertVariant>;
+  /** Bold first line. */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Shows a dismiss button that emits `dismissed`; the host decides whether to hide the alert. */
+  readonly dismissible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `role="alert"` (assertive) instead of `status`; for errors that need attention now. */
+  readonly urgent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Renders the live region empty and fills it on the next frame, so an alert inserted after an
+   * action is announced; read once, when the alert is created. */
+  readonly announce: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Accessible name of the dismiss button (empty falls back to `provideBfLabels()`'s `dismiss`,
+   * "Dismiss"); with a `title` it becomes the label, a colon and the title ("Dismiss: Saved"). */
+  readonly dismissLabel: import("@angular/core").InputSignal<string>;
+  /** Emitted when the dismiss button is pressed. */
+  readonly dismissed: import("@angular/core").OutputEmitterRef<void>;
+  private readonly labels;
+  /** `announce` as it was when the alert was created; later changes are ignored. */
+  private readonly deferred;
+  private readonly frameReady;
+  /** Whether the live region holds its content (at once, or a frame later with `announce`). */
+  protected readonly filled: import("@angular/core").Signal<boolean>;
+  /** The dismiss button's rendered name: `dismissLabel` (else the `dismiss` label), then the title. */
+  readonly dismissName: import("@angular/core").Signal<string>;
+  readonly classes: import("@angular/core").Signal<string>;
+  readonly contentClasses: import("@angular/core").Signal<string>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfAlertComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfAlertComponent, "bf-alert", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissible": {
+      "alias": "dismissible";
+      "required": false;
+      "isSignal": true;
+    };
+    "urgent": {
+      "alias": "urgent";
+      "required": false;
+      "isSignal": true;
+    };
+    "announce": {
+      "alias": "announce";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissLabel": {
+      "alias": "dismissLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "dismissed": "dismissed";
+  }, never, ["[bfSlot=icon]", "*", "[bfSlot=actions]"], true, never>;
+}
+/**
+ * The heading level of a `bf-empty-state` title: `2` for a screen, `3` inside a section.
+ *
+ * @summary The heading level of an empty state title, two for a screen or three
+ * @since 0.3.0
+ */
+type BfEmptyStateHeadingLevel = 2 | 3;
+/**
+ * Placeholder for a screen or list with nothing in it yet: an icon tile, a title, one sentence,
+ * and the action that fills it.
+ *
+ * @example
+ * <bf-empty-state title="No tasks yet" description="Add your first task to get started.">
+ *   <bf-icon bfSlot="icon" [icon]="ListTodo" size="lg" />
+ *   <bf-button bfSlot="actions" (clicked)="create()">New task</bf-button>
+ * </bf-empty-state>
+ * @summary Placeholder for an empty screen or list with icon, title, message and action
+ * @category Feedback
+ * @since 0.1.0
+ * @slot icon The icon in the tile above the title.
+ * @slot actions Buttons under the description, such as Create.
+ */
+export declare class BfEmptyStateComponent {
+  /** What is missing, as a short title. */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** One sentence on how to fill it. */
+  readonly description: import("@angular/core").InputSignal<string>;
+  /** Heading level of the title so the empty state fits the page outline. */
+  readonly headingLevel: import("@angular/core").InputSignal<BfEmptyStateHeadingLevel>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfEmptyStateComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfEmptyStateComponent, "bf-empty-state", never, {
+    "title": {
+      "alias": "title";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "headingLevel": {
+      "alias": "headingLevel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[bfSlot=icon]", "[bfSlot=actions]"], true, never>;
+}
+/**
+ * Floating pill of actions that appears when items are selected. Position it yourself
+ * (bottom-centre, above the safe area on mobile); the bar only styles itself.
+ *
+ * @example
+ * <div class="fixed inset-x-0 bottom-6 flex justify-center">
+ *   <bf-action-bar [label]="selected() + ' selected'">
+ *     <bf-button variant="text" size="sm" (clicked)="clear()">Clear</bf-button>
+ *     <bf-button size="sm" (clicked)="complete()">Mark done</bf-button>
+ *   </bf-action-bar>
+ * </div>
+ * @summary Floating pill of contextual actions that appears while items are selected
+ * @category Actions
+ * @since 0.1.0
+ * @slot default The actions: buttons and icon buttons, laid out in the bar.
+ */
+export declare class BfActionBarComponent {
+  /** Leading text, e.g. "2 selected". */
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly labelId: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfActionBarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfActionBarComponent, "bf-action-bar", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * What `bf-tab` needs from its enclosing `bf-tab-bar`, provided through an injection token so
+ * `tab-bar.component.ts` and `tab.component.ts` never import each other.
+ *
+ * @summary What each tab reads from its tab bar: the selection, tab stop and link mode
+ * @since 0.1.0
+ */
+interface BfTabBarHost {
+  /** The id of the selected tab, the bar's `active` model. */
+  readonly active: Signal<string>;
+  /** The id of the tab shown as selected: `active`, or the controller's `current()` inside a
+   * parent that provides `BF_TAB_BAR_CONTROLLER` (`bf-tabs`). Optional, so a custom `BF_TAB_BAR`
+   * provider without it keeps working: `bf-tab` then reads `active`. */
+  readonly selected?: Signal<string>;
+  /** The id that currently owns the roving tab stop: the active enabled tab, or the first enabled
+   * tab when nothing valid is selected. */
+  readonly tabStop: Signal<string>;
+  /** True when a router-aware parent provides `BF_TAB_LINKS`: the tabs render as links in a
+   * `nav`, not as a `tablist`. */
+  readonly linkMode: boolean;
+  /**
+   * The URL of tab `id` in link mode; `null` without `BF_TAB_LINKS`.
+   * @param id The `id` of the tab.
+   */
+  linkHref(id: string): string | null;
+  /**
+   * Whether the current page is tab `id`'s root page (`aria-current="page"`) rather than a
+   * child page of it (`aria-current="true"`); `true` without `BF_TAB_LINKS`.
+   * @param id The `id` of the tab.
+   */
+  linkIsRoot(id: string): boolean;
+  /**
+   * Selects tab `id`, as a click on it would.
+   * @param id The `id` of the tab.
+   */
+  select(id: string): void;
+}
+/**
+ * The enclosing `bf-tab-bar`, as its tabs inject it.
+ *
+ * @summary Injection token through which each tab reaches its enclosing tab bar
+ * @since 0.1.0
+ */
+export declare const BF_TAB_BAR: InjectionToken<BfTabBarHost>;
+/**
+ * Provided by a router-aware parent (`bf-tabs`) to render the projected bar as a `nav` of links:
+ * `href(id)` is the URL of tab `id`, used for the link's `href` (open in a new tab, copy the
+ * link, see the URL). A plain click still goes through `bf-tab-bar`'s `select()`.
+ *
+ * @summary The URLs a router-aware parent gives a tab bar to render its tabs as links
+ * @since 0.3.0
+ */
+interface BfTabLinks {
+  /**
+   * The URL of tab `id`'s root page, the link's `href`.
+   * @param id The `id` of the tab.
+   */
+  href(id: string): string;
+  /**
+   * Whether the current page is tab `id`'s root page; read in a reactive context, so back it
+   * with signals.
+   * @param id The `id` of the tab.
+   */
+  isRoot(id: string): boolean;
+}
+/**
+ * The link source of a tab bar in link mode, provided by `bf-tabs`.
+ *
+ * @summary Injection token that turns a projected tab bar into a navigation of links
+ * @since 0.3.0
+ */
+export declare const BF_TAB_LINKS: InjectionToken<BfTabLinks>;
+/**
+ * Provided by a parent that projects the bar and drives it (bf-tabs); the bar derives its state from it.
+ *
+ * @summary The state a parent that drives a projected tab bar gives it to derive from
+ * @since 0.3.0
+ */
+interface BfTabBarController extends BfTabLinks {
+  /** The tab the parent shows: the in-flight navigation's target, else the current URL's; null when unknown. */
+  readonly current: Signal<string | null>;
+  /** Hide the bar (e.g. while the soft keyboard is open or about to open). */
+  readonly hidden: Signal<boolean>;
+  /** Animate hiding (iOS) or switch instantly. */
+  readonly hideTransition: Signal<boolean>;
+  /**
+   * Called by the bar on a user selection of another tab.
+   * @param id The `id` of the selected tab.
+   */
+  select(id: string): void;
+  /**
+   * Called by the bar on a user selection of the active tab.
+   * @param id The `id` of the active tab.
+   */
+  reselect(id: string): void;
+}
+/**
+ * The controller of a tab bar projected into a parent that drives it, provided by `bf-tabs`.
+ *
+ * @summary Injection token through which a parent drives the selection and hiding of its tab bar
+ * @since 0.3.0
+ */
+export declare const BF_TAB_BAR_CONTROLLER: InjectionToken<BfTabBarController>;
+/**
+ * One destination inside `bf-tab-bar`: icon in the default slot, `label` under it, optional count
+ * `badge`. A `button role="tab"` in a standalone bar; inside `bf-tabs`, a link to the tab's URL
+ * with `aria-current` while active: `page` on the tab's root page, `true` on a child page of it
+ * (the current section, not the current page).
+ *
+ * @example
+ * <bf-tab id="today" label="Today"><bf-icon [icon]="Sun" /></bf-tab>
+ * @summary One tab bar destination with an icon, a label and an optional count badge
+ * @category Navigation
+ * @since 0.1.0
+ * @slot default The tab icon, a `bf-icon` above the label.
+ */
+export declare class BfTabComponent {
+  /** Stable identifier; matches `bf-tab-bar`'s `active` when this tab is selected. It is a
+   * selection key only, never reflected as the DOM `id` of more than the inner `<button>` (or
+   * `<a>` inside `bf-tabs`). */
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Visible label under the icon. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Optional count shown as a badge on the icon capsule; announced to screen readers as part of
+   * the tab's accessible name (`aria-label` "{label}, {announcement}", with `provideBfLabels()`'s
+   * `tabBadge(n)`, `"{n} new"`, for a number, the string as-is otherwise) since the badge itself
+   * is `aria-hidden`. */
+  readonly badge: import("@angular/core").InputSignal<string | number | null>;
+  /** Disables the tab: skipped by keyboard navigation, cannot be clicked. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The enclosing `bf-tab-bar`, provided through `BF_TAB_BAR` so the two files don't import each other. */
+  readonly bar: import("@bitforgehq/ui").BfTabBarHost;
+  private readonly labels;
+  private readonly control;
+  /** Whether this tab is the bar's current selection. */
+  readonly active: import("@angular/core").Signal<boolean>;
+  /** `aria-current` of the link form: `page` while the active tab's root page is shown, `true`
+   * while a child page of it is (the tab is the current section, not the current page), else
+   * `null`. */
+  readonly current: import("@angular/core").Signal<"page" | "true" | null>;
+  /** The badge as announced after the label in the accessible name when `badge()` is set. */
+  readonly badgeAnnouncement: import("@angular/core").Signal<string | null>;
+  /**
+   * The tab's accessible name while a badge is set, `"{label}, {announcement}"` ("Projects, 3
+   * new"), as `aria-label`: one string, so no browser inserts a pause before the comma (a visually
+   * hidden span is block-level, and Chromium and WebKit join block children with a space). `null`
+   * without a badge, so the name is the visible label.
+   */
+  readonly accessibleName: import("@angular/core").Signal<string | null>;
+  readonly buttonClasses: import("@angular/core").Signal<string>;
+  readonly capsuleClasses: import("@angular/core").Signal<string>;
+  readonly labelClasses: import("@angular/core").Signal<string>;
+  /** Moves keyboard focus to this tab's button (or link); called by `bf-tab-bar` after arrow-key
+   * selection. */
+  focus(): void;
+  /**
+   * A plain primary click on the link selects the tab through the bar (so `bf-tabs` restores the
+   * tab's stack, plays its haptic and pops to the root on reselect) instead of following `href`. A
+   * modified or non-primary click (Ctrl/Cmd, Shift, Alt, middle) is left to the browser, which
+   * opens the tab's URL in a new tab or window.
+   * @internal
+   */
+  onLinkClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfTabComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfTabComponent, "bf-tab", never, {
+    "id": {
+      "alias": "id";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "badge": {
+      "alias": "badge";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Floating pill tab bar for mobile apps (Meadow Sage): at least 64 px tall (it grows with a label
+ * wrapped to two lines at large text sizes; at least 48 px, with icon and label side by side, at
+ * compact heights such as phone landscape), inset 14 px from the sides and
+ * 8 px above the bottom safe area (at least 12 px, so 20 px from the edge without an inset), one
+ * `bf-tab` per destination. On its own it is a pure control with an `active` model and a `hidden`
+ * input: a `tablist` whose selection follows focus with the arrow keys. Inside `bf-tabs`, which
+ * provides `BF_TAB_LINKS` and `BF_TAB_BAR_CONTROLLER`, it is a `nav` of links with `aria-current`
+ * on the active tab (`page` on its root page, `true` on a child page of it) whose selection and
+ * hiding derive from the router and the keyboard; `active` is not written there.
+ *
+ * @example
+ * <bf-tab-bar [(active)]="tab" (changed)="go($event)">
+ *   <bf-tab id="today" label="Today"><bf-icon [icon]="Sun" /></bf-tab>
+ *   <bf-tab id="inbox" label="Inbox" [badge]="3"><bf-icon [icon]="Inbox" /></bf-tab>
+ * </bf-tab-bar>
+ * @summary Floating pill tab bar for mobile apps with arrow-key selection and count badges
+ * @category Navigation
+ * @since 0.1.0
+ * @slot default The tabs, each a `bf-tab`.
+ */
+export declare class BfTabBarComponent implements BfTabBarHost {
+  /** The active tab's id; two-way bindable. */
+  readonly active: import("@angular/core").ModelSignal<string>;
+  /** Accessible name of the navigation; empty falls back to `provideBfLabels()`'s `tabBar`
+   * ("Main"). */
+  readonly label: import("@angular/core").InputSignal<string>;
+  private readonly labels;
+  /** The rendered navigation name: `label`, else the `tabBar` label. */
+  readonly name: import("@angular/core").Signal<string>;
+  /** Floats fixed above the safe area with a shadow; false renders it inline in the layout flow. */
+  readonly floating: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Slides the bar down out of view (e.g. while the soft keyboard is open); `aria-hidden` and inert
+   * while hidden. Shadows the global `hidden` attribute on purpose: a static `<bf-tab-bar hidden>`
+   * sets this input (the slide) and the attribute itself is removed from the host, so it never
+   * becomes `display: none`.
+   */
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Animates hiding and showing (200 ms `translate-y`/`opacity`); false switches instantly. */
+  readonly hideTransition: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted with the newly selected tab's id after a user change. */
+  readonly changed: import("@angular/core").OutputEmitterRef<string>;
+  /** Emitted with the active tab's id when the user selects the tab that is already active. */
+  readonly reselected: import("@angular/core").OutputEmitterRef<string>;
+  /**
+   * Emitted with the newly selected tab's id after a user change, together with `changed`.
+   * @deprecated 0.3.0 use changed; removed in 0.4.0
+   */
+  readonly tabChange: import("@angular/core").OutputEmitterRef<string>;
+  /**
+   * Emitted with the active tab's id on a reselect, together with `reselected`.
+   * @deprecated 0.3.0 use reselected; removed in 0.4.0
+   */
+  readonly tabReselect: import("@angular/core").OutputEmitterRef<string>;
+  private readonly links;
+  /** True inside a router-aware parent (`bf-tabs`): the tabs are links, not a tablist. */
+  readonly linkMode: boolean;
+  private readonly controller;
+  private readonly hiddenState;
+  private readonly hideTransitionState;
+  /** The id of the tab shown as selected: the controller's `current()` inside `bf-tabs` (empty
+   * while it is unknown), else `active`. */
+  readonly selected: import("@angular/core").Signal<string>;
+  /** True while the bar is hidden, through the `hidden` input, `setHidden()` or the controller. */
+  readonly isHidden: import("@angular/core").Signal<boolean>;
+  /** The `bf-tab` children projected into the bar, in document order. */
+  readonly tabs: import("@angular/core").Signal<readonly BfTabComponent[]>;
+  /** The id that currently owns the roving tab stop: the active enabled tab, or the first enabled
+   * tab when nothing valid is selected (empty `active`, before a router binding resolves, or the
+   * active tab is disabled). */
+  readonly tabStop: import("@angular/core").Signal<string>;
+  readonly navClasses: import("@angular/core").Signal<string>;
+  /**
+   * The imperative counterpart of the `hidden` input, for a parent that projects the bar and so
+   * cannot bind it (`bf-tabs` provides `BF_TAB_BAR_CONTROLLER` instead). The bar is hidden while
+   * the input, this or the controller's `hidden()` is true; `transition` overrides
+   * `hideTransition` when given.
+   * @param hidden Whether to hide the bar.
+   * @param transition Whether the change animates (default: `hideTransition`).
+   */
+  setHidden(hidden: boolean, transition?: boolean): void;
+  /**
+   * Selects `id` and emits `changed`, or `reselected` when `id` is already selected; ignores
+   * disabled or unknown tab ids. Inside `bf-tabs` it hands the selection to the controller
+   * (`select`/`reselect`) instead of writing `active`.
+   * @param id The `id` of the tab to select.
+   */
+  select(id: string): void;
+  /**
+   * The URL of tab `id` in link mode (`BF_TAB_LINKS`); `null` for a standalone bar.
+   * @param id The `id` of the tab.
+   */
+  linkHref(id: string): string | null;
+  /**
+   * Whether the current page is tab `id`'s root page (link mode); `true` for a standalone bar.
+   * @param id The `id` of the tab.
+   */
+  linkIsRoot(id: string): boolean;
+  /**
+   * Arrow keys, Home and End move focus and selection along the tabs.
+   * @internal
+   */
+  onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfTabBarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfTabBarComponent, "bf-tab-bar", never, {
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "floating": {
+      "alias": "floating";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "hideTransition": {
+      "alias": "hideTransition";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "active": "activeChange";
+    "changed": "changed";
+    "reselected": "reselected";
+    "tabChange": "tabChange";
+    "tabReselect": "tabReselect";
+  }, ["tabs"], ["*"], true, never>;
+}
+/**
+ * The one interactive element of a `bf-card` or `bf-list-item` (the stretched-link pattern): put
+ * it on the `<a>` (navigation) or `<button>` (an action) that holds the card's heading text or the
+ * row's title. Its `::after` stretches the hit area over the nearest positioned ancestor (the card
+ * box, the row), so the whole surface is clickable while only the heading's link or button is
+ * exposed: the heading stays a heading and the accessible name is the title alone. It registers
+ * with the nearest card or row, which then draws the pointer, the hover and, while the action has
+ * keyboard focus, the focus ring; a card is never lit by the actions of rows nested in it. Give
+ * secondary controls inside the surface `class="relative z-1"` so they stay clickable above the
+ * stretched area.
+ *
+ * @example
+ * <bf-card>
+ *   <h3 class="text-heading"><a bfAction routerLink="/projects/atlas">Atlas rebrand</a></h3>
+ * </bf-card>
+ * @summary Makes one link or button the click target of a whole card or list row
+ * @since 0.3.0
+ */
+export declare class BfActionDirective {
+  private readonly host;
+  private readonly element;
+  constructor();
+  /**
+   * Tells the host card or row whether its action has keyboard focus.
+   * @internal
+   */
+  onFocus(): void;
+  /**
+   * Tells the host card or row that its action lost focus.
+   * @internal
+   */
+  onBlur(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfActionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfActionDirective, "a[bfAction], button[bfAction]", never, {}, {}, never, never, true, never>;
+}
+/** An error as a field reads it: its kind and optional message; limit fields (`minLength`,
+ * `context.requiredLength`, …) are read through type guards by `bfValidationMessage`. */
+type FieldErrorLike = Pick<ValidationError, 'kind' | 'message'>;
+/**
+ * Explicit error message wins; otherwise, once the field was touched, the first form error's text:
+ * its own `message`, else the default for its kind from `messages` (`BF_LABELS.validation`).
+ */
+declare function fieldErrorText(errorMessage: string, touched: boolean, errors: readonly FieldErrorLike[], messages: BfValidationMessages): string;
+/** The visual error state: any error text, or a field the form marked invalid after it was touched. */
+declare function fieldShowsError(errorText: string, invalid: boolean, touched: boolean): boolean;
+/**
+ * `aria-describedby` targets: the help paragraph and the error paragraph under it, each while it
+ * is rendered (`"<id>-help <id>-error"`, `"<id>-help"`, `"<id>-error"`), else none.
+ */
+declare function fieldDescribedBy(id: string, errorText: string, helpText: string): string | null;
+/** `aria-errormessage` target: the error paragraph while the control is invalid, else none. */
+declare function fieldErrorMessageId(id: string, errorText: string, showError: boolean): string | null;
+/**
+ * Returns a document-unique id such as `bf-input-3`, for associating labels and hints with controls.
+ *
+ * The ids come from this module-level counter, so a server render and the client (or two server
+ * renders in one process) number them differently: `@bitforgehq/ui` 0.x is client-rendered only,
+ * and SSR, hydration and prerendering of pages that render its components are not supported.
+ * Hydration-stable ids are decided before 1.0.
+ */
+declare function uniqueId(prefix: string): string;
+/** The positioned, empty ::after that carries the extension; add one inset class beside it. */
+declare const COARSE_HIT_BASE = "pointer-coarse:after:absolute pointer-coarse:after:inset-x-0 pointer-coarse:after:content-['']";
+/**
+ * Vertical hit extension of a 32/40/48 px pill, to 44 px under a coarse pointer. `bordered` boxes
+ * (1.5 px border) position the ::after inside the border, so their inset adds the border back.
+ */
+declare const PILL_HIT: Record<BfSize, Record<'plain' | 'bordered', string>>;
+/**
+ * Removes what overlays and themes leave on a document: the `dark` and `cdk-global-scrollblock`
+ * classes on `<html>`, `inert` on the children of `<body>`, and every child of a
+ * `.cdk-overlay-container`. Internal: shared by `provideBfTesting()` (`@bitforgehq/ui/testing`)
+ * and `provideBfShellTesting()` (`@bitforgehq/ui/mobile`).
+ */
+declare function resetBfDocument(document: Document): void;
+/** Runs `resetBfDocument()` when the environment injector that holds it is destroyed. Internal. */
+declare function provideBfDocumentReset(): EnvironmentProviders;
+export { type BfAlertVariant, type BfAutocapitalize, type BfAvatarSize, type BfAvatarVariant, type BfBadgeVariant, type BfButtonSize, type BfButtonType, type BfButtonVariant, type BfCardPadding, type BfCardVariant, type BfChipGroupMode, type BfChipVariant, type BfCompareWith, type BfDefaults, type BfDefaultsOptions, type BfEmptyStateHeadingLevel, type BfEnterKeyHint, type BfFieldControlState, type BfFieldSize, type BfIconButtonVariant, type BfInputAutocapitalize, type BfInputEnterKeyHint, type BfInputInputMode, type BfInputMode, type BfInputType, type BfLabels, type BfLabelsOverrides, type BfProgressSize, type BfProgressTone, type BfRadioGroupOrientation, type BfRadioOption, type BfSegmentOption, type BfSegmentedSize, type BfSelectOption, type BfSize, type BfSpinnerSize, type BfTabBarController, type BfTabBarHost, type BfTabLinks, type BfToggleLabelPosition, type BfValidationMessages, BUTTON_CLASSES as ɵBF_BUTTON_CLASSES, ICON_BUTTON_CLASSES as ɵBF_ICON_BUTTON_CLASSES, FIELD_BOX as ɵFIELD_BOX, FIELD_ICON_END as ɵFIELD_ICON_END, FIELD_ICON_START as ɵFIELD_ICON_START, FIELD_PADDING_END as ɵFIELD_PADDING_END, FIELD_PADDING_START as ɵFIELD_PADDING_START, PILL_HIT as ɵPILL_HIT, fieldDescribedBy as ɵfieldDescribedBy, fieldErrorMessageId as ɵfieldErrorMessageId, fieldErrorText as ɵfieldErrorText, fieldShowsError as ɵfieldShowsError, provideBfDocumentReset as ɵprovideBfDocumentReset, uniqueId as ɵuniqueId };