@bitforgehq/ui 0.3.0

package/types/bitforgehq-ui-overlay.d.ts

@@ -0,0 +1,1514 @@
+import * as i0 from "@angular/core";
+import { ComponentRef, DestroyRef, EnvironmentProviders, InjectionToken, Injector, Signal, StaticProvider, TemplateRef, Type } from "@angular/core";
+import { LiveAnnouncer } from "@angular/cdk/a11y";
+import { BfSize } from "@bitforgehq/ui";
+import * as i1 from "@angular/cdk/menu";
+/**
+ * The `data` passed to `BfOverlayService.open()`, injectable in the overlay's content.
+ *
+ * @summary Injection token carrying the data an overlay was opened with, for its content
+ * @since 0.2.0
+ */
+export declare const BF_OVERLAY_DATA: InjectionToken<unknown>;
+/**
+ * What the overlay service does for a ref. Exported for entries that extend `BfOverlayRef` with
+ * their own controller (the `/mobile` `BfSheetRef`); apps never implement it.
+ *
+ * @summary What the overlay service does for a ref: close it and re-apply its position
+ * @since 0.2.0
+ */
+interface BfOverlayController {
+  /** Plays the exit animation, detaches the overlay and cleans up. Never rejects. */
+  close(): Promise<void>;
+  /** Re-applies the overlay's position (after its size changed). */
+  updatePosition(): void;
+}
+/**
+ * Handle to an open overlay, returned by `BfOverlayService.open()` and injectable in the
+ * overlay's content. `close(result)` plays the exit animation, detaches the overlay and resolves
+ * `afterClosed` with `result`; later calls are ignored.
+ *
+ * @example
+ * const ref = overlays.open(PickerComponent, { data: { value } });
+ * const picked = await ref.afterClosed;
+ *
+ * @summary Handle on an open overlay that closes it and resolves with its result
+ * @since 0.2.0
+ */
+export declare class BfOverlayRef<T = unknown> {
+  private readonly controller;
+  /** Unique id of the overlay (`bf-overlay-N`). */
+  readonly id: string;
+  /** Resolves with the result given to `close()` once the overlay is detached. */
+  readonly afterClosed: Promise<T | undefined>;
+  private readonly closedState;
+  /** True once the overlay has been detached. */
+  readonly closed: Signal<boolean>;
+  private closing;
+  private resolveClosed;
+  constructor(controller: BfOverlayController);
+  /** True from the first `close()` call on (the exit animation may still be running). */
+  get isClosing(): boolean;
+  /**
+   * Closes the overlay with an optional result; ignored once closing.
+   * @param result The value `afterClosed` resolves with.
+   */
+  close(result?: T): void;
+  /** Re-applies the overlay's position (after its size changed). */
+  updatePosition(): void;
+}
+/**
+ * An overlay ref whose content is a component, exposing its `ComponentRef`.
+ *
+ * @summary Overlay handle whose content is a component, with access to its ComponentRef
+ * @since 0.2.0
+ */
+export declare class BfComponentOverlayRef<C, T = unknown> extends BfOverlayRef<T> {
+  private ref;
+  /** The content component; available as soon as `open()` returns. */
+  get componentRef(): ComponentRef<C>;
+  /** @internal Set by `BfOverlayService` once the component is attached. */
+  setComponentRef(ref: ComponentRef<C>): void;
+}
+/**
+ * What the stack needs of an overlay: a way to close it (a `BfOverlayRef` of any result type).
+ *
+ * @summary What the overlay stack needs of an overlay: a way to close it
+ * @since 0.2.0
+ */
+interface BfStackedOverlay {
+  /** Closes the overlay (the stack calls it for the hardware back button). */
+  close(): void;
+}
+/**
+ * How an overlay takes part in the stack.
+ *
+ * @summary How an overlay takes part in the stack: its back priority and modal depth
+ * @since 0.2.0
+ */
+interface BfOverlayStackOptions {
+  /**
+   * Priority of its hardware back handler (default 100).
+   * @default 100
+   */
+  backPriority?: number;
+  /**
+   * Counts towards `depth()` and `--bf-modal-depth` (page-sheet modals).
+   * @default false
+   */
+  countsAsModal?: boolean;
+}
+/**
+ * The open modal-like overlays, in order. While any is open, every registered page root (the
+ * `/mobile` `bf-stack-outlet` hosts register themselves) is `inert`, and `--bf-modal-depth` on the
+ * roots carries the number of open modals. With no registered root (a desktop page), every direct
+ * child of `document.body` becomes `inert` instead, except those holding a CDK overlay container
+ * (`.cdk-overlay-container`, found without importing the CDK), the CDK live
+ * announcer and `AriaDescriber` containers, `script`/`style`/`template`/`link` and body children
+ * carrying `data-bf-overlay-keep`; an element that was already `inert` keeps it on close. When
+ * the stack's injector is destroyed (the app torn down with an overlay open), it removes every
+ * `inert` and `--bf-modal-depth` it set. Under a `BF_OVERLAY_HOST`
+ * (`provideBfShell()`) each pushed overlay registers a hardware back handler that closes it; on
+ * equal priority the newest overlay closes first. Passive overlays (toasts) are never pushed.
+ *
+ * @summary Keeps the open overlays in order and makes the page behind them inert
+ * @since 0.2.0
+ */
+export declare class BfOverlayStack {
+  private readonly host;
+  private readonly document;
+  private readonly roots;
+  /** Body children the stack made `inert` (outside a shell), and only those. */
+  private readonly inertBodyChildren;
+  private readonly entries;
+  constructor();
+  /** Number of open modal-like overlays. */
+  readonly count: import("@angular/core").Signal<number>;
+  /** Number of open overlays that count as modals (drives `--bf-modal-depth`). */
+  readonly depth: import("@angular/core").Signal<number>;
+  /**
+   * Registers a page root that becomes `inert` while an overlay is open. Returns a function that
+   * unregisters it (and clears what the stack set on it).
+   * @param el The page root, such as a `bf-stack-outlet` host.
+   */
+  registerRoot(el: HTMLElement): () => void;
+  /**
+   * Adds an overlay on top of the stack. Outside a shell, every body child that holds a CDK
+   * overlay container (`.cdk-overlay-container`) stays active, so an overlay created on the CDK
+   * directly, not through `BfOverlayService`, can be pushed as well.
+   * @param ref The overlay's ref.
+   * @param options Its back priority and whether it counts as a modal.
+   */
+  push(ref: BfStackedOverlay, options?: BfOverlayStackOptions): void;
+  /**
+   * Removes an overlay from the stack.
+   * @param ref The overlay's ref.
+   */
+  pop(ref: BfStackedOverlay): void;
+  /**
+   * True when `ref` is the newest overlay in the stack (the one that answers `Escape`).
+   * @param ref The overlay's ref.
+   */
+  isTop(ref: BfStackedOverlay): boolean;
+  /**
+   * Stops the back handler of an overlay that is closing, while it stays in the stack.
+   * @param ref The overlay's ref.
+   */
+  releaseBack(ref: BfStackedOverlay): void;
+  /**
+   * Written synchronously on every change rather than in an effect: an overlay restores focus
+   * into a root right after popping, which fails while the root is still `inert`.
+   */
+  private apply;
+  /** Outside a shell (no registered root), isolates the page: body children become `inert`. */
+  private applyToBody;
+  private applyTo;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfOverlayStack, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Where the overlay's panel sits in the viewport.
+ *
+ * @summary Where an overlay panel sits in the viewport: bottom, centre, top or fullscreen
+ * @since 0.2.0
+ */
+type BfOverlayPosition = 'bottom' | 'center' | 'top' | 'fullscreen';
+/**
+ * The ARIA role of an overlay panel: a `dialog`, an `alertdialog` or a passive `status`.
+ *
+ * @summary The role an overlay panel carries: a dialog, an alert dialog or a status
+ * @since 0.3.0
+ */
+type BfOverlayRole = 'dialog' | 'alertdialog' | 'status';
+/**
+ * Where focus goes when an overlay opens: the first tabbable element of the content
+ * (`first-tabbable`, skipping the container's own controls such as `bf-sheet`'s hidden Close) or
+ * the panel itself (`panel`).
+ *
+ * @summary Where focus lands when an overlay opens, its first control or the panel
+ * @since 0.3.0
+ */
+type BfOverlayAutoFocus = 'first-tabbable' | 'panel';
+/**
+ * Options of `BfOverlayService.open()`.
+ *
+ * @summary Options of an overlay: its data, backdrop, focus, dismissal, position and motion
+ * @since 0.2.0
+ */
+interface BfOverlayOptions {
+  /** Injected into the content as `BF_OVERLAY_DATA`. */
+  data?: unknown;
+  /** Extra classes on the panel (it always carries `bf-overlay-panel`). */
+  panelClass?: string[];
+  /**
+   * Renders a backdrop behind the panel (default true; never for passive overlays).
+   * @default true
+   */
+  backdrop?: boolean;
+  /**
+   * Class of the backdrop (default `bf-overlay-backdrop`: a black scrim, 40 % light / 60 % dark).
+   * @default 'bf-overlay-backdrop'
+   */
+  backdropClass?: string;
+  /**
+   * A backdrop click closes the overlay (default true).
+   * @default true
+   */
+  dismissOnBackdrop?: boolean;
+  /**
+   * `Escape` closes the overlay (default true).
+   * @default true
+   */
+  dismissOnEscape?: boolean;
+  /**
+   * Runs instead of closing when the overlay is on top and `Escape` is pressed (e.g. an alert
+   * resolving with its cancel button). The key is always claimed by the topmost non-passive
+   * overlay, so it never reaches an overlay underneath.
+   */
+  onEscape?: () => void;
+  /**
+   * Role of the panel (default `dialog`; passive overlays get none unless one is given — a toast
+   * is announced through `LiveAnnouncer`).
+   * @default 'dialog'
+   */
+  role?: BfOverlayRole;
+  /** Accessible name of the panel. */
+  ariaLabel?: string;
+  /**
+   * Id of the element naming the panel. Dropped after the content renders when no element inside
+   * the panel carries it and `ariaLabel` is unset, so the panel never points at nothing.
+   */
+  ariaLabelledBy?: string;
+  /** Id of the element describing the panel (an alert's message). */
+  ariaDescribedBy?: string;
+  /**
+   * Traps Tab focus inside the panel (default true).
+   * @default true
+   */
+  trapFocus?: boolean;
+  /**
+   * Where focus goes on open (non-passive overlays): `first-tabbable` (default) — the element
+   * marked `[autofocus]`/`[cdkFocusInitial]` when it is focusable (a control, or any element with
+   * a `tabindex`, also `-1`), else the first tabbable element inside it, else (all its controls
+   * disabled) the first tabbable element of the panel, else the panel; `panel` — the panel
+   * itself, so a long text is read from its start (APG dialog pattern). `first-tabbable` skips the
+   * library's own container controls (`bf-sheet`'s hidden Close and grabber button, marked with
+   * the internal `data-bf-overlay-chrome`): they stay in the Tab order but never take the initial
+   * focus, so it lands on your content.
+   * @default 'first-tabbable'
+   */
+  autoFocus?: BfOverlayAutoFocus;
+  /**
+   * Returns focus to the previously focused element on close (default true); when that element
+   * is gone, to the topmost overlay still open, else focus stays on the body (move it yourself,
+   * e.g. to the next row after a delete).
+   * @default true
+   */
+  restoreFocus?: boolean;
+  /**
+   * Placement of the panel (default `center`).
+   * @default 'center'
+   */
+  position?: BfOverlayPosition;
+  /**
+   * Closes the overlay when the URL path changes (default true; false for passive overlays): a
+   * router navigation, a link, the browser's back and forward buttons. Query- or fragment-only
+   * changes never close; a matrix-parameter change (`/a;x=1`) is a path change and closes. Read
+   * from `Location.onUrlChange()`, so no router is needed, and a `history.pushState()` made
+   * outside Angular's `Location` is not seen. An overlay opened before the first navigation ends
+   * (root component, `APP_INITIALIZER`) closes when the start URL redirects: open it after the
+   * first `NavigationEnd`, or pass false.
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /**
+   * Runs instead of `close()` when a navigation closes the overlay (e.g. an alert answering with
+   * its cancel id); it should close the overlay.
+   */
+  onNavigation?: () => void;
+  /**
+   * Priority of the hardware back handler that closes the overlay (default 100).
+   * @default 100
+   */
+  backPriority?: number;
+  /**
+   * Counts towards `BfOverlayStack.depth()` / `--bf-modal-depth` (default false).
+   * @default false
+   */
+  countsAsModal?: boolean;
+  /**
+   * A passive overlay (a toast) has no backdrop, no focus trap, does not move focus, does not
+   * count in `BfOverlayStack.count()`, registers no back handler and leaves the page interactive.
+   * @default false
+   */
+  passive?: boolean;
+  /**
+   * Enter animation of the panel (default `fadeIn`); return null for none.
+   * @default fadeIn
+   */
+  enter?: (el: HTMLElement) => Animation | null;
+  /**
+   * Exit animation of the panel (default `fadeOut`), awaited before detaching.
+   * @default fadeOut
+   */
+  exit?: (el: HTMLElement) => Animation | null;
+  /**
+   * Parent of the content's injector (default the root injector), so the content resolves the
+   * opener's providers, e.g. a feature-level `provideBfLabels()`.
+   */
+  injector?: Injector;
+  /**
+   * Extra providers of the content's injector, next to `BF_OVERLAY_DATA` and `BfOverlayRef`,
+   * built with the new overlay's ref (e.g. a typed ref of a service built on the core).
+   */
+  providers?: (ref: BfOverlayRef<unknown>) => StaticProvider[];
+}
+/**
+ * Context of a template opened as an overlay: `let-ref` and `let-data="data"`.
+ *
+ * @summary The context a template opened as an overlay receives: its ref and data
+ * @since 0.2.0
+ */
+interface BfOverlayTemplateContext {
+  /** The overlay's ref (`let-ref`), to close it with a result. */
+  $implicit: BfOverlayRef<unknown>;
+  /** The `data` the overlay was opened with (`let-data="data"`). */
+  data: unknown;
+}
+/**
+ * Opens overlays on the Angular CDK `Overlay`: a component or template in a panel with a
+ * backdrop, a focus trap, `role`/`aria-modal`/`aria-labelledby`, `Escape` and backdrop click
+ * closing it, and the page behind it `inert` (see `BfOverlayStack`). A non-passive overlay blocks
+ * document scroll (CDK `block()` scroll strategy); passive overlays, and every overlay under a
+ * `BF_OVERLAY_HOST` whose document never scrolls (the `/mobile` `provideBfShell()`), use `noop()`.
+ * Under `provideBfShell()` the hardware back button (priority 100) closes it too; without a host
+ * no back handler is registered. Where the browser has `CloseWatcher` (Chromium 120+), a close
+ * request (Android back in Chrome or a PWA) runs the `Escape` path on the top non-passive overlay,
+ * unless the host handles the system back itself (`handlesSystemBack`). An overlay that does not
+ * close on it (`dismissOnEscape: false` without `onEscape`, or an `onEscape` that keeps it open)
+ * swallows Android web back for as long as it is open, as a non-dismissible sheet swallows the
+ * hardware back button. A navigation to another URL path closes every non-passive
+ * overlay (`closeOnNavigation`, read from `Location`, so no router is needed). The content
+ * injects `BF_OVERLAY_DATA` and `BfOverlayRef` (plus any `providers`). `BfDialogService` and the
+ * `/mobile` sheet, modal, toast, action sheet and alert services build on it.
+ *
+ * @example
+ * const ref = inject(BfOverlayService).open(ConfirmComponent, {
+ *   data: { name },
+ *   ariaLabelledBy: 'confirm-title',
+ * });
+ * const confirmed = await ref.afterClosed;
+ *
+ * @summary Opens a component or template in an overlay panel on the Angular CDK
+ * @since 0.2.0
+ */
+export declare class BfOverlayService {
+  private readonly overlay;
+  private readonly injector;
+  private readonly document;
+  private readonly stack;
+  private readonly focusTrapFactory;
+  private readonly location;
+  /** Panels of the open non-passive overlays, oldest first (focus fallback on close). */
+  private readonly openPanels;
+  private readonly host;
+  /** Under `provideBfShell()` the document never scrolls (the stack pages do). */
+  private readonly documentScrolls;
+  /**
+   * Opens `component` in an overlay.
+   * @param component The component to render in the panel.
+   * @param options The overlay's data, backdrop, focus, dismissal, position and motion.
+   */
+  open<C, T = unknown>(component: Type<C>, options?: BfOverlayOptions): BfComponentOverlayRef<C, T>;
+  /**
+   * Opens `template` in an overlay; its context is `{ $implicit: ref, data }`.
+   * @param template The template to render in the panel.
+   * @param options The overlay's data, backdrop, focus, dismissal, position and motion.
+   */
+  open<T = unknown>(template: TemplateRef<unknown>, options?: BfOverlayOptions): BfOverlayRef<T>;
+  /** Fades the backdrop out alongside the panel's exit (instantly under reduced motion). */
+  private fadeOutBackdrop;
+  /** Removes an `aria-labelledby` whose id names no element inside the rendered panel. */
+  private dropDanglingLabel;
+  private decoratePanel;
+  private positionStrategy;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfOverlayService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * What a host shell (the `/mobile` `provideBfShell()`) tells the overlay core. The core itself
+ * depends on no platform code: without a host, overlays register no hardware back handler and
+ * lock document scroll behind a modal overlay, and where the browser has `CloseWatcher`, its close
+ * requests (Android back in Chrome) close the top overlay.
+ *
+ * @summary What a host shell tells the overlay core: back handling and document scroll
+ * @since 0.3.0
+ */
+interface BfOverlayHost {
+  /**
+   * Registers a hardware back handler at `priority`; returns its unregister function.
+   * @param priority Higher runs first; the overlay core uses 100.
+   * @param handler Returns (or resolves) true when it handled the back press.
+   */
+  registerBack(priority: number, handler: () => boolean | Promise<boolean>): () => void;
+  /** False when the document never scrolls (the mobile shell): overlays skip the scroll lock. */
+  readonly documentScrolls: boolean;
+  /**
+   * True when the host already delivers the system back action to `registerBack` (the mobile
+   * shell on native Android, through Capacitor's `backButton` event): overlays then create no
+   * `CloseWatcher` of their own, so one back press never closes two things.
+   */
+  readonly handlesSystemBack?: boolean;
+}
+/**
+ * Optional; without it overlays register no back handler and lock document scroll.
+ *
+ * @summary Optional injection token through which a host shell plugs into the overlay core
+ * @since 0.3.0
+ */
+export declare const BF_OVERLAY_HOST: InjectionToken<BfOverlayHost>;
+/**
+ * Motion constants of the overlay core. `@bitforgehq/ui/mobile` reuses them for its own motion
+ * (`DURATION_OVERLAY`, `DURATION_FAST`, `IOS_EASING`).
+ */
+/**
+ * Overlay enter and exit (ms).
+ *
+ * @summary The duration of every overlay enter and exit animation, in milliseconds
+ * @since 0.2.0
+ */
+export declare const OVERLAY_DURATION = 260;
+/**
+ * The overlays' curve: UIKit's navigation and sheet curve.
+ *
+ * @summary The easing curve of the overlay animations, the UIKit sheet curve
+ * @since 0.2.0
+ */
+export declare const OVERLAY_EASING = "cubic-bezier(0.32, 0.72, 0, 1)";
+/**
+ * The opacity fade that replaces every overlay animation under reduced motion (ms).
+ *
+ * @summary The duration of the fade that replaces overlay motion under reduced motion
+ * @since 0.3.0
+ */
+export declare const OVERLAY_REDUCED_DURATION = 150;
+/**
+ * True when the user asked the system to minimise motion.
+ *
+ * @param view The window to ask, usually `document.defaultView`; none reads as false.
+ * @summary Tells whether the user asked the system to minimise motion
+ * @since 0.2.0
+ */
+export declare function prefersReducedMotion(view: Window | null | undefined): boolean;
+/**
+ * `el.animate(frames, options)`, or, where the Web Animations API is missing, the end state at
+ * once: a `forwards` fill writes the last frame onto `el.style` (an exit stays hidden), any other
+ * fill leaves the element as it is (an enter ends in its natural state). The returned animation
+ * is finished either way.
+ */
+declare function animateOrSettle(el: HTMLElement, frames: Keyframe[], options: KeyframeAnimationOptions): Animation;
+/**
+ * Slides `el` up into place from `distance` below it (default: its own height).
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @param distance How far below its place it starts, as a CSS length.
+ * @returns The running animation.
+ * @summary Slides an element up into place, the enter animation of a bottom sheet
+ * @since 0.2.0
+ */
+export declare function slideUp(el: HTMLElement, distance?: string): Animation;
+/**
+ * Slides `el` down out of place by `distance` (default: its own height).
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @param distance How far below its place it ends, as a CSS length.
+ * @returns The running animation.
+ * @summary Slides an element down out of place, the exit animation of a bottom sheet
+ * @since 0.2.0
+ */
+export declare function slideDown(el: HTMLElement, distance?: string): Animation;
+/**
+ * Fades `el` in.
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @returns The running animation.
+ * @summary Fades an element in, the default enter animation of an overlay
+ * @since 0.2.0
+ */
+export declare function fadeIn(el: HTMLElement): Animation;
+/**
+ * Fades `el` out.
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @returns The running animation.
+ * @summary Fades an element out, the default exit animation of an overlay
+ * @since 0.2.0
+ */
+export declare function fadeOut(el: HTMLElement): Animation;
+/**
+ * Scales `el` up from 92 % while fading it in (centred dialogs).
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @returns The running animation.
+ * @summary Scales an element up while fading it in, the enter animation of centred dialogs
+ * @since 0.2.0
+ */
+export declare function scaleIn(el: HTMLElement): Animation;
+/**
+ * Fades `el` in while it rises by `distance` (default 16 px; the Material modal enter).
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @param distance How far below its place it starts, as a CSS length.
+ * @returns The running animation.
+ * @summary Fades an element in while it rises, the Material modal enter animation
+ * @since 0.2.0
+ */
+export declare function fadeUp(el: HTMLElement, distance?: string): Animation;
+/**
+ * Fades `el` out while it sinks by `distance` (default 16 px; the reverse of `fadeUp`).
+ *
+ * @param el The element to animate, usually the overlay panel.
+ * @param distance How far below its place it ends, as a CSS length.
+ * @returns The running animation.
+ * @summary Fades an element out while it sinks, the reverse of the fadeUp animation
+ * @since 0.2.0
+ */
+export declare function fadeDown(el: HTMLElement, distance?: string): Animation;
+/**
+ * Names an overlay panel by the first heading inside it that is not `aria-hidden` or `hidden`:
+ * gives the heading an id when it has none (`bf-overlay-title-<n>`), points the panel's
+ * `aria-labelledby` at it and drops the fallback `aria-label`. Leaves the panel as it is when
+ * there is no heading. Returns whether it found one.
+ */
+declare function labelPanelByHeading(panel: HTMLElement): boolean;
+/**
+ * `labelPanelByHeading` now, and, while the content has no heading yet (content behind an `@if`
+ * or a `resource()`), again whenever the panel's DOM changes, until the first heading appears.
+ * Only that first heading names the panel; later changes are not followed. Returns a function
+ * that stops watching; call it when the overlay closes.
+ */
+declare function watchPanelHeading(panel: HTMLElement): () => void;
+/**
+ * The action rendered as a real button inside a toast.
+ *
+ * @summary The action button of a toast: its label and what it runs when clicked
+ * @since 0.2.0
+ */
+interface BfToastAction {
+  /** Text of the action button. */
+  label: string;
+  /** Runs before the toast closes with reason `'action'`. */
+  handler?: () => void;
+}
+/**
+ * Why a toast ended.
+ *
+ * @summary Why a toast ended: its time ran out, its action fired or it was dismissed
+ * @since 0.2.0
+ */
+type BfToastDismissReason = 'timeout' | 'action' | 'dismiss';
+/**
+ * What the toast queue does for a toast ref; internal.
+ *
+ * @summary What the toast queue does for a toast ref: dismiss the toast now
+ * @since 0.2.0
+ */
+interface BfToastController {
+  /** Ends the toast now: closes it if shown, or drops it from the queue if it never showed. */
+  dismiss(): void;
+}
+/**
+ * Handle to a toast, returned by `BfToastService.show()` (`/mobile`) and
+ * `BfDesktopToastService.show()` (`/overlay`). `dismiss()` ends it immediately — closing it right
+ * away if it is shown, or removing it from the queue before it ever shows. `afterDismissed`
+ * resolves with why it ended: `'timeout'` (its duration elapsed), `'action'` (the action button
+ * was clicked) or `'dismiss'` (`dismiss()` was called). The duration never runs out while the
+ * toast is hovered or focused, and a toast with an action has none by default, so it only ends
+ * with `'action'` or `'dismiss'` (`dismiss()`, `Escape` inside it, or the next `show()` replacing
+ * it).
+ *
+ * @example
+ * const ref = inject(BfToastService).show({ message: 'Saved' });
+ * const reason = await ref.afterDismissed;
+ * @since 0.2.0
+ * @summary Handle on a shown or queued toast that dismisses it and reports why it ended
+ */
+export declare class BfToastRef {
+  private readonly controller;
+  /** Resolves with why the toast ended. */
+  readonly afterDismissed: Promise<BfToastDismissReason>;
+  constructor(controller: BfToastController, afterDismissed: Promise<BfToastDismissReason>);
+  /** Ends the toast now; see the class doc. */
+  dismiss(): void;
+}
+/** One `show()` call; not public API. */
+interface ɵBfToastRequest {
+  message: string;
+  action?: BfToastAction;
+  /** Default 3000 without an action, 0 (persistent) with one. */
+  duration?: number;
+}
+/** What a presenter renders for one toast; not public API. */
+interface ɵBfToastView {
+  readonly message: string;
+  /** The action button, or null; `run()` calls the handler and closes with `'action'`. */
+  readonly action: {
+    label: string;
+    run: () => void;
+  } | null;
+  /** Pauses (`held: true`) or resumes this toast's timer. */
+  hold(source: 'pointer' | 'focus', held: boolean): void;
+  /** `Escape` inside the toast: dismisses it (`'dismiss'`). */
+  escape(): void;
+}
+/** A rendered toast; not public API. */
+interface ɵBfToastHandle {
+  /** The toast's element (focus inside it counts as "in the toast"). */
+  readonly host: HTMLElement | null;
+  /** Plays the exit and removes the toast; resolves once it is gone. */
+  close(reason: BfToastDismissReason): Promise<void>;
+}
+/**
+ * Renders toasts for the queue; `request` is the `show()` argument as given (a presenter reads
+ * its own extra fields from it, e.g. the mobile `position`). Not public API.
+ */
+interface ɵBfToastPresenter<R extends ɵBfToastRequest = ɵBfToastRequest> {
+  present(view: ɵBfToastView, request: R): ɵBfToastHandle;
+}
+/** Options of `ɵBfToastQueue`; not public API. */
+interface ɵBfToastQueueOptions {
+  /** How many toasts are shown at once (1 on mobile). */
+  maxVisible: number;
+  announcer: LiveAnnouncer;
+  document: Document;
+  /** Ends every toast (timers, listeners) when destroyed; later `show()` calls resolve `'dismiss'`. */
+  destroyRef: DestroyRef;
+}
+/**
+ * Queues toasts and shows up to `maxVisible` at once through a presenter. A toast
+ * auto-dismisses after `duration` ms (`'timeout'`); a persistent one (`duration` 0, the default
+ * with an action) never blocks the queue: the next `show()` dismisses it, visible or waiting
+ * (`'dismiss'`). The timer pauses while held (pointer or focus) and resumes with the rest. A
+ * toast holding focus when it closes hands focus back to the element focused last outside it.
+ * Each toast is announced once, politely, as it shows. Not public API.
+ */
+export declare class ɵBfToastQueue<R extends ɵBfToastRequest = ɵBfToastRequest> {
+  private readonly presenter;
+  private readonly options;
+  private readonly waiting;
+  /** Shown toasts, oldest first, until their exit has finished (they hold their slot). */
+  private readonly shown;
+  private destroyed;
+  constructor(presenter: ɵBfToastPresenter<R>, options: ɵBfToastQueueOptions);
+  /**
+   * Queues `request`; shows it now while fewer than `maxVisible` are shown, else once one ends.
+   * Every persistent toast, shown or waiting, is dismissed first.
+   */
+  show(request: R): BfToastRef;
+  private dismissEntry;
+  private pump;
+  private present;
+  /** The focused element, or null when focus is on the body (nothing to return to). */
+  private focusedElement;
+}
+/**
+ * Layout of a modal dialog opened with `BfDialogService`: a title row, a scrolling body and a
+ * footer of actions. The panel is labelled by the title, and the body becomes focusable only
+ * while its content overflows, so keyboard users can scroll it (a region named by the title when
+ * there is one).
+ *
+ * @example
+ * const ref = inject(BfDialogService).open(RenameDialogComponent, { data: { name } });
+ * // RenameDialogComponent template:
+ * // <bf-dialog title="Rename project"> …fields…
+ * //   <div bfSlot="footer">…buttons…</div> </bf-dialog>
+ * @summary Desktop modal dialog with a title, scrolling body, footer actions and focus trap
+ * @category Overlays
+ * @since 0.3.0
+ * @slot header More header content after the title, such as a status badge.
+ * @slot default The dialog body.
+ * @slot footer The actions, aligned at the end.
+ */
+export declare class BfDialogComponent {
+  private readonly labels;
+  private readonly context;
+  private readonly ref;
+  /** Heading of the dialog, rendered as the `h2` the dialog panel is labelled by. */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Shows a close button (×) at the top end that closes the dialog with no result. */
+  readonly closeButton: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Accessible name of the close button; empty uses `provideBfLabels()`'s `close` ("Close"). */
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  /** True while the body's content is taller than the body (it scrolls). */
+  protected readonly overflowing: import("@angular/core").WritableSignal<boolean>;
+  protected readonly titleId: string;
+  protected readonly closeIcon: import("lucide").IconNode;
+  private readonly size;
+  protected readonly hostClasses: import("@angular/core").Signal<string>;
+  protected readonly headerClasses: import("@angular/core").Signal<string>;
+  protected readonly closeName: import("@angular/core").Signal<string>;
+  private readonly body;
+  private readonly content;
+  constructor();
+  /** Closes the dialog with no result (does nothing outside `BfDialogService`). */
+  protected close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfDialogComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfDialogComponent, "bf-dialog", never, {
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeButton": {
+      "alias": "closeButton";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[bfSlot=header]", "*", "[bfSlot=footer]"], true, never>;
+}
+/**
+ * The dialog's own width scale (not `BfSize`, which is a control-height scale): `sm` 24 rem,
+ * `md` 32 rem, `lg` 48 rem, `xl` 64 rem — each never wider than the viewport minus a gutter on
+ * both sides — and `fullscreen`, edge to edge.
+ *
+ * @summary The dialog width scale from a 24 rem confirm to an edge-to-edge fullscreen dialog
+ * @since 0.3.0
+ */
+type BfDialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+/**
+ * The `data` passed to `BfDialogService.open()`, injectable in the dialog's content.
+ *
+ * @summary Injection token carrying the data a dialog was opened with, for its content
+ * @since 0.3.0
+ */
+export declare const BF_DIALOG_DATA: InjectionToken<unknown>;
+/** @internal What `BfDialogService` tells the `bf-dialog` inside its content. */
+interface BfDialogContext {
+  /** Id the `bf-dialog` title renders with; the panel's `aria-labelledby` points to it. */
+  readonly titleId: string;
+  readonly size: BfDialogSize;
+}
+/** @internal Provided by `BfDialogService` to the dialog's content. */
+declare const BF_DIALOG_CONTEXT: InjectionToken<BfDialogContext>;
+/**
+ * Handle to an open dialog, returned by `BfDialogService.open()` and injectable in the dialog's
+ * content (`inject(BfDialogRef)`). `close(result)` plays the exit animation, detaches the dialog
+ * and resolves `afterClosed` with `result`; later calls are ignored. Closing with `Escape`, the
+ * backdrop or the `bf-dialog` close button resolves `undefined`.
+ *
+ * @example
+ * const ref = inject(BfDialogService).open<RenameDialogComponent, { name: string }, string>(
+ *   RenameDialogComponent,
+ *   { data: { name } },
+ * );
+ * const newName = await ref.afterClosed;
+ *
+ * @summary Handle on an open dialog that closes it and resolves with its result
+ * @since 0.3.0
+ */
+export declare class BfDialogRef<R = unknown, C = unknown> {
+  private readonly overlayRef;
+  private readonly instance;
+  /** Unique id of the dialog (its overlay's `bf-overlay-N`). */
+  readonly id: string;
+  /** Resolves with the result given to `close()`, or `undefined`, once the dialog is detached. */
+  readonly afterClosed: Promise<R | undefined>;
+  /** True once the dialog has been detached. */
+  readonly closed: Signal<boolean>;
+  /** @internal Created by `BfDialogService`; apps never construct it. */
+  constructor(overlayRef: BfOverlayRef<unknown>, instance?: () => C | null);
+  /** The content component; `null` for a dialog opened from a template. */
+  get componentInstance(): C | null;
+  /**
+   * Closes the dialog with an optional result; ignored once closing.
+   * @param result The value `afterClosed` resolves with.
+   */
+  close(result?: R): void;
+}
+/**
+ * Context of a template opened with `BfDialogService.open()`: `let-ref` and `let-data="data"`.
+ *
+ * @summary The context a template opened as a dialog receives: its ref and its data
+ * @since 0.3.0
+ */
+interface BfDialogTemplateContext<D = unknown, R = unknown> {
+  /** The dialog's ref (`let-ref`), to close it with a result. */
+  $implicit: BfDialogRef<R>;
+  /** The `data` the dialog was opened with (`let-data="data"`). */
+  data: D;
+}
+/**
+ * Options of `BfDialogService.open()`.
+ *
+ * @summary Options of a dialog: its data, width, role, dismissal, focus and injector
+ * @since 0.3.0
+ */
+interface BfDialogConfig<D = unknown> {
+  /** Injected into the content as `BF_DIALOG_DATA` (and a template's `data`). */
+  data?: D;
+  /**
+   * Width of the `bf-dialog` in the content (default `md`, 32 rem).
+   * @default 'md'
+   */
+  size?: BfDialogSize;
+  /**
+   * `alertdialog` for a dialog that demands an answer (default `dialog`).
+   * @default 'dialog'
+   */
+  role?: BfDialogRole;
+  /** Accessible name, when the content renders no `bf-dialog` title and no heading. */
+  ariaLabel?: string;
+  /** Id of the element describing the dialog (e.g. its message). */
+  ariaDescribedBy?: string;
+  /** A backdrop click closes the dialog (default true for `dialog`, false for `alertdialog`). */
+  dismissOnBackdrop?: boolean;
+  /**
+   * `Escape` closes the dialog (default true); when false the key is claimed and ignored.
+   * @default true
+   */
+  dismissOnEscape?: boolean;
+  /**
+   * Initial focus (default `first-tabbable`: an `[autofocus]`/`[cdkFocusInitial]` element, else
+   * the first tabbable element); `panel` focuses the dialog itself, for long text.
+   * @default 'first-tabbable'
+   */
+  autoFocus?: BfOverlayAutoFocus;
+  /**
+   * Returns focus to the element that had it before opening (default true).
+   * @default true
+   */
+  restoreFocus?: boolean;
+  /**
+   * A navigation to another URL path closes the dialog with no result (default true).
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /** Extra classes on the overlay panel (it always carries `bf-overlay-panel bf-dialog-panel`). */
+  panelClass?: string[];
+  /**
+   * Parent of the content's injector and source of its labels (default the root injector). Pass
+   * the opener's `inject(Injector)` so a feature-level `provideBfLabels()` reaches the dialog.
+   */
+  injector?: Injector;
+}
+/**
+ * A button of `BfDialogService.confirm()`.
+ *
+ * @summary One button of a confirm dialog: its answer, its label and its role
+ * @since 0.3.0
+ */
+interface BfConfirmButton {
+  /** The value `confirm()` resolves with (default the `label`). */
+  id?: string;
+  /** Button text. */
+  label: string;
+  /** `cancel` answers `Escape` and gets initial focus; `destructive` renders `danger`. */
+  role?: BfConfirmButtonRole;
+}
+/**
+ * The ARIA role of a dialog: `dialog`, or `alertdialog` for one that demands an answer.
+ *
+ * @summary The role a dialog carries, plain or an alert dialog that demands an answer
+ * @since 0.3.0
+ */
+type BfDialogRole = 'dialog' | 'alertdialog';
+/**
+ * The role of a confirm dialog button: `cancel` answers `Escape`, `destructive` renders `danger`.
+ *
+ * @summary The role of a confirm dialog button, the cancel answer or a destructive action
+ * @since 0.3.0
+ */
+type BfConfirmButtonRole = 'cancel' | 'destructive';
+/**
+ * The width of a confirm dialog: `sm` (24 rem) or `md`.
+ *
+ * @summary The two widths a confirm dialog comes in, small or medium
+ * @since 0.3.0
+ */
+type BfConfirmSize = 'sm' | 'md';
+/**
+ * Options of `BfDialogService.confirm()`.
+ *
+ * @summary Options of a confirm dialog: its title, message, buttons and width
+ * @since 0.3.0
+ */
+interface BfConfirmOptions {
+  /** Heading, rendered as the `h2` the alert dialog is labelled by. */
+  title: string;
+  /** Text under the title; the dialog's `aria-describedby` points to it. */
+  message?: string;
+  /**
+   * Buttons, in order, right-aligned (default Cancel and OK from `provideBfLabels()`, ids
+   * `cancel` and `ok`).
+   */
+  buttons?: readonly BfConfirmButton[];
+  /**
+   * Width (default `sm`, 24 rem).
+   * @default 'sm'
+   */
+  size?: BfConfirmSize;
+  /**
+   * A navigation to another URL path closes the dialog, resolving the cancel button's answer, or
+   * `undefined` without one (default true).
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /** Source of the default button labels and parent of the content's injector. */
+  injector?: Injector;
+}
+/**
+ * Opens modal dialogs on the overlay core, centred over a backdrop: a component or a template in
+ * a pane labelled by its `bf-dialog` title, with focus moved in and trapped, `Escape` and a
+ * backdrop click closing it (never the backdrop for an `alertdialog`), focus returned to the
+ * opener, document scroll locked and the page behind it `inert`. `confirm()` opens an alert
+ * dialog with a title, a message and a row of buttons and resolves with the pressed button's
+ * `id ?? label`.
+ *
+ * @example
+ * const ref = inject(BfDialogService).open(RenameDialogComponent, { data: { name } });
+ * const answer = await inject(BfDialogService).confirm({
+ *   title: 'Delete project?',
+ *   message: 'This cannot be undone.',
+ *   buttons: [
+ *     { id: 'cancel', label: 'Cancel', role: 'cancel' },
+ *     { id: 'delete', label: 'Delete', role: 'destructive' },
+ *   ],
+ * });
+ * @since 0.3.0
+ * @summary Opens modal dialogs and confirm prompts, centred over the page with focus trapped
+ */
+export declare class BfDialogService {
+  private readonly overlays;
+  private readonly injector;
+  /**
+   * Opens `component` as a dialog; it injects `BfDialogRef` and `BF_DIALOG_DATA`.
+   * @param component The component to render; it injects `BfDialogRef` and `BF_DIALOG_DATA`.
+   * @param config The dialog's data, width, role, dismissal, focus and injector.
+   */
+  open<C, D = unknown, R = unknown>(component: Type<C>, config?: BfDialogConfig<D>): BfDialogRef<R, C>;
+  /**
+   * Opens `template` as a dialog; its context is `{ $implicit: ref, data }`.
+   * @param template The template to render, with the context `{ $implicit: ref, data }`.
+   * @param config The dialog's data, width, role, dismissal, focus and injector.
+   */
+  open<D = unknown, R = unknown>(template: TemplateRef<BfDialogTemplateContext<D, R>>, config?: BfDialogConfig<D>): BfDialogRef<R>;
+  /**
+   * Opens an alert dialog (`role="alertdialog"`, described by `message`, no backdrop dismiss)
+   * and resolves with the pressed button's `id ?? label`. Focus starts on the `cancel`-role
+   * button, else the first button; `Escape` resolves the cancel button's answer, or is ignored
+   * when there is none. A navigation to another path resolves the cancel button's answer, else
+   * `undefined`.
+   * @param options The title, message, buttons and width of the alert dialog.
+   * @returns The pressed button's `id ?? label`, or `undefined`.
+   */
+  confirm(options: BfConfirmOptions): Promise<string | undefined>;
+  private openDialog;
+  /**
+   * A dialog without an `ariaLabel` whose content rendered no `bf-dialog` title (the core then
+   * drops the dangling `aria-labelledby`) is named by the first heading in its content, also one
+   * that renders later, and by the `dialog` label until then.
+   */
+  private nameUnlabelledPanel;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfDialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The card `BfDesktopToastService.show()` renders in its notification stack: the message and an
+ * optional action button on a surface card. It is not a live region (the service announces each
+ * toast once through CDK `LiveAnnouncer`) and has no close button; `Escape` with focus inside it
+ * emits `escaped`, which dismisses the toast. Apps do not place it in templates.
+ *
+ * @example
+ * const ref = inject(BfDesktopToastService).show({ message: 'Changes saved' });
+ * @summary Desktop notification card in a bottom corner stack of up to three
+ * @category Overlays
+ * @since 0.3.0
+ */
+export declare class BfDesktopToastComponent {
+  /** Text of the toast; long words wrap. */
+  readonly message: import("@angular/core").InputSignal<string>;
+  /** Text of the action button; empty renders no button. */
+  readonly actionLabel: import("@angular/core").InputSignal<string>;
+  /** The action button was clicked. */
+  readonly actionClicked: import("@angular/core").OutputEmitterRef<void>;
+  /** `Escape` was pressed with focus inside the toast (the key is claimed). */
+  readonly escaped: import("@angular/core").OutputEmitterRef<void>;
+  /** `Escape` inside the card is the toast's: claimed so no dialog underneath also closes. */
+  protected keydown(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfDesktopToastComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfDesktopToastComponent, "bf-desktop-toast", never, {
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+    "actionLabel": {
+      "alias": "actionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "actionClicked": "actionClicked";
+    "escaped": "escaped";
+  }, never, never, true, never>;
+}
+/**
+ * The viewport corner or edge the desktop toast stack anchors to.
+ *
+ * @summary The viewport corners and edges a desktop toast stack can anchor to
+ * @since 0.3.0
+ */
+type BfDesktopToastPosition = 'bottom-end' | 'bottom-center' | 'top-end' | 'top-center';
+/**
+ * App-wide settings of `BfDesktopToastService`; set them with `provideBfDesktopToast()`.
+ *
+ * @summary App-wide settings of desktop toasts: where they sit and how many show at once
+ * @since 0.3.0
+ */
+interface BfDesktopToastConfig {
+  /**
+   * Where the stack sits (default `'bottom-end'`: bottom right, bottom left in RTL).
+   * @default 'bottom-end'
+   */
+  position: BfDesktopToastPosition;
+  /**
+   * How many toasts are visible at once (default 3); later ones wait.
+   * @default 3
+   */
+  maxVisible: number;
+  /**
+   * Name of the stack's region landmark; empty uses the `notifications` label ("Notifications").
+   * @default ''
+   */
+  ariaLabel: string;
+}
+/**
+ * The library defaults of `BfDesktopToastConfig`.
+ *
+ * @summary The library defaults of the desktop toast settings, bottom end with three visible
+ * @since 0.3.0
+ */
+export declare const BF_DESKTOP_TOAST_DEFAULTS: Readonly<BfDesktopToastConfig>;
+/**
+ * Sets where the desktop toast stack sits, how many toasts it shows at once and its region name,
+ * merged over the defaults. Add it to `ApplicationConfig.providers`.
+ *
+ * @param config The settings to change; any left out keep `BF_DESKTOP_TOAST_DEFAULTS`.
+ * @returns The providers of the desktop toast settings.
+ * @summary Sets where desktop toasts appear and how many show at once, app-wide
+ * @since 0.3.0
+ */
+export declare function provideBfDesktopToast(config?: Partial<BfDesktopToastConfig>): EnvironmentProviders;
+/**
+ * Options of `BfDesktopToastService.show()`.
+ *
+ * @summary Options of one desktop toast: its message, an action and its duration
+ * @since 0.3.0
+ */
+interface BfDesktopToastOptions {
+  /** Text of the toast. */
+  message: string;
+  /** An optional action button (the toast then persists by default). */
+  action?: BfToastAction;
+  /**
+   * Milliseconds before the toast auto-dismisses, not counting time the pointer is over the
+   * stack or focus is inside it; `0` keeps it until dismissed or its action fires (default 3000
+   * without an action, `0` with one).
+   * @default 3000
+   */
+  duration?: number;
+  /**
+   * Source of the region's labels when this toast opens the stack (default the root injector):
+   * pass the feature's `inject(Injector)` so its `provideBfLabels()` names the region.
+   */
+  injector?: Injector;
+}
+/**
+ * Shows desktop notifications: `show(options)` adds a `bf-desktop-toast` card to one passive
+ * overlay stack (bottom right by default, 24 px in, a `region` landmark named "Notifications")
+ * and returns a `BfToastRef`. Up to three are visible at once, the newest nearest the anchored
+ * edge; later calls wait and show as earlier ones end. A toast auto-dismisses after `duration` ms
+ * (default 3000, `'timeout'`); one with an action persists by default until its action
+ * (`'action'`), `Escape` inside it or `dismiss()` (`'dismiss'`), and the next `show()` replaces it
+ * (`'dismiss'`), visible or waiting. The pointer over the stack or focus inside it pauses every
+ * visible toast, which resume with their remaining time. Each toast is announced once, politely,
+ * through CDK `LiveAnnouncer`; focus never moves on show, and returns to the element focused
+ * last outside a toast that closes while holding it. `F6` from the page moves focus to the
+ * action of the newest toast that has one, and `F6` inside the stack moves it back (otherwise
+ * the key is left to the browser); it does nothing while a modal overlay is open
+ * (`BfOverlayStack.count() > 0`), since that overlay's focus trap must not be escaped. No
+ * backdrop, no scroll lock, nothing inert, and a navigation never closes it (a "Saved" survives
+ * the navigation after the save). Needs `@angular/cdk`, no Capacitor.
+ *
+ * @example
+ * const ref = inject(BfDesktopToastService).show({
+ *   message: 'Invoice deleted',
+ *   action: { label: 'Undo', handler: () => restore(invoice) },
+ * });
+ * const reason = await ref.afterDismissed;
+ * @since 0.3.0
+ * @summary Shows brief desktop notifications in a stack at a corner of the viewport
+ */
+export declare class BfDesktopToastService {
+  private readonly overlay;
+  private readonly injector;
+  private readonly document;
+  private readonly config;
+  private readonly directionality;
+  private readonly overlayStack;
+  /** Where the last `F6` into the stack came from; the next `F6` inside it goes back there. */
+  private f6ReturnTo;
+  private readonly onKeydown;
+  /** Shown toasts, oldest first (a leaving one stays until its exit has played). */
+  private items;
+  /** What holds the stack now; applied to every toast, also one that shows while held. */
+  private readonly holds;
+  private pane;
+  /** Re-applies the position strategy on a `dir` change while the pane lives (N2). */
+  private dirSubscription;
+  private nextId;
+  private readonly queue;
+  constructor();
+  /**
+   * Queues `options` as a toast; shows it now while fewer than `maxVisible` are visible, else once
+   * one ends. Every persistent toast (`duration` 0, the default with an action), visible or
+   * waiting, is dismissed first (`'dismiss'`).
+   * @param options The toast's message, action, duration and injector.
+   * @returns The toast's ref, to dismiss it or await why it ended.
+   */
+  show(options: BfDesktopToastOptions): BfToastRef;
+  private present;
+  private remove;
+  private render;
+  private setHold;
+  private ensurePane;
+  private disposePane;
+  /**
+   * `F6` (no Ctrl, Alt or Meta) from the page moves focus to the action of the newest toast that
+   * has one; `F6` inside the stack moves it back to where it came from. Never moves focus out of
+   * an open modal overlay (`BfOverlayStack.count() > 0`): that overlay's focus trap is APG-modal
+   * (focus never leaves it), so a toast surfacing behind it stays reachable only by pointer while
+   * it is open. Otherwise the key is left to the browser.
+   */
+  private keydown;
+  private anchoredTop;
+  private positionStrategy;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfDesktopToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Menu panel of actions, choices and submenus on the Angular CDK menu (role `menu`, arrow keys,
+ * Home/End, type-ahead, `Escape` returning focus to the trigger). Put it in an `ng-template` that
+ * a `bf-menu-button` or a `[bfMenuTriggerFor]` opens, and fill it with `bfMenuItem`,
+ * `bfMenuItemCheckbox`, `bfMenuItemRadio` (in a `bfMenuGroup`) and `bfMenuDivider` parts.
+ *
+ * @example
+ * <bf-menu-button [menu]="rowActions">Actions</bf-menu-button>
+ * <ng-template #rowActions>
+ *   <bf-menu>
+ *     <button bfMenuItem (triggered)="rename()">Rename</button>
+ *     <button bfMenuItem [bfMenuTriggerFor]="moveTo">Move to</button>
+ *     <div bfMenuDivider></div>
+ *     <button bfMenuItem (triggered)="remove()">Delete</button>
+ *   </bf-menu>
+ * </ng-template>
+ * @summary Keyboard-operable menu panel with items, checkbox and radio items, groups and submenus
+ * @category Overlays
+ * @since 0.3.0
+ * @slot default The items (`bfMenuItem`, `bfMenuItemCheckbox`, `bfMenuItemRadio`), groups and dividers.
+ */
+export declare class BfMenuComponent {
+  private readonly defaults;
+  /** The `bfMenuTriggerFor` that opened this menu (a button, or the parent item of a submenu). */
+  private readonly trigger;
+  /** Row height of its items: sm 32, md 36, lg 44 px (44 px under a coarse pointer); unset follows
+   * `provideBfDefaults()` (`controlSize`, `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Accessible name of the menu. Empty: the menu is named by the trigger that opened it (APG). */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Id of the element that names the menu; wins over the trigger. */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
+  /** The item height in effect: `size`, else the app's `controlSize` default. */
+  readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  private readonly triggerId;
+  protected readonly labelledBy: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfMenuComponent, "bf-menu", never, {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "ariaLabelledby";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, [{
+    directive: typeof i1.CdkMenu;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i1.CdkTargetMenuAim;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/**
+ * An action row of a `bf-menu` (role `menuitem`), on a native `<button>` or a link (`<a>` with
+ * `href` or `routerLink`). Activating it (click, `Enter`, `Space`) emits `triggered`, closes every
+ * open menu and returns focus to the trigger. With `[bfMenuTriggerFor]` on the same element it
+ * opens a submenu instead (and shows a chevron). A disabled item stays focusable and announces
+ * itself as disabled, but does not activate; a disabled link does not navigate either, also with
+ * `routerLink`.
+ *
+ * @example
+ * <button bfMenuItem (triggered)="rename()">Rename</button>
+ * <a bfMenuItem routerLink="/settings">Settings</a>
+ * @binding bfMenuItemDisabled Whether the item is disabled: it stays focusable and announced, but does not activate.
+ * @binding bfMenuItemTypeahead The text typeahead matches the item by (default: its text content).
+ * @binding triggered Emits when the item is activated (click, `Enter` or `Space`), unless it opens a submenu.
+ * @summary An action row of a menu on a native button or link, with keyboard rules
+ * @since 0.3.0
+ */
+export declare class BfMenuItemDirective {
+  protected readonly classes: () => string;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuItemDirective, "button[bfMenuItem], a[bfMenuItem]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.CdkMenuItem;
+    inputs: {
+      "cdkMenuItemDisabled": "bfMenuItemDisabled";
+      "cdkMenuitemTypeaheadLabel": "bfMenuItemTypeahead";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+/**
+ * A toggle row of a `bf-menu` (role `menuitemcheckbox`) with a check mark while `checked`.
+ * Activating it (click, `Enter`, `Space`) flips its own `checked` (`aria-checked`), emits
+ * `triggered`, then `changed` (and `checkedChange`) with the new state, and closes the menu. Bind
+ * it two-way, `[(checked)]`, so your state always follows the item.
+ *
+ * @example
+ * <button bfMenuItemCheckbox [(checked)]="showGrid">Show grid</button>
+ * @binding bfMenuItemDisabled Whether the item is disabled: it stays focusable and announced, but does not activate.
+ * @binding bfMenuItemTypeahead The text typeahead matches the item by (default: its text content).
+ * @binding triggered Emits when the item is activated (click, `Enter` or `Space`), before `checked` flips.
+ * @summary A menu row that toggles an option on and off with a check mark
+ * @since 0.3.0
+ */
+export declare class BfMenuItemCheckboxDirective {
+  /** Whether the item is checked. The item flips it itself on activation (and emits
+   * `checkedChange`), so bind it two-way: `[(checked)]`. */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /** Emitted with the new state right after the user toggles the item. */
+  readonly changed: import("@angular/core").OutputEmitterRef<boolean>;
+  protected readonly classes: () => string;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuItemCheckboxDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuItemCheckboxDirective, "button[bfMenuItemCheckbox]", never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "changed": "changed";
+  }, never, never, true, [{
+    directive: typeof i1.CdkMenuItemCheckbox;
+    inputs: {
+      "cdkMenuItemDisabled": "bfMenuItemDisabled";
+      "cdkMenuitemTypeaheadLabel": "bfMenuItemTypeahead";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+/**
+ * One choice of a set (role `menuitemradio`) with a dot while `checked`. Put the choices of one
+ * set in a `bfMenuGroup`: choosing one (click, `Enter`, `Space`) unchecks the others, emits
+ * `triggered` and closes the menu.
+ *
+ * @example
+ * <div bfMenuGroup aria-label="Density">
+ *   <button bfMenuItemRadio [checked]="density() === 'compact'" (triggered)="density.set('compact')">
+ *     Compact
+ *   </button>
+ * </div>
+ * @binding checked Whether this choice is the selected one of its group (shown with a dot).
+ * @binding bfMenuItemDisabled Whether the item is disabled: it stays focusable and announced, but does not activate.
+ * @binding bfMenuItemTypeahead The text typeahead matches the item by (default: its text content).
+ * @binding triggered Emits when the choice is activated (click, `Enter` or `Space`); set your state here.
+ * @summary One choice of a set of exclusive options in a menu, marked with a dot
+ * @since 0.3.0
+ */
+export declare class BfMenuItemRadioDirective {
+  protected readonly classes: () => string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuItemRadioDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuItemRadioDirective, "button[bfMenuItemRadio]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.CdkMenuItemRadio;
+    inputs: {
+      "cdkMenuItemChecked": "checked";
+      "cdkMenuItemDisabled": "bfMenuItemDisabled";
+      "cdkMenuitemTypeaheadLabel": "bfMenuItemTypeahead";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+/**
+ * A group of menu items (role `group`); radio items in one group are exclusive. Name it with
+ * `aria-label` when its items share a topic ("Density").
+ *
+ * @example
+ * <div bfMenuGroup aria-label="Density">…radio items…</div>
+ * @summary Groups related menu items; radio items in one group exclude each other
+ * @since 0.3.0
+ */
+export declare class BfMenuGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuGroupDirective, "[bfMenuGroup]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.CdkMenuGroup;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/**
+ * A line between groups of menu items (role `separator`, not focusable).
+ *
+ * @example
+ * <div bfMenuDivider></div>
+ * @summary A line between groups of menu items that keyboard focus never lands on
+ * @since 0.3.0
+ */
+export declare class BfMenuDividerDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuDividerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuDividerDirective, "[bfMenuDivider]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Where a menu opens against its trigger; `start`/`end` follow the text direction.
+ *
+ * @summary Where a menu opens against its trigger, above or below, at either end
+ * @since 0.3.0
+ */
+type BfMenuPlacement = 'below-start' | 'below-end' | 'above-start' | 'above-end';
+/**
+ * Opens a `bf-menu` template from any element on the Angular CDK menu trigger: it sets
+ * `aria-haspopup="menu"` and `aria-expanded`, opens on click, `Enter`, `Space` and `ArrowDown`
+ * (first item focused) or `ArrowUp` (last item), and takes focus back when the menu closes. A
+ * navigation to another URL path closes the open menu (with its submenus); the URL is watched
+ * only while the menu is open. On a
+ * `bfMenuItem` it opens a submenu beside the item instead (`ArrowRight`, `ArrowLeft` in RTL).
+ * `bf-menu-button` wraps it in a styled button.
+ *
+ * @example
+ * <button type="button" [bfMenuTriggerFor]="menu" bfMenuPlacement="below-end">Options</button>
+ * <ng-template #menu><bf-menu>…</bf-menu></ng-template>
+ * @binding bfMenuTriggerFor The `ng-template` holding the `bf-menu` this element opens.
+ * @binding bfMenuTriggerData The context the menu template receives, for a menu shared by many triggers.
+ * @binding bfMenuOpened Emits when the menu opens.
+ * @binding bfMenuClosed Emits when the menu closes (an item, `Escape`, a click outside or a navigation).
+ * @summary Opens a menu from any element with the keyboard and focus rules of menus
+ * @since 0.3.0
+ */
+export declare class BfMenuTriggerDirective {
+  private readonly el;
+  /** Where the menu opens (flipping when it would overflow). A submenu always opens beside its
+   * item, at the inline end, and ignores it. */
+  readonly bfMenuPlacement: import("@angular/core").InputSignal<BfMenuPlacement>;
+  constructor();
+  /** The trigger element's id (assigned when it has none), which names the menu it opens. It is
+   * read when the menu opens: an `[id]` bound on the trigger that changes while the menu is open
+   * names the menu from its next opening. */
+  labelId(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfMenuTriggerDirective, "[bfMenuTriggerFor]", never, {
+    "bfMenuPlacement": {
+      "alias": "bfMenuPlacement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, [{
+    directive: typeof i1.CdkMenuTrigger;
+    inputs: {
+      "cdkMenuTriggerFor": "bfMenuTriggerFor";
+      "cdkMenuTriggerData": "bfMenuTriggerData";
+    };
+    outputs: {
+      "cdkMenuOpened": "bfMenuOpened";
+      "cdkMenuClosed": "bfMenuClosed";
+    };
+  }]>;
+}
+/**
+ * The visual style of a `bf-menu-button`: outline, text or tonal, as `bf-button`'s.
+ *
+ * @summary The three visual styles of a menu button, matching the button styles
+ * @since 0.3.0
+ */
+type BfMenuButtonVariant = 'outline' | 'text' | 'tonal';
+/**
+ * Button that opens a `bf-menu`: a native `<button>` styled like `bf-button` (or `bf-icon-button`
+ * with `iconOnly`) in the outline, text or tonal variant, with `aria-haspopup="menu"` and
+ * `aria-expanded`. Click, `Enter`, `Space` or `ArrowDown` open the menu with its first item
+ * focused, `ArrowUp` with its last; closing it returns focus here.
+ *
+ * @example
+ * <bf-menu-button [menu]="actions">Actions</bf-menu-button>
+ * <bf-menu-button [menu]="actions" iconOnly label="More actions" variant="text">
+ *   <bf-icon [icon]="Ellipsis" />
+ * </bf-menu-button>
+ * <ng-template #actions>
+ *   <bf-menu><button bfMenuItem (triggered)="rename()">Rename</button></bf-menu>
+ * </ng-template>
+ * @summary Styled button that opens a menu, with outline, text, tonal and icon-only looks
+ * @category Overlays
+ * @since 0.3.0
+ * @slot icon-start An icon before the label.
+ * @slot default The label (the accessible name of an icon-only button).
+ */
+export declare class BfMenuButtonComponent {
+  private readonly defaults;
+  /** The `ng-template` holding the `bf-menu` to open. */
+  readonly menu: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  /** Visual style: outline (default), text, tonal. */
+  readonly variant: import("@angular/core").InputSignal<BfMenuButtonVariant>;
+  /** Height step: sm 32, md 40, lg 48 px; unset follows `provideBfDefaults()` (`controlSize`,
+   * `md` by default). */
+  readonly size: import("@angular/core").InputSignal<BfSize | undefined>;
+  /** Where the menu opens against the button; it flips when it would overflow. */
+  readonly placement: import("@angular/core").InputSignal<BfMenuPlacement>;
+  /** Accessible name (`aria-label`). Required with `iconOnly`; with a visible label leave it empty
+   * or start it with the visible text. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Square button holding only the projected icon, like `bf-icon-button`; set `label`. */
+  readonly iconOnly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Disables the button; the menu cannot open. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The menu opened. */
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  /** The menu closed. */
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  /** The size in effect: `size`, else the app's `controlSize` default. */
+  protected readonly resolvedSize: import("@angular/core").Signal<BfSize>;
+  protected readonly labelClasses: import("@angular/core").Signal<"contents" | "max-w-full min-w-0 truncate">;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfMenuButtonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfMenuButtonComponent, "bf-menu-button", never, {
+    "menu": {
+      "alias": "menu";
+      "required": true;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconOnly": {
+      "alias": "iconOnly";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+    "closed": "closed";
+  }, never, ["[bfSlot=icon-start]", "*"], true, never>;
+}
+export { type BfConfirmButton, type BfConfirmButtonRole, type BfConfirmOptions, type BfConfirmSize, type BfDesktopToastConfig, type BfDesktopToastOptions, type BfDesktopToastPosition, type BfDialogConfig, type BfDialogRole, type BfDialogSize, type BfDialogTemplateContext, type BfMenuButtonVariant, type BfMenuPlacement, type BfOverlayAutoFocus, type BfOverlayController, type BfOverlayHost, type BfOverlayOptions, type BfOverlayPosition, type BfOverlayRole, type BfOverlayStackOptions, type BfOverlayTemplateContext, type BfStackedOverlay, type BfToastAction, type BfToastController, type BfToastDismissReason, type ɵBfToastHandle, type ɵBfToastPresenter, type ɵBfToastQueueOptions, type ɵBfToastRequest, type ɵBfToastView, labelPanelByHeading as ɵlabelPanelByHeading, watchPanelHeading as ɵwatchPanelHeading };