@bitforgehq/ui 0.3.0

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

@@ -0,0 +1,2914 @@
+import * as i0 from "@angular/core";
+import { AfterViewInit, ComponentRef, EnvironmentInjector, EnvironmentProviders, InjectionToken, Injector, OnDestroy, OnInit, Signal, TemplateRef, Type } from "@angular/core";
+import { SystemBarsStyle } from "@capacitor/core";
+import { ActivatedRoute, ActivatedRouteSnapshot, BaseRouteReuseStrategy, Data, NavigationExtras, RouterConfigurationFeature, RouterOutletContract, Routes, UrlTree } from "@angular/router";
+import * as core from "@bitforgehq/ui/overlay";
+import { BfOverlayController, BfOverlayRef as BfOverlayRef$1, BfOverlayTemplateContext as BfOverlayTemplateContext$1, BfToastAction, BfToastAction as BfToastAction$1, BfToastDismissReason, BfToastRef, BfToastRef as BfToastRef$1, prefersReducedMotion } from "@bitforgehq/ui/overlay";
+import { BfButtonVariant, BfTabBarController } from "@bitforgehq/ui";
+import { IconNode } from "lucide";
+/**
+ * The shell's transition and gesture style: `ios`, `md` (Material), or `auto` (iOS on iOS, else
+ * `md`).
+ *
+ * @summary The shell style setting, iOS, Material or automatic from the platform
+ * @since 0.3.0
+ */
+type BfShellConfigMode = 'ios' | 'md' | 'auto';
+/**
+ * The cap of iOS Dynamic Type: the largest root font scale the shell applies.
+ *
+ * @summary The largest root font scale iOS Dynamic Type may apply in the shell
+ * @since 0.3.0
+ */
+interface BfShellDynamicTypeLimit {
+  /** The largest root font scale (2.35, the AX3 size, by default); `Infinity` removes the cap. */
+  maxScale: number;
+}
+/**
+ * The shell's iOS Dynamic Type setting: `false` opts out, a `BfShellDynamicTypeLimit` caps it.
+ *
+ * @summary Whether the shell follows iOS Dynamic Type, and up to which scale
+ * @since 0.3.0
+ */
+type BfShellDynamicType = false | BfShellDynamicTypeLimit;
+/**
+ * What the Android back button does at the root of every stack, when no overlay or page claims
+ * it: `minimize` moves the app to the background (`App.minimizeApp()`), so a relaunch resumes it
+ * warm; `exit` finishes the activity (`App.exitApp()`), so the next launch starts cold.
+ *
+ * @summary What Android back does at a stack root, background the app or exit it
+ * @since 0.3.0
+ */
+type BfBackAtRoot = 'minimize' | 'exit';
+/**
+ * Configuration of the mobile shell, set once through `provideBfShell()`.
+ *
+ * @summary The mobile shell settings: mode, swipe-back, haptics, Dynamic Type and system bars
+ * @since 0.2.0
+ */
+interface BfShellConfig {
+  /**
+   * Transition and gesture style: `ios`, `md` (Material), or `auto` (iOS on iOS, else `md`).
+   * Overscroll is not part of it: `bf-content`'s iOS bounce and Android stretch and
+   * `bf-refresher`'s iOS bounce mode follow the engine (`BfPlatformService.mode()`), because the
+   * bounce is WebKit's own and Chrome never reports a negative `scrollTop`.
+   * @default 'auto'
+   */
+  mode: BfShellConfigMode;
+  /**
+   * Enables the iOS edge swipe-back in every stack outlet (iOS mode only).
+   * @default true
+   */
+  swipeBack: boolean;
+  /**
+   * Holds a transition at frame 0 for two animation frames while the entering page renders.
+   * @default true
+   */
+  deferTransitionStart: boolean;
+  /**
+   * Plays a light haptic tick on tab changes (native only).
+   * @default true
+   */
+  hapticsOnTabChange: boolean;
+  /**
+   * iOS Dynamic Type (native iOS only; see `BfTextScaleService`): the root font size follows the
+   * user's text size. `false` opts out; `maxScale` caps the root scale (default 2.35, the AX3
+   * size, at least 200 %). `Infinity` removes the cap entirely; a non-finite value other than
+   * `Infinity` (e.g. `NaN`) falls back to the default cap. Left out, the default applies. Android
+   * needs no setting: its WebView applies the system font scale.
+   * @default { maxScale: 2.35 }
+   */
+  dynamicType?: BfShellDynamicType;
+  /**
+   * Native iOS and Android only: the status-bar and navigation-bar icons follow the in-app theme
+   * (`BfPlatformService.dark()`) through Capacitor's `SystemBars.setStyle()`, on start and on every
+   * theme change (see `bfSystemBarsStyle()`). `false` leaves the system bars to the app.
+   * @default true
+   */
+  syncSystemBars?: boolean;
+  /**
+   * Native Android only: what the back button does when no overlay and no stack can go back
+   * (every stack is at its first page). `minimize` (default) moves the app to the background, as
+   * Android does for a root activity, so a relaunch resumes it warm on the same tab; `exit`
+   * finishes the activity, as 0.2 did, so the next launch starts cold.
+   * @default 'minimize'
+   */
+  backAtRoot?: BfBackAtRoot;
+  /**
+   * How many pages of one stack stay alive in each `bf-stack-outlet` (default `Infinity`: every
+   * page). Above it, the deepest pages are destroyed and kept as a record (route, URL, history
+   * position and the content's scroll position); a pop back to one creates the page again, fires
+   * its lifecycle and restores its scroll. Deep pages come back fresh: their component state and
+   * the stacks of outlets nested in them are gone. Values below 1 count as 1.
+   * @default Infinity
+   */
+  maxLivePages?: number;
+}
+/** The default Dynamic Type cap: the AX3 size (40 / 17 px), at least 200 %. Internal. */
+declare const DEFAULT_MAX_TEXT_SCALE = 2.35;
+/**
+ * The shell defaults, merged under the overrides given to `provideBfShell()`.
+ *
+ * @summary The mobile shell defaults that provideBfShell merges the app settings over
+ * @since 0.2.0
+ */
+export declare const BF_SHELL_DEFAULTS: Readonly<BfShellConfig>;
+/**
+ * The resolved shell configuration.
+ *
+ * @summary Injection token holding the resolved mobile shell configuration of the app
+ * @since 0.2.0
+ */
+export declare const BF_SHELL_CONFIG: InjectionToken<BfShellConfig>;
+/**
+ * The platform the app runs on: native iOS, native Android, or a browser.
+ *
+ * @summary The platform the app runs on, native iOS, native Android or the web
+ * @since 0.2.0
+ */
+type BfPlatform = 'ios' | 'android' | 'web';
+/**
+ * The shell's look and motion: `ios`, or `md` (Material) everywhere else.
+ *
+ * @summary The shell's look and motion conventions, iOS or Material Design
+ * @since 0.2.0
+ */
+type BfShellMode = 'ios' | 'md';
+/**
+ * The app theme choice: follow the system, or force light or dark.
+ *
+ * @summary The app theme choice, following the system or forcing light or dark
+ * @since 0.2.0
+ */
+type BfTheme = 'system' | 'light' | 'dark';
+/** A theme store in memory, gone with the app: where `localStorage` is unavailable, and in tests. Internal. */
+declare function createMemoryThemeStorage(): Pick<Storage, 'getItem' | 'setItem'>;
+/**
+ * Where `BfPlatformService` keeps the theme choice (the key `bf-theme`): `localStorage` when it is
+ * available, otherwise an in-memory map. Provide another store (a native preferences plugin, or an
+ * in-memory one in tests, as `provideBfShellTesting()` does) to keep the choice elsewhere.
+ *
+ * @example
+ * providers: [{ provide: BF_THEME_STORAGE, useValue: sessionStorage }]
+ * @summary Injection token for the store that keeps the app theme choice between visits
+ * @since 0.3.0
+ */
+export declare const BF_THEME_STORAGE: InjectionToken<Pick<Storage, "getItem" | "setItem">>;
+/**
+ * The SystemBars style for a theme: Dark = light icons. Android WebView < 140 pads the WebView, so
+ * the bar areas show the activity's window background (which follows the system theme): use
+ * Default there.
+ *
+ * The WebView ≥ 140 case assumes the shell's setup: `viewport-fit=cover` and Capacitor's default
+ * `SystemBars.insetsHandling: 'css'`, so the page draws under the bars. With `insetsHandling`
+ * `'disable'` or `'native'` the page never reaches under them and the bars show the window
+ * background as on older WebViews; pass `syncSystemBars: false` and style them yourself there.
+ * `webViewMajor` is read from `Chrome/<n>` in the user agent (Capacitor reads the WebView
+ * package, which normally agrees).
+ *
+ * @example
+ * await SystemBars.setStyle({ style: bfSystemBarsStyle(true, 'ios', null) });
+ * @param dark Whether the app is dark now (`BfPlatformService.dark()`).
+ * @param platform The platform the app runs on.
+ * @param webViewMajor The Android WebView's major version (`Chrome/<n>` in the user agent), or
+ *   `null` when unknown.
+ * @returns The `SystemBarsStyle` to pass to `SystemBars.setStyle()`.
+ * @summary The system-bar icon style that keeps the bars readable in the in-app theme
+ * @since 0.3.0
+ */
+export declare function bfSystemBarsStyle(dark: boolean, platform: BfPlatform, webViewMajor: number | null): SystemBarsStyle;
+/**
+ * Platform facts and the app theme: native or web, iOS or Android, the shell mode that follows
+ * from it, and the user's theme choice (system, light, dark) reflected as the `dark` class on
+ * `<html>`. `matchMedia('(prefers-color-scheme: dark)')` is the single source for the system
+ * theme on every platform.
+ *
+ * The `theme`/`dark` signals always compute, but the `<html>` class and storage writes
+ * only run when `provideBfShell()` provided `BF_SHELL_CONFIG` — i.e. this service is the app's
+ * own shell, not merely injected by something that wants `platform`/`mode`. Without it (e.g. a
+ * docs demo that instantiates `BfPlatformService` directly to preview `bf-tabs`), this service
+ * would otherwise fight the host page's own theme: its `effect` runs on construction and would
+ * immediately overwrite `<html class="dark">` with whatever `prefers-color-scheme` says.
+ *
+ * With `provideBfShell()` on a native platform it also makes the viewport meta forbid zoom
+ * (`maximum-scale=1, user-scalable=no`, other directives kept; the meta is created if missing):
+ * WKWebView zooms a focused control whose font is under 16 px and never zooms back, so the native
+ * shell forbids zoom — pinch, double tap and focus alike — and honours the system text size
+ * instead (iOS Dynamic Type through `BfTextScaleService`, Android's font scale in the WebView).
+ * On the web the meta is never touched, so a web build keeps pinch zoom (the owner's ruling,
+ * audit §12): ship `index.html` without `maximum-scale`/`user-scalable`.
+ *
+ * With `provideBfShell()` on native iOS and Android (unless `syncSystemBars: false`) the status-bar
+ * and navigation-bar icons follow `dark()`: `SystemBars.setStyle()` with `bfSystemBarsStyle()`,
+ * on start and on every theme change (Android WebView < 140 keeps `Default`, see there).
+ * @summary Platform facts and the app theme: native or web, iOS or Android, light or dark
+ * @since 0.2.0
+ */
+export declare class BfPlatformService {
+  private readonly document;
+  private readonly shellConfig;
+  private readonly storage;
+  /** True inside the native iOS or Android app, false in a browser. */
+  readonly isNative: boolean;
+  /** The platform the app runs on. */
+  readonly platform: BfPlatform;
+  /** The platform's shell mode: `ios` on iOS, else `md`; `resolveShellMode()` applies the config. */
+  readonly mode: import("@angular/core").Signal<BfShellMode>;
+  /** The user's theme choice, stored in `BF_THEME_STORAGE` (`localStorage`); set it with `theme.set(…)`. */
+  readonly theme: import("@angular/core").WritableSignal<BfTheme>;
+  private readonly systemDark;
+  /** Whether the app is dark now: the theme choice, or the system's under `system`. */
+  readonly dark: import("@angular/core").Signal<boolean>;
+  constructor();
+  /** The native system bars are outside the page; a failed call leaves them as they were. */
+  private applySystemBars;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfPlatformService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The shell mode in effect: `config.mode`, or the platform's (`BfPlatformService.mode()`: iOS on
+ * iOS, else Material) when it is `'auto'`. The one resolution every mode-dependent part of the
+ * shell (stack outlet, modal, header, back button) shares; apps use it (or `injectShellMode()`)
+ * to follow the same per-mode conventions, e.g. text vs icon header actions.
+ *
+ * @example
+ * const mode = resolveShellMode(inject(BF_SHELL_CONFIG), inject(BfPlatformService));
+ * @param config The shell configuration, usually `inject(BF_SHELL_CONFIG)`.
+ * @param platform The platform service.
+ * @returns The mode in effect.
+ * @summary Resolves the shell mode in effect from the configuration and the platform
+ * @since 0.2.0
+ */
+export declare function resolveShellMode(config: Readonly<BfShellConfig>, platform: BfPlatformService): BfShellMode;
+/**
+ * `resolveShellMode()` from the injector: `BF_SHELL_CONFIG` (the defaults, i.e. `'auto'`, without
+ * `provideBfShell()`) and `BfPlatformService`. Call it in an injection context (a field
+ * initializer or constructor); the mode is fixed for the app's lifetime.
+ *
+ * @example
+ * protected readonly ios = injectShellMode() === 'ios';
+ * @returns The mode in effect.
+ * @summary Reads the shell mode in effect from the injector, iOS or Material
+ * @since 0.2.0
+ */
+export declare function injectShellMode(): BfShellMode;
+/**
+ * The hardware back button queue: on native Android it listens to `@capacitor/app`'s
+ * `backButton` event; on iOS and web nothing is registered (there is no hardware button to
+ * listen to), but `register` and `dispatch` still work so overlays and tests can drive the same
+ * queue. `register` adds a handler at a priority (an open overlay registers at 100,
+ * `BfNavController` at 0 — it pops the deepest active `bf-stack-outlet`); `dispatch` runs the
+ * queue from the highest priority down until one handler returns true; on equal priority the
+ * newest registration runs first, so stacked overlays close top-down. When none does (every
+ * stack is at its first page), the app moves to the background (`App.minimizeApp()`), so a
+ * relaunch resumes it warm; `provideBfShell({ backAtRoot: 'exit' })` finishes it instead
+ * (`App.exitApp()`).
+ *
+ * @example
+ * const unregister = backButton.register(100, () => {
+ *   closeTopOverlay();
+ *   return true;
+ * });
+ * @summary The Android hardware back button queue that overlays and navigation stacks share
+ * @since 0.2.0
+ */
+export declare class BfBackButtonService {
+  private readonly platform;
+  private readonly destroyRef;
+  private readonly backAtRoot;
+  private readonly handlers;
+  private sequence;
+  constructor();
+  /**
+   * Adds a handler at `priority` (higher priority runs first; on a tie, the handler registered
+   * last runs first). Returns a function that removes
+   * it again; call it when the registrant (an overlay, an outlet) is torn down.
+   * @param priority Higher runs first: an open overlay uses 100, `BfNavController` 0.
+   * @param handler Returns (or resolves) true when it handled the press.
+   */
+  register(priority: number, handler: () => boolean | Promise<boolean>): () => void;
+  /**
+   * Runs the registered handlers from highest to lowest priority until one claims the event
+   * (returns true); when none does, minimizes the app (or exits it with `backAtRoot: 'exit'`).
+   * Public so tests and the native listener share one code path, and so overlays outside the
+   * native listener's reach (phase 2c) can still be driven by it, e.g. `Escape`.
+   */
+  dispatch(): Promise<void>;
+  private attachNativeListener;
+  private minimizeApp;
+  private exitApp;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfBackButtonService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Impact weight, mapped to `ImpactStyle.Light` / `Medium` / `Heavy` on native.
+ *
+ * @summary The weight of an impact haptic, light, medium or heavy
+ * @since 0.2.0
+ */
+type BfHapticsImpactStyle = 'light' | 'medium' | 'heavy';
+/**
+ * Outcome of a task, mapped to `NotificationType.Success` / `Warning` / `Error` on native.
+ *
+ * @summary The outcome a notification haptic reports: success, warning or error
+ * @since 0.2.0
+ */
+type BfHapticsNotificationType = 'success' | 'warning' | 'error';
+/**
+ * Haptic feedback: `impact`, `selection` and `notification` forward to `@capacitor/haptics` on
+ * native (loaded lazily on first use, the import cached like `BfKeyboardService`'s plugin); on
+ * the web, and when the plugin fails to load (an app that didn't add the optional dependency),
+ * every method resolves as a silent no-op.
+ *
+ * @example
+ * const haptics = inject(BfHapticsService);
+ * await haptics.impact('light');
+ * @since 0.2.0
+ * @summary Haptic feedback on native devices that silently does nothing on the web
+ */
+export declare class BfHapticsService {
+  private readonly platformService;
+  private modulePromise;
+  /**
+   * Impact feedback: a collision between UI elements of the given weight.
+   * @param style The weight of the impact.
+   */
+  impact(style: BfHapticsImpactStyle): Promise<void>;
+  /** A light tick for a discrete selection change (scrubbing a picker, crossing a threshold). */
+  selection(): Promise<void>;
+  /**
+   * Feedback for the outcome of a task.
+   * @param type The outcome of the task.
+   */
+  notification(type: BfHapticsNotificationType): Promise<void>;
+  private run;
+  /**
+   * Resolves the plugin, or `null` when it is not installed. The `import()` stays lexically inside
+   * the `try` so esbuild tolerates an unresolved optional peer at build time (as in
+   * `BfBackButtonService` and `BfKeyboardService`); a bare `import()` fails the consumer's build.
+   */
+  private loadPlugin;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfHapticsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Scales the root font size with iOS Dynamic Type inside the native shell. WKWebView resolves the
+ * system text style `font: -apple-system-body` to the user's text size (17 px at the default
+ * "Large", 21 px at xxL, 40 px at AX3, 53 px at AX5); a hidden, persistent probe element with that
+ * font gives the size, and `<html>` gets `font-size: probe / 17 × 100 %` (rounded to 0.1 %). Every
+ * type token and spacing step of the library is in `rem`, so text and rem-based layout grow
+ * together, as UIKit's Dynamic Type does.
+ *
+ * A `ResizeObserver` on the probe re-applies the scale when the setting changes while the app
+ * runs (WebKit re-resolves system fonts then); `visibilitychange` re-probes as the fallback. The
+ * scale never goes below 1 (the smaller iOS sizes, and a Mac running the iOS app, keep the design
+ * size) and is capped at `BfShellConfig.dynamicType.maxScale` (default 2.35; `Infinity` means no
+ * cap; `NaN` falls back to the default). A missing or non-finite probe value gives 1; at 1 the
+ * root font size is left unset.
+ *
+ * Acts only with `provideBfShell()` (which starts it at bootstrap), on native iOS, and while
+ * `dynamicType` is not `false`. Android needs nothing: its WebView applies the system font scale
+ * (`textZoom`) itself, so probing there would scale twice. On the web the browser's own text
+ * size and zoom apply. Destroying the service removes the probe, its listeners and the root font
+ * size.
+ *
+ * @example
+ * const textScale = inject(BfTextScaleService);
+ * const compact = computed(() => textScale.scale() > 1.5);
+ * @since 0.2.0
+ * @summary Follows iOS Dynamic Type by scaling the root font size of the app
+ */
+export declare class BfTextScaleService {
+  private readonly document;
+  private readonly platformService;
+  private readonly config;
+  private readonly destroyRef;
+  private readonly scaleState;
+  /** Current root scale (1 = the system default "Large"); always 1 on Android and the web. */
+  readonly scale: import("@angular/core").Signal<number>;
+  constructor();
+  private createProbe;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfTextScaleService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Keyboard lifecycle phase, for animations only; never gate logic on the order of the phases.
+ * `showing` starts at `keyboardWillShow`, `shown` at `keyboardDidShow`. Either hide event
+ * (`keyboardWillHide` or `keyboardDidHide`, whichever arrives first — iOS does not guarantee
+ * the order) moves straight to `hidden`, so there is no `hiding` phase.
+ *
+ * @summary The soft keyboard phase, hidden, showing or shown, for animations only
+ * @since 0.2.0
+ */
+type BfKeyboardPhase = 'hidden' | 'showing' | 'shown';
+/**
+ * True for an element that opens the soft keyboard when focused: a text-like `input` (not a
+ * button, checkbox, color, file, hidden, image, radio, range, reset or submit), a `textarea`, or
+ * a `[contenteditable]` element other than `contenteditable="false"`.
+ *
+ * @param element The element to test, usually `document.activeElement`.
+ * @returns Whether it opens the soft keyboard.
+ * @summary Tells whether focusing an element opens the soft keyboard on a phone
+ * @since 0.2.0
+ */
+export declare function isTextEntry(element: Element | null): element is HTMLElement;
+/**
+ * The soft keyboard as signals. On native it listens to the Capacitor Keyboard plugin
+ * (`@capacitor/keyboard`, loaded lazily, height known at `keyboardWillShow`); on the web it falls
+ * back to `visualViewport` resizes with an 80 px threshold (height known only once the viewport has
+ * shrunk; ignored while the page is pinch-zoomed, `visualViewport.scale` ≠ 1); in Jest and SSR it
+ * stays inert (height 0, never visible). The rest height (viewport with the keyboard hidden) comes
+ * from a fixed `100lvh` probe element, never `innerHeight`, which sticks at a wrong value after a
+ * field-to-field focus jump on iOS; it is measured at construction and on window resizes while the
+ * keyboard is hidden and no text control is focused, never at will-show. `imminent` flags a focused
+ * text control before any keyboard event, and `keyboardTop()` gives the keyboard's top edge in
+ * viewport px. It also writes the height as `--bf-keyboard-height` on `<html>` (`0px` while hidden)
+ * for CSS that follows the keyboard.
+ *
+ * @example
+ * const keyboard = inject(BfKeyboardService);
+ * const hideTabBar = computed(() => keyboard.visible());
+ * @since 0.2.0
+ * @summary The soft keyboard state as signals: visible, its height and its phase
+ */
+export declare class BfKeyboardService {
+  private readonly platformService;
+  private readonly document;
+  private readonly destroyRef;
+  private readonly heightState;
+  private readonly phaseState;
+  private readonly restHeightState;
+  private readonly willShowState;
+  private readonly imminentState;
+  private imminentTarget;
+  private imminentTimer;
+  private plugin;
+  private probe;
+  private destroyed;
+  /** Keyboard height in CSS px (iOS: includes the home-indicator strip); 0 when hidden. */
+  readonly height: import("@angular/core").Signal<number>;
+  /** Lifecycle phase for animations; see `BfKeyboardPhase`. */
+  readonly phase: import("@angular/core").Signal<BfKeyboardPhase>;
+  /** True from will-show until either hide event: the moment to hide chrome such as the tab bar. */
+  readonly visible: import("@angular/core").Signal<boolean>;
+  /** True when the keyboard overlays the WebView (native iOS, `resize: 'none'`); false when the WebView resizes. */
+  readonly overlaysContent: import("@angular/core").Signal<boolean>;
+  /** Viewport height with the keyboard hidden, in CSS px, from a fixed `100lvh` probe. */
+  readonly restHeight: import("@angular/core").Signal<number>;
+  /** Increments once per keyboard show (at will-show), for one-off reactions such as closing popovers. */
+  readonly willShow: import("@angular/core").Signal<number>;
+  /**
+   * True from `focusin` on a text-entry control (see `isTextEntry`) until that control's
+   * `focusout` or either keyboard hide event; never cleared by will-show. Hide chrome such as the
+   * tab bar on `visible() || imminent()`: on Android the WebView shrinks before the plugin's
+   * will-show, which lifts `position: fixed` elements above the keyboard; `focusin` is the only
+   * earlier signal. When it turns true without the keyboard up, it also clears itself after
+   * `IMMINENT_TIMEOUT_MS` (2500 ms) unless will-show or a visible keyboard arrives first, so a
+   * hardware keyboard, which fires no keyboard event, does not keep the tab bar hidden.
+   */
+  readonly imminent: import("@angular/core").Signal<boolean>;
+  constructor();
+  /** Hides the keyboard: `Keyboard.hide()` on native, blurs the focused element on the web. */
+  hide(): Promise<void>;
+  /**
+   * The keyboard's top edge in viewport CSS px, read on demand. While the keyboard overlays the
+   * WebView (native iOS) it is `restHeight() - height()`; where the viewport shrinks for it
+   * (Android, the web) it is the bottom of `visualViewport` (else `innerHeight`). With the
+   * keyboard hidden it is `restHeight()`.
+   */
+  keyboardTop(): number;
+  private createProbe;
+  private measureRestHeight;
+  /** Never measures the rest height: on Android the WebView has already shrunk by will-show. */
+  private onWillShow;
+  private onDidShow;
+  private onHidden;
+  /** Either plugin hide event: the keyboard is gone even if the control keeps focus. */
+  private onHideEvent;
+  private clearImminent;
+  /** Arms the hardware-keyboard fallback; a keyboard already up needs none. */
+  private armImminentTimeout;
+  private cancelImminentTimeout;
+  private setHeight;
+  private writeHeightVariable;
+  private attachPlugin;
+  private attachVisualViewport;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfKeyboardService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Provides the mobile shell: its configuration, the stack-aware route reuse strategy
+ * (`BfStackReuseStrategy`) and `BF_OVERLAY_HOST` (the hardware back button closes the top overlay
+ * through `BfBackButtonService`, which on native Android also stands in for the overlays'
+ * `CloseWatcher`, and the document never scrolls, so overlays skip the scroll lock). An environment initializer starts `BfPlatformService` (theme sync, the `dark` class),
+ * `BfBackButtonService` (the Android hardware back listener), `BfKeyboardService` (keyboard
+ * listeners and the rest-height probe), `BfHapticsService` (its native plugin loads lazily on first
+ * use, so this only makes the singleton available) and `BfTextScaleService` (iOS Dynamic Type on
+ * the root font size) at bootstrap, before any page renders. Every service is
+ * `providedIn: 'root'`, so this function lists none of them: `BfNavController` and the overlay
+ * services (`BfOverlayStack`, `BfOverlayService`, `BfSheetService`, `BfModalService`,
+ * `BfToastService`, `BfActionSheetService`, `BfAlertDialogService`) are created on first
+ * injection, and an app that never injects an overlay service bundles no overlay code. Use it
+ * together with `provideRouter(routes, withComponentInputBinding(), withBfShellRouting())`, in the
+ * application providers: in a lazy route's environment injector the services still resolve from
+ * the root injector.
+ *
+ * @param config The settings to change; any left out keep `BF_SHELL_DEFAULTS`.
+ * @returns The shell's environment providers.
+ * @summary Provides the Capacitor app shell: its configuration, navigation and platform services
+ * @since 0.2.0
+ */
+export declare function provideBfShell(config?: Partial<BfShellConfig>): EnvironmentProviders;
+/**
+ * The router feature the stack needs: `canceledNavigationResolution: 'computed'`, so a refused
+ * back navigation (a guard stopping a swipe-back) restores the browser history position and the
+ * stack stays in sync with it. Pass it to `provideRouter()`.
+ *
+ * @returns The router configuration feature.
+ * @summary The router setting the mobile shell's stack needs, passed to provideRouter
+ * @since 0.2.0
+ */
+export declare function withBfShellRouting(): RouterConfigurationFeature;
+/**
+ * The route reuse strategy the stack needs: the default one, except that a route whose *path
+ * params* change (`/items/4` → `/items/5`) is a new page, not an in-place update. The default only
+ * compares `routeConfig`, so the router would reuse the component and never call the outlet, and
+ * the stack would no longer match the history. Query-param changes still reuse the page (filters,
+ * tabs). Exported so an app can extend it for its own reuse rules.
+ * @summary Route reuse strategy that treats a changed path parameter as a new stack page
+ * @since 0.2.0
+ */
+export declare class BfStackReuseStrategy extends BaseRouteReuseStrategy {
+  /**
+   * Whether the router may reuse the current page for `future`: same route config and path params.
+   * @param future The route being navigated to.
+   * @param curr The route shown now.
+   * @returns True to reuse the page in place.
+   */
+  shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfStackReuseStrategy, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Where a stacked page is in its lifecycle.
+ *
+ * @summary Where a stacked page is in its lifecycle: entering, active, leaving or inactive
+ * @since 0.2.0
+ */
+type BfViewState = 'entering' | 'active' | 'leaving' | 'inactive';
+/**
+ * One lifecycle event of a stacked page.
+ *
+ * @summary The four lifecycle events of a stacked page as it enters and leaves
+ * @since 0.2.0
+ */
+type BfViewEvent = 'willEnter' | 'didEnter' | 'willLeave' | 'didLeave';
+/**
+ * Per-page lifecycle. `bf-stack-outlet` creates one per page and provides it through the page's
+ * element injector; `bf-page` re-exposes it as outputs, and any page or service can
+ * `inject(BfViewLifecycle)` to react to the page entering or leaving the top of the stack.
+ * `state` and the counters are signals for `computed`/`effect`; `on()` delivers every event
+ * synchronously, including the ones that happen before the page's first change detection and
+ * right before a popped page is destroyed.
+ * @summary The lifecycle of one stacked page as signals and events, from enter to leave
+ * @since 0.2.0
+ */
+export declare class BfViewLifecycle {
+  /** The page's current lifecycle state. */
+  readonly state: import("@angular/core").WritableSignal<BfViewState>;
+  /** How often the page started entering; monotonic, so a page can `effect()` on it. */
+  readonly willEnter: import("@angular/core").WritableSignal<number>;
+  /** How often the page became the top page (its enter transition ended). */
+  readonly didEnter: import("@angular/core").WritableSignal<number>;
+  /** How often the page started leaving the top of the stack. */
+  readonly willLeave: import("@angular/core").WritableSignal<number>;
+  /** How often the page stopped being the top page (its leave transition ended). */
+  readonly didLeave: import("@angular/core").WritableSignal<number>;
+  private readonly listeners;
+  /**
+   * Calls `listener` synchronously on every event; returns a function that removes it.
+   * @param listener Called with each event, synchronously.
+   */
+  on(listener: (event: BfViewEvent) => void): () => void;
+  /**
+   * Moves the page to its `willEnter` state and notifies; called by `bf-stack-outlet`.
+   * @internal
+   */
+  fireWillEnter(): void;
+  /**
+   * Moves the page to its `didEnter` state and notifies; called by `bf-stack-outlet`.
+   * @internal
+   */
+  fireDidEnter(): void;
+  /**
+   * Moves the page to its `willLeave` state and notifies; called by `bf-stack-outlet`.
+   * @internal
+   */
+  fireWillLeave(): void;
+  /**
+   * Moves the page to its `didLeave` state and notifies; called by `bf-stack-outlet`.
+   * @internal
+   */
+  fireDidLeave(): void;
+  private notify;
+}
+/**
+ * The direction a navigation should animate in.
+ *
+ * @summary The direction a stack navigation animates in: forward, back or a new root
+ * @since 0.2.0
+ */
+type BfNavDirection = 'forward' | 'back' | 'root';
+/**
+ * A router target: a URL string, a `UrlTree` or a commands array, as `Router` accepts.
+ *
+ * @summary A navigation target as the router accepts it: a URL, a UrlTree or commands
+ * @since 0.2.0
+ */
+type BfNavTarget = string | UrlTree | readonly unknown[];
+/** What a stack outlet tells `BfNavController` when it registers (see `registerOutlet`). */
+interface BfNavOutlet {
+  /** Number of pages in the outlet's shown stack. */
+  readonly depth: Signal<number>;
+  /** False while the page that hosts the outlet is parked under another page (or leaving). */
+  readonly active: Signal<boolean>;
+  /** The (negative) history step that pops the outlet's top page, or null when unknown. */
+  popDelta(): number | null;
+}
+/**
+ * Stack-aware navigation. `forward` pushes, `back` pops through the real history (so the browser
+ * or WebView history stays in sync), `root` replaces the whole stack. Each call leaves a direction
+ * hint that `bf-stack-outlet` consumes on the next activation; without a hint the outlet infers
+ * the direction from the router event. A hint lives only as long as the navigation it started:
+ * when that navigation ends without an activation (a guard refused it), the hint is dropped so it
+ * cannot mislabel the next one. Every primary `bf-stack-outlet` registers here with its nesting
+ * level; `depth`, `canGoBack` and `back()` follow the **deepest active outlet** (the innermost one
+ * whose page is shown, e.g. the outlet inside `bf-tabs`, or the root outlet once it pushed a page
+ * above the tabs page). The controller also owns the priority-0 hardware back handler: it pops the
+ * deepest active outlet that has a page to pop, and lets the app exit only when every active
+ * outlet is at its first page (a parked outlet cannot be popped, so it never blocks the exit).
+ * @summary Stack-aware navigation that pushes, pops through the history and replaces the root
+ * @since 0.2.0
+ */
+export declare class BfNavController {
+  private readonly router;
+  private readonly location;
+  private readonly outlets;
+  private hint;
+  /** Id of the navigation the hint belongs to; null until that navigation starts. */
+  private hintNavigationId;
+  /** The active outlets, deepest first (on equal level, the one registered last first). */
+  private readonly activeOutlets;
+  /** Number of pages in the deepest active stack outlet (0 without an outlet). */
+  readonly depth: Signal<number>;
+  /** True when the deepest active stack has a page to go back to. */
+  readonly canGoBack: Signal<boolean>;
+  constructor();
+  /**
+   * Pushes a page.
+   * @param url Where to go.
+   * @param extras Router navigation extras, such as `queryParams`.
+   * @returns Whether the navigation succeeded.
+   */
+  forward(url: BfNavTarget, extras?: NavigationExtras): Promise<boolean>;
+  /**
+   * Replaces the whole stack with one page (`replaceUrl`, no animation).
+   * @param url Where to go.
+   * @param extras Router navigation extras, such as `queryParams`.
+   * @returns Whether the navigation succeeded.
+   */
+  root(url: BfNavTarget, extras?: NavigationExtras): Promise<boolean>;
+  /**
+   * Pops the top page of the deepest active outlet that has one to pop: always a real history
+   * step. When the page added history entries of its own (a query-only or nested child
+   * navigation), it goes back past them in one step (`Location.historyGo(-n)`) so the page below
+   * is shown; otherwise `Location.back()`.
+   */
+  back(): void;
+  /**
+   * Called by every primary stack outlet on init with its nesting level (the number of stack
+   * outlets around it). Returns a function that removes it again.
+   * @internal
+   */
+  registerOutlet(outlet: BfNavOutlet, level: number): () => void;
+  /**
+   * Returns the pending direction hint and clears it; called by the stack outlet.
+   * @internal
+   */
+  consumeHint(): BfNavDirection | null;
+  /**
+   * Drops a pending hint (its navigation never happened).
+   * @internal
+   */
+  clearHint(): void;
+  /** The deepest active outlet with a page to pop, else the deepest active outlet. */
+  private popTarget;
+  /**
+   * The hardware back button: pops while an active outlet has a page to pop; returns false (and
+   * the back button service exits the app) when every active outlet is at depth 1 or less. A
+   * parked outlet cannot be popped by `back()`, so it does not keep the app from exiting.
+   */
+  private handleBackButton;
+  private setHint;
+  private go;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfNavController, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Motion constants of the mobile shell, shared by the page transitions, the overlays and the
+ * refresher. `theme.css` mirrors them for CSS: `--ease-ios`, `--ease-md`, `--ease-settle`
+ * (`@theme`) and `--bf-duration-fast`, `--bf-duration-overlay`, `--bf-duration-push` (`:root`).
+ */
+/**
+ * UIKit's navigation and sheet curve (push/pop, overlays, modal depth); `OVERLAY_EASING` too.
+ *
+ * @summary The UIKit navigation and sheet easing curve of pushes, pops and overlays
+ * @since 0.2.0
+ */
+export declare const IOS_EASING = "cubic-bezier(0.32, 0.72, 0, 1)";
+/**
+ * Material standard easing (the Android fade-up).
+ *
+ * @summary The Material standard easing curve of the Android page fade-up transition
+ * @since 0.2.0
+ */
+export declare const MD_EASING = "cubic-bezier(0.2, 0, 0, 1)";
+/**
+ * Ease-out of a released gesture settling into place (swipe-back, refresher).
+ *
+ * @summary The ease-out curve a released swipe-back or refresher gesture settles with
+ * @since 0.2.0
+ */
+export declare const SETTLE_EASING = "cubic-bezier(0.2, 0.8, 0.3, 1)";
+/**
+ * Colour transitions and the reduced-motion cross-fade (ms); the overlay core's reduced fade.
+ *
+ * @summary The duration of colour transitions and the reduced-motion fade, in milliseconds
+ * @since 0.2.0
+ */
+export declare const DURATION_FAST = 150;
+/**
+ * Overlay enter/exit and the modal depth effect (ms); the overlay core's duration.
+ *
+ * @summary The duration of overlay enter and exit and the modal depth effect, in milliseconds
+ * @since 0.2.0
+ */
+export declare const DURATION_OVERLAY = 260;
+/**
+ * iOS push/pop (ms).
+ *
+ * @summary The duration of the iOS push and pop page transitions, in milliseconds
+ * @since 0.2.0
+ */
+export declare const DURATION_PUSH = 500;
+/**
+ * Material fade-up and the refresher settle (ms).
+ *
+ * @summary The duration of the Material fade-up and the refresher settle, in milliseconds
+ * @since 0.2.0
+ */
+export declare const DURATION_MD = 220;
+/**
+ * The iOS push and pop (ms), `DURATION_PUSH`.
+ *
+ * @summary The duration of the iOS push and pop stack transitions, in milliseconds
+ * @since 0.2.0
+ */
+export declare const IOS_DURATION = 500;
+/**
+ * Upper bound of the settle animation after a released swipe.
+ *
+ * @summary The longest a released swipe-back may take to settle, in milliseconds
+ * @since 0.2.0
+ */
+export declare const MAX_COMPLETE_MS = 540;
+/**
+ * Material fade-up.
+ *
+ * @summary The duration of the Material fade-up stack transition, in milliseconds
+ * @since 0.2.0
+ */
+export declare const MD_DURATION = 220;
+/**
+ * Cross-fade used under `prefers-reduced-motion`.
+ *
+ * @summary The duration of the cross-fade that replaces page motion under reduced motion
+ * @since 0.2.0
+ */
+export declare const REDUCED_DURATION = 150;
+/**
+ * A running set of animations that finish together.
+ *
+ * @summary A running set of page transition animations that finish together
+ * @since 0.2.0
+ */
+interface BfStackTransition {
+  /** The Web Animations of the transition, one per moving layer. */
+  readonly animations: Animation[];
+  /** Their shared duration (ms). */
+  readonly duration: number;
+  /** Resolves when every animation finished or was cancelled; never rejects. */
+  readonly finished: Promise<void>;
+}
+/**
+ * The direction of a stack transition: a page pushed on, or popped off.
+ *
+ * @summary The direction of a stack transition, a page pushed on or popped off
+ * @since 0.2.0
+ */
+type BfTransitionKind = 'push' | 'pop';
+/**
+ * The iOS push or pop. `pop` is written as the literal reverse of a push but as forward
+ * keyframes, so `currentTime` maps directly to swipe progress (0 = nothing moved, duration = pop
+ * complete). Returns three animations: the top page (slide and edge shadow), the page under it
+ * (parallax) and the dim layer.
+ *
+ * @param kind `push` or `pop`.
+ * @param entering The page that becomes visible.
+ * @param leaving The page that goes away.
+ * @param dim The dimming layer between the two pages.
+ * @param width The width the pages travel (the outlet width, px).
+ * @param easing The curve of the transition.
+ * @returns The three running animations.
+ * @summary Builds the iOS push or pop with its slide, parallax and dimming layers
+ * @since 0.2.0
+ */
+export declare function createTransition(kind: BfTransitionKind, entering: HTMLElement, leaving: HTMLElement, dim: HTMLElement, width: number, easing?: string): BfStackTransition;
+/**
+ * Material fade-up: the entering page fades in while rising 16 px; a pop is the reverse on the
+ * leaving page. No parallax, no dim.
+ *
+ * @param kind `push` or `pop`.
+ * @param entering The page that becomes visible.
+ * @param leaving The page that goes away.
+ * @returns The running animation.
+ * @summary Builds the Material fade-up page transition of a push or a pop
+ * @since 0.2.0
+ */
+export declare function mdTransition(kind: BfTransitionKind, entering: HTMLElement, leaving: HTMLElement): BfStackTransition;
+/**
+ * Reduced motion: a 150 ms cross-fade of the two pages, nothing moves.
+ *
+ * @param entering The page that becomes visible.
+ * @param leaving The page that goes away.
+ * @returns The two running fades.
+ * @summary Builds the cross-fade that replaces page motion when the user reduces motion
+ * @since 0.2.0
+ */
+export declare function reducedTransition(entering: HTMLElement, leaving: HTMLElement): BfStackTransition;
+/**
+ * Frame values of the pop at progress `p` (0 = start, 1 = done), used to hand a scrubbed gesture
+ * over to a fresh eased animation on release.
+ *
+ * @param p The pop progress, 0 (start) to 1 (done).
+ * @param width The outlet width (px).
+ * @returns The top page offset, the page under it and the dim opacity.
+ * @summary The positions of the pop layers at a given progress, for scrubbing a swipe
+ * @since 0.2.0
+ */
+export declare function popFramesAt(p: number, width: number): {
+  top: number;
+  under: number;
+  dim: number;
+};
+/**
+ * Animates top, under and dim from pop progress `from` to `to` with an ease-out.
+ *
+ * @param top The page being popped.
+ * @param under The page under it.
+ * @param dim The dimming layer.
+ * @param width The outlet width (px).
+ * @param from The progress at release, 0 to 1.
+ * @param to The progress to settle at: 1 completes the pop, 0 cancels it.
+ * @param duration The settle duration (ms), see `settleDuration`.
+ * @returns The three running animations.
+ * @summary Animates a released swipe-back from its progress to done or back to the start
+ * @since 0.2.0
+ */
+export declare function settlePop(top: HTMLElement, under: HTMLElement, dim: HTMLElement, width: number, from: number, to: number, duration: number): BfStackTransition;
+/**
+ * The release rule of the swipe-back: a flick (`velocity` above 0.2 px/ms) or a drag past half
+ * the width completes the pop; anything else settles back.
+ *
+ * @param velocity The release speed (px/ms, positive towards the end edge).
+ * @param delta The distance swiped (px).
+ * @param width The outlet width (px).
+ * @returns True when the pop completes.
+ * @summary Decides whether a released swipe-back completes the pop or settles back
+ * @since 0.2.0
+ */
+export declare function shouldCompletePop(velocity: number, delta: number, width: number): boolean;
+/**
+ * Duration of the settle animation after a release: the remaining distance at the release speed
+ * (at least 0.5 px/ms), clamped to 120 ms … `MAX_COMPLETE_MS`.
+ *
+ * @param remainingPx The distance left to travel (px).
+ * @param velocity The release speed (px/ms).
+ * @returns The duration (ms), 120 to `MAX_COMPLETE_MS`.
+ * @summary The duration of the settle animation after a released swipe-back gesture
+ * @since 0.2.0
+ */
+export declare function settleDuration(remainingPx: number, velocity: number): number;
+/**
+ * Emitted by `bf-stack-outlet` after every change of its stack.
+ *
+ * @summary What a stack outlet reports after its stack changed: the depth and the tab
+ * @since 0.2.0
+ */
+interface BfStackChange {
+  /** Number of pages in the active stack. */
+  depth: number;
+  /** Key of the active tab's stack inside `bf-tabs`; null for an outlet outside `bf-tabs`. */
+  tabKey: string | null;
+}
+/**
+ * Emitted by `bf-stack-outlet` around a transition between two pages.
+ *
+ * @summary What a stack outlet reports around a page transition: its kind and animation
+ * @since 0.2.0
+ */
+interface BfStackTransitionEvent {
+  /** `push` for a new page (also a `replaceUrl` navigation), `pop` for going back. */
+  kind: BfTransitionKind;
+  /** False when the pages switched without an animation (`animated=false`). */
+  animated: boolean;
+}
+/**
+ * A router outlet that keeps a stack of live pages: a push slides the new page in and parks the
+ * previous one (still in the DOM, so scroll and state survive), a pop slides the top page out and
+ * destroys it, and on iOS a finger's edge swipe scrubs the pop (touch only: a mouse or pen drag
+ * never arms it). `provideBfShell({ maxLivePages })` bounds the live pages of each stack: the
+ * deepest ones are destroyed and created again, scroll restored, on a pop back to them. Replaces
+ * `<router-outlet>` in a mobile app.
+ * Pages receive route params, query params and route data as inputs, bound by the outlet itself.
+ * Inside `bf-tabs` it keeps one stack per tab and switches between them without a transition.
+ * Outlets nest: an outlet inside a page (the tabs page) keeps its stacks while an outer outlet
+ * parks that page, and `BfNavController` follows the innermost outlet whose page is shown.
+ *
+ * @example
+ * <bf-stack-outlet />
+ * @summary Router outlet keeping a live page stack with slide transitions and iOS swipe back
+ * @category Navigation
+ * @since 0.2.0
+ */
+export declare class BfStackOutletComponent implements RouterOutletContract, OnInit, AfterViewInit, OnDestroy {
+  /** Outlet name, as on `router-outlet`. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Enables the iOS edge swipe-back for this outlet (ignored in Material mode). */
+  readonly swipeGesture: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Animates push and pop; false switches pages instantly (lifecycle events still fire). */
+  readonly animated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted with the new depth after every change of the stack. */
+  readonly stackChanged: import("@angular/core").OutputEmitterRef<BfStackChange>;
+  /** Emitted when a transition between two pages starts (also the start of a swipe-back). */
+  readonly transitionStarted: import("@angular/core").OutputEmitterRef<BfStackTransitionEvent>;
+  /** Emitted when a transition between two pages has settled. */
+  readonly transitionEnded: import("@angular/core").OutputEmitterRef<BfStackTransitionEvent>;
+  /**
+   * Emitted with the new depth after every change of the stack, together with `stackChanged`.
+   * @deprecated 0.3.0 use stackChanged; removed in 0.4.0
+   */
+  readonly stackChange: import("@angular/core").OutputEmitterRef<BfStackChange>;
+  /**
+   * Emitted when a transition starts, together with `transitionStarted`.
+   * @deprecated 0.3.0 use transitionStarted; removed in 0.4.0
+   */
+  readonly transitionStart: import("@angular/core").OutputEmitterRef<BfStackTransitionEvent>;
+  /**
+   * Emitted when a transition has settled, together with `transitionEnded`.
+   * @deprecated 0.3.0 use transitionEnded; removed in 0.4.0
+   */
+  readonly transitionEnd: import("@angular/core").OutputEmitterRef<BfStackTransitionEvent>;
+  readonly supportsBindingToComponentInputs: true;
+  private readonly parentContexts;
+  private readonly router;
+  private readonly location;
+  private readonly nav;
+  private readonly overlays;
+  private readonly config;
+  private readonly platform;
+  private readonly host;
+  private readonly document;
+  private readonly tabContext;
+  /** The stack outlet around this one (this outlet is inside one of its pages), if any. */
+  private readonly parentOutlet;
+  /** The page of the parent outlet this outlet lives in, if any. */
+  private readonly outletHost;
+  /** Lifecycle of the page hosting this outlet (null for a root outlet); forwarded to our page. */
+  private readonly hostLifecycle;
+  /** Removes the listener on `hostLifecycle`. */
+  private hostLifecycleOff;
+  /** Number of stack outlets around this one: 0 for the root outlet. */
+  private readonly level;
+  /** False while the page hosting this outlet is parked, so none of its pages is shown. */
+  private readonly shown;
+  private readonly depthState;
+  private readonly anchor;
+  private readonly dim;
+  private readonly mode;
+  private readonly injector;
+  /** Pages of one stack kept alive (`BfShellConfig.maxLivePages`): at least 1, else every page. */
+  private readonly maxLivePages;
+  /** One stack per tab key inside `bf-tabs`; a single stack under the `null` key otherwise. */
+  private readonly stacks;
+  /** Key of the stack that is shown; always null outside `bf-tabs`. */
+  private activeTab;
+  private active;
+  private leaving;
+  /**
+   * The page deactivated while the host page was parked (an outer outlet pushed above it): kept,
+   * with every stack, and resumed as it was when the host page comes back.
+   */
+  private suspended;
+  private pending;
+  private viewReady;
+  /** The running transition and the completion that must run if it gets interrupted. */
+  private current;
+  /** Final frame of a completed swipe, held until the router re-activates the page below. */
+  private held;
+  /** Set while the swipe gesture has already animated the pop the router now performs. */
+  private gestureCommitted;
+  private gesture;
+  private lastStart;
+  private destroyed;
+  /** Pending rAF of the deferred transition start. */
+  private startFrame;
+  /** Fallback timer after a completed swipe's `Location.back()`. */
+  private backFallback;
+  /** Unregisters this outlet from `BfNavController`; primary outlets only. */
+  private navUnregister;
+  /** Unregisters the host as a page root of `BfOverlayStack`; outermost outlets only. */
+  private rootUnregister;
+  /** History position after the last completed navigation (see `pageIdOf`). */
+  private settledPageId;
+  /** Element that had focus in the top page when a swipe was claimed, restored on cancel. */
+  private swipeFocus;
+  /** The stack that is shown (the active tab's stack inside `bf-tabs`). */
+  private get stack();
+  constructor();
+  get isActivated(): boolean;
+  get component(): object;
+  get activatedRoute(): ActivatedRoute;
+  get activatedRouteData(): Data;
+  get activatedComponentRef(): ComponentRef<unknown> | null;
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  ngOnDestroy(): void;
+  /**
+   * The router tears down the active page. It is NOT destroyed here: it either stays under the
+   * next page (push) or is removed after the pop animation (decided in `activateWith`).
+   * @internal
+   */
+  deactivate(): void;
+  /**
+   * The router shows a page: pushed, popped to, or a new root (the router outlet contract).
+   * @internal
+   */
+  activateWith(activatedRoute: ActivatedRoute, environmentInjector: EnvironmentInjector): void;
+  /**
+   * Only called by a store/retrieve `RouteReuseStrategy`; the stack itself never needs one.
+   * @internal
+   */
+  detach(): ComponentRef<unknown>;
+  /**
+   * Re-attaches a page a store/retrieve `RouteReuseStrategy` kept (the router outlet contract).
+   * @internal
+   */
+  attach(ref: ComponentRef<unknown>, activatedRoute: ActivatedRoute): void;
+  /**
+   * The URL of the top page of a tab's stack (inside `bf-tabs`), or null when that tab has no
+   * stack yet. `bf-tabs` navigates there on a tab switch, so the tab comes back as it was left.
+   * @param tabKey The key of the tab, the URL segment after `tabsPath`.
+   */
+  lastUrlOf(tabKey: string): string | null;
+  /**
+   * Pops the active stack back to its first page in one history step (`Location.historyGo(-n)`
+   * to the entry before the second page was pushed), keeping that page alive. Returns false, and
+   * does nothing, when the stack has one page or the history position is unknown.
+   */
+  popToRoot(): boolean;
+  /**
+   * Scrolls the active page's `bf-content` back to the top (a re-selected tab).
+   * @param behavior `smooth` (the default) or `instant`.
+   */
+  scrollActiveContentToTop(behavior?: ScrollBehavior): void;
+  /**
+   * A navigation onto another tab's key: parks the whole current stack and shows the target
+   * stack (its page for this URL, the pages above it dropped) or starts it with a new page. No
+   * transition and no gesture; `fresh` (a `root` navigation) discards the target stack first.
+   */
+  private switchStack;
+  /** Shows a page of the stack again: a live one as it was, a dormant one created anew. */
+  private bringBack;
+  /**
+   * Creates a dormant page again from the route the router re-activated, in a new frame, keeping
+   * its record (key, history position, URL); its scroller gets the `scrollTop` it had back after
+   * the first render. Its nested outlets start empty ("deep pages come back fresh").
+   */
+  private revive;
+  /**
+   * Keeps at most `maxLivePages` pages of the shown stack alive: the deepest ones beyond it go
+   * dormant (component destroyed, frame removed, record kept). The top pages stay alive.
+   */
+  private trimStack;
+  private makeDormant;
+  /** Shows a kept page again: new route, nested outlets re-attached, change detection back on. */
+  private reactivate;
+  private tabOf;
+  private destroyAllStacks;
+  private classify;
+  private createEntry;
+  /**
+   * Moves the page host into its own positioned frame. The host stays a view of the anchor's
+   * `ViewContainerRef` (Angular removes a destroyed host from whatever parent it has); the frame
+   * is what gets animated, parked and focused, so the page host stays free of outlet state.
+   */
+  private wrap;
+  /**
+   * The outlet's own component-input binder: the router's (`RoutedComponentInputBinder` behind
+   * the private `INPUT_BINDER` token) only serves `RouterOutlet`. Mirrors its Angular 22.1
+   * behaviour with the default options, whether or not `withComponentInputBinding()` is present:
+   * query params, then path params, then route data (including resolved data), each input set
+   * (or cleared with `undefined`) on every emission. Not supported: the feature's
+   * `queryParams: false` and `unmatchedInputBehavior` options and the experimental route
+   * `resources`.
+   */
+  private bindInputs;
+  private destroyEntry;
+  private emitTransitionStart;
+  private emitTransitionEnd;
+  private emitDepth;
+  /** Makes `entry` the active page; the page it replaces is parked for its nested outlets. */
+  private setActive;
+  /**
+   * The host page is back (the outer outlet popped to it): shows the page that was active when
+   * it was parked, as it was, when the router activates the same route key on the same stack.
+   * Returns false for any other route, which then goes through the normal classification.
+   */
+  private resume;
+  /**
+   * The host page entered or left (the parent outlet parked or restored it): the page this outlet
+   * shows follows it. Fires only on a real state change, so a page that just ran its own
+   * transition (or its first activation) does not get an event twice.
+   */
+  private forwardHostEvent;
+  private requireActive;
+  /**
+   * Layers the two pages, fires the lifecycle, animates (unless `kind` is null, `animated` is
+   * off or a swipe already animated the pop), then destroys `removed`, parks `leaving` when it
+   * stays in the stack and moves focus.
+   */
+  private runTransition;
+  private createAnimation;
+  /** A new activation during a running transition finishes the old one at once. */
+  private interruptTransition;
+  private clearBackFallback;
+  private releaseHeld;
+  private moveFocus;
+  /** During a transition: both pages visible, only the entering one interactive. */
+  private layer;
+  /** Final state: only the top page visible and interactive; the rest parked. */
+  private settleLayers;
+  /**
+   * Non-passive `touchmove` guard, attached only while a swipe is armed (which happens only inside
+   * the 50 px edge zone). Once the swipe is claimed, native scrolling must not start: a horizontal
+   * scroller under the finger (any `overflow-x-auto` row, which pans on its own) would take over
+   * the touch and cancel the pointer stream. Inside the edge zone the gesture wins; outside it the
+   * guard is never attached, so such scrollers keep their own pan.
+   */
+  private readonly touchMoveGuard;
+  private readonly onPointerDown;
+  private readonly onPointerMove;
+  private readonly onPointerUp;
+  private readonly onPointerCancel;
+  /** Settles a swipe that did not pop: the top page stays, the page under it is parked again. */
+  private cancelSwipe;
+  /**
+   * The history step that pops the top page in one navigation: back to the entry before the page
+   * was pushed, skipping the entries it added itself (query-only or nested child navigations).
+   * Null when unknown, and `Location.back()` is used instead.
+   */
+  private popDelta;
+  private endGesture;
+  /** The router refused a swiped pop (a guard): slide the top page back in over 300 ms. */
+  private restoreAfterRefusedPop;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfStackOutletComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfStackOutletComponent, "bf-stack-outlet", never, {
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "swipeGesture": {
+      "alias": "swipeGesture";
+      "required": false;
+      "isSignal": true;
+    };
+    "animated": {
+      "alias": "animated";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "stackChanged": "stackChanged";
+    "transitionStarted": "transitionStarted";
+    "transitionEnded": "transitionEnded";
+    "stackChange": "stackChange";
+    "transitionStart": "transitionStart";
+    "transitionEnd": "transitionEnd";
+  }, never, never, true, never>;
+}
+/**
+ * The page frame of a mobile app: `bf-stack-outlet` positions one per stacked page and provides
+ * its `BfViewLifecycle` through the element injector. Everything scrollable inside a page goes
+ * into `bf-content`; `bf-page` is only the frame, the lifecycle signal and a per-page
+ * `BfPageContext` (provided for its children, where `bf-content` registers its scroller). The
+ * page an outlet shows makes its `bf-content` the document's `main` landmark. Used
+ * standalone (outside an outlet, e.g. in a docs demo) it falls back to a local, inert lifecycle
+ * instance instead of throwing, and exposes no `main` landmark.
+ *
+ * @example
+ * <bf-page (bfViewDidEnter)="load()">
+ *   <p>Page content</p>
+ * </bf-page>
+ * @summary Frame for one stacked mobile screen that supplies lifecycle events and shared page state
+ * @category Navigation
+ * @since 0.2.0
+ * @slot default The page: a `bf-header` and a `bf-content`.
+ */
+export declare class BfPageComponent {
+  private readonly lifecycle;
+  /** The page's current lifecycle state, mirrored from `BfViewLifecycle`. */
+  readonly viewState: import("@angular/core").Signal<import("@bitforgehq/ui/mobile").BfViewState>;
+  /** Emitted when the page starts entering the top of the stack. */
+  readonly bfViewWillEnter: import("@angular/core").OutputEmitterRef<void>;
+  /** Emitted once the page is active at the top of the stack. */
+  readonly bfViewDidEnter: import("@angular/core").OutputEmitterRef<void>;
+  /** Emitted when the page starts leaving the top of the stack. */
+  readonly bfViewWillLeave: import("@angular/core").OutputEmitterRef<void>;
+  /** Emitted once the page has left the top of the stack. */
+  readonly bfViewDidLeave: import("@angular/core").OutputEmitterRef<void>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfPageComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfPageComponent, "bf-page", never, {}, {
+    "bfViewWillEnter": "bfViewWillEnter";
+    "bfViewDidEnter": "bfViewDidEnter";
+    "bfViewWillLeave": "bfViewWillLeave";
+    "bfViewDidLeave": "bfViewDidLeave";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Per-page state shared between the parts of one `bf-page`. `bf-page` provides a fresh instance
+ * for each page through its element injector; `bf-content` registers its scroll container here
+ * on init (and clears it on destroy), so siblings such as `bf-header` can follow the page's
+ * scroll without querying the DOM. A plain class, like `BfViewLifecycle`: it is only ever
+ * provided per page, never from the root injector.
+ *
+ * @example
+ * const scroller = inject(BfPageContext, { optional: true })?.scroller;
+ * @since 0.2.0
+ * @summary Per-page state that the header and content of one page share
+ */
+export declare class BfPageContext {
+  /** The page's scroll container (`bf-content`'s scroller), or `null` before one registers. */
+  readonly scroller: import("@angular/core").WritableSignal<HTMLElement | null>;
+  /**
+   * Height (px) of a `translucent` `bf-header` drawn over the content, which `bf-content` pads its
+   * scroller by (`--bf-header-height`); 0 while the header sits in the page's flow (or none).
+   */
+  readonly headerHeight: import("@angular/core").WritableSignal<number>;
+  /**
+   * Whether the page reaches the top of the screen, so its `bf-header` toolbar (and a `fullscreen`
+   * `bf-content`) pads by the top safe area. True for a page; `bf-modal` in the `sheet`
+   * presentation sets it to false, because its card already sits below the status bar.
+   */
+  readonly safeAreaTop: import("@angular/core").WritableSignal<boolean>;
+  /**
+   * Whether the page's `bf-content` scroller is the document's `main` landmark (`role="main"`).
+   * True for the page a `bf-stack-outlet` shows; `bf-modal` sets it to false (content in a dialog
+   * is not `main`), and so does a `bf-page` outside an outlet (a docs illustration) or nested in
+   * another page, so the document keeps exactly one `main`: parked pages are `inert` and
+   * `aria-hidden`, so only the shown page's landmark is exposed.
+   */
+  readonly mainLandmark: import("@angular/core").WritableSignal<boolean>;
+}
+/**
+ * Provided by `bf-stack-outlet` for each stacked page: the page's outermost `bf-page` registers
+ * its `BfPageContext` here (a nested `bf-page` finds the slot taken and leaves it), so the outlet
+ * can reach the page's scroller, e.g. to scroll it to the top when its tab is re-selected.
+ * Internal to the mobile entry.
+ */
+declare class BfPageContextSlot {
+  context: BfPageContext | null;
+}
+/**
+ * Back button for a `bf-header` start slot (or anywhere else in a page): pops the shown stack,
+ * or replaces it with `defaultHref` when there's nothing to pop back to, e.g. a deep link that
+ * landed on this page directly. Hidden when neither applies. Its anatomy follows the shell mode:
+ * iOS, a chevron with the `label` as text; Material, a bare arrow icon button named by `label`.
+ *
+ * @example
+ * <bf-back-button defaultHref="/tabs/today" />
+ * @summary Header back button that pops the page stack or falls back to a default route
+ * @category Navigation
+ * @since 0.2.0
+ */
+export declare class BfBackButtonComponent {
+  private readonly nav;
+  private readonly labels;
+  /** Destination `nav.root()` navigates to when there's no page to pop back to. */
+  readonly defaultHref: import("@angular/core").InputSignal<string>;
+  /**
+   * The previous page's name: the text beside the chevron in iOS mode, the arrow button's
+   * accessible name in Material mode. Empty falls back to `provideBfLabels()`'s `back` ("Back").
+   */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** The shell mode (`provideBfShell({ mode })`, or the platform's for `'auto'`). */
+  protected readonly mode: BfShellMode;
+  protected readonly iosClasses: string;
+  protected readonly chevronLeft: import("lucide").IconNode;
+  protected readonly arrowLeft: import("lucide").IconNode;
+  /** The rendered label: `label`, else the `back` label. */
+  readonly name: import("@angular/core").Signal<string>;
+  /** Shown when the stack has a page to go back to, or a `defaultHref` is set. */
+  readonly visible: import("@angular/core").Signal<boolean>;
+  /** Goes back one page, or to `defaultHref` when the stack has none to go back to. */
+  go(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfBackButtonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfBackButtonComponent, "bf-back-button", never, {
+    "defaultHref": {
+      "alias": "defaultHref";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Sets `touch-action: pan-x pan-y` (and a `data-bf-horizontal-scroll` marker) on a horizontally
+ * scrolling element inside a `bf-stack-outlet` page. Not needed: `touch-action` is not inherited,
+ * and a touch's effective value is the intersection of the values from the touched element up to
+ * its nearest scroll container only, so an `overflow-x-auto` row (a chips row, a carousel) pans
+ * on its own under the outlet's `touch-action: pan-y`, on iOS and on Android. Only the 50 px
+ * left-edge zone belongs to the swipe-back, with or without the directive.
+ *
+ * @example
+ * <div bfHorizontalScroll class="flex gap-2 overflow-x-auto">
+ *   <bf-chip>All</bf-chip>
+ *   <bf-chip>Open</bf-chip>
+ * </div>
+ * @deprecated 0.3.0 use a plain overflow-x-auto scroller, which pans on its own; removed in 0.4.0
+ * @category Navigation
+ * @since 0.2.0
+ * @summary Deprecated touch-action opt-in for horizontal scrollers in stack pages, not needed
+ */
+export declare class BfHorizontalScrollDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfHorizontalScrollDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfHorizontalScrollDirective, "[bfHorizontalScroll]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The payload of `bf-content`'s `scrolled` output: the scroller's `scrollTop` after the scroll.
+ *
+ * @summary What a content scroll event carries: the scroller's current top offset
+ * @since 0.3.0
+ */
+interface BfContentScrollEvent {
+  /** The scroller's `scrollTop`, in px. */
+  scrollTop: number;
+}
+/**
+ * The page's single scroll container: fills the rest of `bf-page` under the header, keeps the
+ * focused text control clear of the soft keyboard (`bfKeyboardAssist`), pads for the horizontal
+ * safe areas, for the floating tab bar (`--bf-tab-bar-inset`), for a `translucent` header drawn
+ * over it (`--bf-header-height`, from `BfPageContext`) and at the bottom for the height a solid
+ * `bf-header` has collapsed by (`--bf-header-collapse`, written by the header, so the scroll range
+ * stays the same while the large title collapses), and contains overscroll so the document
+ * never scrolls. On iOS (`ios.scrollEnabled: false`) it is the only thing that scrolls. The
+ * projected content sits in a block body inside the scroller: in iOS mode the body is 1 px taller
+ * than the scroller, so WebKit rubber-bands even a short page; in Material mode the scroller gets
+ * `bfOverscrollStretch`, the Android edge stretch the WebView does not draw itself, except in iOS
+ * WebKit (Safari or a home-screen app, platform `web`), which rubber-bands natively. Both follow the
+ * engine (`BfPlatformService.mode()`), not `provideBfShell({ mode })`. In the page a
+ * `bf-stack-outlet` shows, the scroller is the document's `main` landmark (`role="main"`; not in a
+ * `bf-modal`, see `BfPageContext.mainLandmark`). While it overflows and holds nothing focusable,
+ * it is a tab stop (`tabindex="0"`), so a keyboard can scroll it in Safari too (axe
+ * `scrollable-region-focusable`); otherwise Tab reaches its controls and the arrow keys scroll it.
+ *
+ * @example
+ * <bf-page>
+ *   <bf-content>
+ *     <bf-list>…</bf-list>
+ *   </bf-content>
+ * </bf-page>
+ * @summary Page's single scroll container that keeps focused fields clear of the soft keyboard
+ * @category Navigation
+ * @since 0.2.0
+ * @slot default The page content, in the scroll container.
+ */
+export declare class BfContentComponent {
+  /** Extends the content under the status bar: adds the top safe-area padding (no header above). */
+  readonly fullscreen: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Keeps the focused text control clear of the soft keyboard; false for screens that handle it themselves. */
+  readonly keyboardAssist: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits `scrolled` on every scroll; off by default so plain pages add no listener. */
+  readonly scrollEvents: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The scroller's `scrollTop` on each scroll, only while `scrollEvents` is true. */
+  readonly scrolled: import("@angular/core").OutputEmitterRef<BfContentScrollEvent>;
+  private readonly scroller;
+  private readonly pageContext;
+  private readonly platform;
+  private readonly iosWebKit;
+  protected readonly ios: import("@angular/core").Signal<boolean>;
+  /** The edge stretch only where nothing rubber-bands natively: never in iOS mode or iOS WebKit. */
+  protected readonly stretch: import("@angular/core").Signal<boolean>;
+  protected readonly bodyClasses: import("@angular/core").Signal<"" | "min-h-[calc(100%+1px)]">;
+  /** The shown page's content is the document's `main` landmark; a modal's is not. */
+  protected readonly role: import("@angular/core").Signal<"main" | null>;
+  /** True while the scroller overflows and holds nothing a keyboard can Tab to. */
+  protected readonly tabStop: import("@angular/core").WritableSignal<boolean>;
+  /** A page-sheet modal already sits below the status bar (`BfPageContext.safeAreaTop`). */
+  private readonly safeAreaTop;
+  protected readonly scrollerClasses: import("@angular/core").Signal<string>;
+  constructor();
+  /**
+   * Keeps `tabStop` current: re-checked once per frame after the scroller or its content resizes
+   * or the content changes (rows added, a control enabled, shown, hidden or made inert). Hidden,
+   * inert and unrendered controls do not count.
+   */
+  private watchKeyboardReach;
+  /** The scroll container element, for code that needs to read or drive it directly. */
+  get scrollElement(): HTMLElement;
+  /**
+   * Scrolls back to the top (e.g. on a second tap of the active tab).
+   * @param behavior `smooth` (the default) or `instant`.
+   */
+  scrollToTop(behavior?: ScrollBehavior): void;
+  /**
+   * Scrolls to the given offset in px.
+   * @param x The horizontal offset (px).
+   * @param y The vertical offset (px).
+   * @param behavior `smooth` (the default) or `instant`.
+   */
+  scrollToPoint(x: number, y: number, behavior?: ScrollBehavior): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfContentComponent, "bf-content", never, {
+    "fullscreen": {
+      "alias": "fullscreen";
+      "required": false;
+      "isSignal": true;
+    };
+    "keyboardAssist": {
+      "alias": "keyboardAssist";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollEvents": {
+      "alias": "scrollEvents";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "scrolled": "scrolled";
+  }, never, ["*"], true, never>;
+}
+/**
+ * How `bfKeyboardAssist` scrolls the focused control into view: `smooth` or `instant`.
+ *
+ * @summary Whether the keyboard assist scrolls a focused field into view smoothly or at once
+ * @since 0.3.0
+ */
+type BfKeyboardAssistBehavior = 'smooth' | 'instant';
+/**
+ * Keeps the focused text control of a scroll container clear of the soft keyboard. On keyboard
+ * will-show it pads the scroller by the part below the keyboard's top edge
+ * (`BfKeyboardService.keyboardTop()`: `padding-bottom`, plus `scroll-padding-bottom` with the
+ * margin for engine scrolls), then scrolls the focused `input`, `textarea` or `[contenteditable]`
+ * up until it sits `bfKeyboardAssistMargin` px above the keyboard (or down until it sits the margin
+ * below the scroller's top edge; in a scroller too short for the control and both margins, the gap
+ * above the control shrinks first, then the one above the keyboard, so a control shorter than the
+ * scroller stays whole; a taller one keeps its bottom at the keyboard top). The covered part is
+ * measured again at did-show and on every window or `visualViewport` resize, so a WebView that
+ * resizes for the keyboard (Android) gets no padding and a padding never outlives the keyboard,
+ * even on a detached page. A hidden host (a parked page, `visibility: hidden`) is never padded or
+ * scrolled. The reveal waits for the engine's own focus scroll to settle (100 ms without a `scroll`
+ * event, 120 ms if none arrives, at most 400 ms), then scrolls once; one correction follows at
+ * did-show once the scroller is quiet (skipped while a reveal is pending). Focus moving to another
+ * field while the keyboard is open re-arms the reveal, and both paddings go away on hide.
+ * `refresh()` measures and corrects again for a container that moved on its own. `bf-content`
+ * applies it to its own scroller; use it directly only on a custom scroll container.
+ *
+ * @example
+ * <div class="h-full overflow-y-auto" bfKeyboardAssist [bfKeyboardAssistMargin]="32">
+ *   <bf-input label="Name" />
+ * </div>
+ * @category Navigation
+ * @since 0.2.0
+ * @summary Keeps the focused text field of a scroll container clear of the soft keyboard
+ */
+export declare class BfKeyboardAssistDirective {
+  /** Enables the assist; set it false for screens that manage the keyboard themselves (a chat composer). */
+  readonly bfKeyboardAssist: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Gap kept between the focused control and the top of the keyboard, in px. */
+  readonly bfKeyboardAssistMargin: import("@angular/core").InputSignal<number>;
+  /** Scroll behaviour of the reveal. */
+  readonly bfKeyboardAssistBehavior: import("@angular/core").InputSignal<BfKeyboardAssistBehavior>;
+  private readonly host;
+  private readonly document;
+  private readonly keyboard;
+  private settleCallback;
+  private quietTimer;
+  private maxWaitTimer;
+  private revealPending;
+  private lastScrollAt;
+  constructor();
+  /**
+   * The did-show correction's measurement: the scroll it needs now, or 0 when it is skipped (a
+   * reveal is pending, the assist is off, the keyboard is no longer shown) or deferred until the
+   * scroller is quiet.
+   */
+  private settledCorrection;
+  /**
+   * Measures the covered part again and, while the keyboard is up, corrects the reveal once
+   * (instantly, after any scroll in progress). For a container that moves with the keyboard
+   * outside the keyboard events — `bf-sheet` calls it once its lift above the keyboard has ended.
+   */
+  refresh(): void;
+  /**
+   * False for a host that is not rendered visibly. A parked page is `visibility: hidden`, which
+   * `checkVisibility()` ignores unless asked with `visibilityProperty`.
+   */
+  private hostVisible;
+  /** Part of the host below the keyboard's top edge, in px; 0 while hidden or not applicable. */
+  private covered;
+  /** Measures and applies the paddings at once, outside change detection (resize, `refresh()`). */
+  private updatePadding;
+  /** The keyboard height the paddings answer to and the part of the host it covers. */
+  private measurePadding;
+  private applyPadding;
+  /**
+   * Arms a single-shot reveal: it runs once the scroller has been quiet for `REVEAL_QUIET_MS`
+   * after its last `scroll` event, `REVEAL_SETTLE_MS` after arming if none arrives, and at most
+   * `REVEAL_MAX_WAIT_MS` after arming.
+   */
+  private scheduleReveal;
+  /** Runs `callback` now if the scroller is quiet, else once it has been quiet for `REVEAL_QUIET_MS`. */
+  private whenScrollSettled;
+  private waitForQuiet;
+  private restartQuietTimer;
+  private finishSettle;
+  /** Drops a pending reveal or correction and its timers. */
+  private cancelReveal;
+  /** Scrolls the focused text control so that its bottom plus the margin clears the keyboard top. */
+  private reveal;
+  /** How far the scroller must scroll for the focused text control to clear the keyboard; 0 when
+   * nothing needs revealing. */
+  private revealDelta;
+  private scrollReveal;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfKeyboardAssistDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfKeyboardAssistDirective, "[bfKeyboardAssist]", never, {
+    "bfKeyboardAssist": {
+      "alias": "bfKeyboardAssist";
+      "required": false;
+      "isSignal": true;
+    };
+    "bfKeyboardAssistMargin": {
+      "alias": "bfKeyboardAssistMargin";
+      "required": false;
+      "isSignal": true;
+    };
+    "bfKeyboardAssistBehavior": {
+      "alias": "bfKeyboardAssistBehavior";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Android-style edge stretch for a scroll container: a vertical touch drag past the top or bottom
+ * edge scales the container's first element child (the content body) up along the y axis from
+ * that edge — `scaleY(1 + 0.14 × (1 − e^(−pull / 240)))` — and springs it back on release (220 ms,
+ * the settle curve; instant under `prefers-reduced-motion`). Touch only, with passive listeners:
+ * it never prevents a touch, so scrolling is untouched. It follows the finger that started the
+ * gesture and ignores any other. A horizontal-dominant gesture (decided after 8 px) is ignored,
+ * and the top edge is left alone while an active `bf-refresher` (`[data-bf-refresher]`) inside
+ * the container owns the top pull. `bf-content` applies it to its
+ * scroller in Material mode, where the WebView draws no overscroll effect of its own.
+ *
+ * @example
+ * <div class="h-full overflow-y-auto" bfOverscrollStretch>
+ *   <div>…</div>
+ * </div>
+ * @category Navigation
+ * @since 0.2.0
+ * @summary Android-style stretch of a scroll container dragged past its top or bottom edge
+ */
+export declare class BfOverscrollStretchDirective {
+  /** Enables the stretch; false leaves the container inert. */
+  readonly bfOverscrollStretch: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly host;
+  private readonly document;
+  private gesture;
+  private settle;
+  constructor();
+  private readonly onTouchStart;
+  private readonly onTouchMove;
+  private readonly onTouchEnd;
+  private apply;
+  private stopSettle;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfOverscrollStretchDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BfOverscrollStretchDirective, "[bfOverscrollStretch]", never, {
+    "bfOverscrollStretch": {
+      "alias": "bfOverscrollStretch";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * The page header: a persistent bar (`start` | title | `end`) and, with `largeTitle` (the
+ * default), the Meadow Sage large title below it that collapses into the bar's title as the
+ * page's `bf-content` scrolls. The bar follows the shell mode (`provideBfShell({ mode })`, the
+ * platform's for `'auto'`): iOS, at least 44 px with a semibold title centred on the bar whatever
+ * the slots hold (symmetric insets of the wider slot's width plus 8 px, measured with a
+ * `ResizeObserver`); Material, at least 64 px with a regular title leading after the `start` slot.
+ * The bar grows with its content at large text sizes: the title wraps to at most two lines (the
+ * bar is never shorter than the measured title, `--bf-header-title-height`), the `start` slot may
+ * shrink (a back button drops its text before its chevron; in iOS mode capped by
+ * `--bf-header-start-max` so the centred title keeps up to half the bar) and the `end` slot never
+ * does. At
+ * compact heights (`(max-height: 500px)`, phone landscape) it renders no large title: the title is
+ * the bar's `h1`, the bar is 44 px in both modes and nothing collapses. Once content scrolls under
+ * it (the large title fully collapsed; without one, `scrollTop > 0`, overscroll excluded) the
+ * host gets `data-bf-scrolled`: iOS turns translucent with a blur and a 1 px hairline, Material
+ * takes a tonal tint. Reads its sibling scroller through the page's `BfPageContext` (set by
+ * `bf-content`) and, from a passive scroll listener, writes `--bf-header-progress` (0…1, over the
+ * large title block's rendered height, bounded to 44–200 px (a taller title collapses faster), of the scroll position clamped to the
+ * scrollable range, so overscroll never moves it, and 0 on a page that cannot scroll that far) on
+ * its host and the large title block's height (its natural height, measured once and on resize,
+ * times `1 − progress`), so at progress 1 the header is exactly the toolbar; scrolling schedules
+ * no Angular change detection. Solid, it also writes the collapsed height as
+ * `--bf-header-collapse` on the scroller, which `bf-content` adds to its bottom padding: the
+ * scroller grows by what the header gives up, so its scroll range stays the same through the
+ * collapse and the short-page rule reads one stable value. When a scroll ends part-way
+ * (`scrollend`, or 120 ms without a `scroll` event) with nothing pressed on the scroller, it snaps
+ * the scroller to fully expanded or fully collapsed, whichever is nearer, like UIKit. Solid
+ * (default), it sits in the page's flow above the content; `translucent`, it is drawn over the
+ * content and `bf-content` pads its scroller by the header's height (`--bf-header-height`).
+ *
+ * @example
+ * <bf-header title="Today" subtitle="Wed, 23 Sep">
+ *   <bf-icon-button bfSlot="end" variant="text" label="Profile">
+ *     <bf-icon [icon]="userIcon" />
+ *   </bf-icon-button>
+ * </bf-header>
+ * @summary Page header toolbar with a large title that collapses into the toolbar on scroll
+ * @category Navigation
+ * @since 0.2.0
+ * @slot start Toolbar buttons at the start, such as `bf-back-button`.
+ * @slot default The toolbar title, when the `title` input is empty.
+ * @slot end Toolbar buttons at the end.
+ */
+export declare class BfHeaderComponent {
+  /** The page title, rendered in the toolbar and, with `largeTitle`, in the large title block. */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Eyebrow line above the large title (e.g. a date); rendered only with `largeTitle`. */
+  readonly subtitle: import("@angular/core").InputSignal<string>;
+  /**
+   * Renders the collapsing large title block below the toolbar; never at compact heights
+   * (`(max-height: 500px)`), where the title is the bar's `h1`.
+   */
+  readonly largeTitle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Draws the header over the content (`absolute`) instead of in the page's flow, so content
+   * scrolls under its scroll-under surface; `bf-content` pads its scroller by the header's height.
+   */
+  readonly translucent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly host;
+  private readonly pageContext;
+  /** The status-bar band, unless the page sits below the status bar already (a page-sheet modal). */
+  protected readonly toolbarClasses: import("@angular/core").Signal<"" | "pt-safe-top">;
+  private readonly keyboard;
+  private readonly document;
+  private readonly toolbar;
+  private readonly startSlot;
+  private readonly endSlot;
+  private readonly largeClip;
+  private readonly largeBlock;
+  private readonly titleText;
+  private readonly titleSizer;
+  /**
+   * True at compact heights (`(max-height: 500px)`: phone landscape, split screen), read with
+   * `matchMedia` and followed live: no large title, the title in the bar, a 44 px bar.
+   */
+  protected readonly compact: import("@angular/core").WritableSignal<boolean>;
+  /** Whether the large title block renders: `largeTitle`, except at compact heights. */
+  protected readonly showLarge: import("@angular/core").Signal<boolean>;
+  /** The shell mode (`provideBfShell({ mode })`, or the platform's for `'auto'`), fixed per header. */
+  protected readonly mode: BfShellMode;
+  protected readonly barClasses: import("@angular/core").Signal<string>;
+  protected readonly titleBoxClasses: string;
+  protected readonly titleTextClasses: string;
+  protected readonly startSlotClasses: string;
+  protected readonly largeBlockClasses = "bf-large px-gutter pb-2 opacity-[calc(1_-_var(--bf-header-progress,0))] motion-safe:-translate-y-[calc(var(--bf-header-progress,0)_*_8px)]";
+  protected readonly largeTitleClasses = "text-display text-[length:min(var(--text-display),80px)] leading-[min(var(--text-display--line-height),88px)] wrap-anywhere";
+  protected readonly hostClasses: import("@angular/core").Signal<string>;
+  /** Last written progress (0…1). */
+  private progress;
+  /** Natural height of the large title block, 0 until measured (or without one). */
+  private largeHeight;
+  /** The scroller `--bf-header-collapse` was last written on, so it can be cleared again. */
+  private compensated;
+  constructor();
+  /**
+   * The iOS `start` slot's cap (px), or `null` when the title fits on one line beside the slots
+   * at their full width. A back button's text (`[data-bf-back-text]`) is the only part that gives
+   * way: the cap is at least the slot's width with every back text gone (down to the button's own
+   * minimum width) and at least one 44 px hit area.
+   * @param width The bar's width.
+   * @param titleWidth The title's one-line width.
+   * @param start The start slot.
+   * @param end The end slot.
+   */
+  private startCap;
+  /**
+   * The scroll distance (px) over which the large title collapses: its block's rendered height
+   * (the eyebrow, the wrapped title and its bottom padding), so the collapse ends exactly when the
+   * title has scrolled away, bounded to 44–200 px (a taller title collapses its whole height over
+   * 200 px, so faster than it scrolls); 56 px until it is measured.
+   */
+  private collapseRange;
+  /**
+   * Collapses the large title block's height with the progress, so the header ends at exactly the
+   * toolbar (left at its natural (auto) height until measured), and writes the height it gave up
+   * as `--bf-header-collapse` on the page's scroller (`0px` at rest). Solid, the header is in the
+   * page's column, so the scroller grows by that much and `bf-content` pads its bottom by the same
+   * amount, keeping the scroll range constant; translucent, the header is drawn over the scroller,
+   * which never resizes, so the compensation stays `0px`.
+   */
+  private applyCollapse;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfHeaderComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfHeaderComponent, "bf-header", never, {
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "subtitle": {
+      "alias": "subtitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "largeTitle": {
+      "alias": "largeTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "translucent": {
+      "alias": "translucent";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[bfSlot=start]", "*", "[bfSlot=end]", "*"], true, never>;
+}
+/**
+ * The payload of `bf-refresher`'s `refreshRequested` output: call `complete()` once the reload is
+ * done to animate the disc away.
+ *
+ * @summary What a pull-to-refresh request carries: the callback that ends the refresh
+ * @since 0.3.0
+ */
+interface BfRefresherRefreshEvent {
+  /** Ends the refresh: animates the disc away and resets the refresher. */
+  complete: () => void;
+}
+/**
+ * Pull-to-refresh, placed as the first child of `bf-content`. It tracks Pointer Events on the
+ * page's scroller (read from `BfPageContext`, or its nearest scrolling ancestor when used without one)
+ * only while the scroller is at `scrollTop === 0`: the disc resists the pull (half the pointer's
+ * travel, capped) from a resting position above the clipped content to a 64 px threshold, ticks
+ * `BfHapticsService.impact('light')` once on crossing it, and on release past the threshold
+ * parks at the top with a spinner and emits `refreshRequested` — call `complete()` on the event to animate
+ * the disc away and reset. A press by itself changes nothing: only once a pointermove clears an
+ * 8 px downward slop (out-vertical'ing any horizontal travel) does it claim the gesture and
+ * capture the pointer on the scroller, so a plain click on the content underneath (a row, a
+ * button) still reaches it. For touch, a non-passive `touchmove` guard (attached only while a
+ * press is tracked) keeps the browser from taking a downward drag at the top as a pan, which
+ * would cancel the pointer stream; upward drags still scroll the list. The disc itself is
+ * `aria-hidden`; a permanent, visually hidden `role="status"` region announces
+ * `provideBfLabels()`'s `refreshing` ("Refreshing"). `prefers-reduced-motion` still follows the
+ * pointer 1:1 during the pull (direct manipulation is not motion); only the settle, park and `complete()` animations
+ * become instant.
+ *
+ * That pull is the Material (and mouse/pen) mode. A touch in iOS mode (`BfPlatformService.mode()`)
+ * is the bounce mode instead: the refresher claims nothing (no capture, no `preventDefault`, no
+ * guard), the scroller rubber-bands natively, and while the finger is down a negative `scrollTop`
+ * shows the disc inside the gap the bounce opens, at its resting −48 px, with opacity and scale
+ * (0.6 → 1) following `−scrollTop / 64` once it passes 8 px; one light haptic at 64 px. Lifting the
+ * finger at 64 px or more parks the disc and emits `refreshRequested`, like `UIRefreshControl`; a bounce
+ * with no finger down (a fling's overshoot) never shows it. The host carries `data-bf-refresher`
+ * while enabled, so `bfOverscrollStretch` leaves the top edge to it.
+ *
+ * @example
+ * <bf-content>
+ *   <bf-refresher (refreshRequested)="reload($event.complete)" />
+ *   <bf-list>…</bf-list>
+ * </bf-content>
+ * @summary Pull-to-refresh indicator with haptic feedback, native iOS bounce and an Android-style pull
+ * @category Navigation
+ * @since 0.2.0
+ */
+export declare class BfRefresherComponent implements AfterViewInit {
+  /** Disables pull tracking; the disc never moves and `refreshRequested` never emits. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted when a pull past the threshold is released; call `complete()` to end it. */
+  readonly refreshRequested: import("@angular/core").OutputEmitterRef<BfRefresherRefreshEvent>;
+  /**
+   * Emitted with the same event as `refreshRequested`, together with it.
+   * @deprecated 0.3.0 use refreshRequested; removed in 0.4.0
+   */
+  readonly refresh: import("@angular/core").OutputEmitterRef<BfRefresherRefreshEvent>;
+  private readonly host;
+  private readonly disc;
+  private readonly pageContext;
+  private readonly haptics;
+  protected readonly labels: import("@bitforgehq/ui").BfLabels;
+  private readonly document;
+  private readonly platform;
+  private readonly ios;
+  private readonly refreshingState;
+  /** True from the moment a completed pull is released until `complete()` is called. */
+  readonly refreshing: import("@angular/core").Signal<boolean>;
+  private scroller;
+  private gesture;
+  private settleAnimation;
+  private currentOffset;
+  /** A finger is on the scroller (tracked in iOS mode only). */
+  private touchActive;
+  private bounce;
+  constructor();
+  /** Paints the disc's resting, hidden transform once the view exists (no template `style`). */
+  ngAfterViewInit(): void;
+  /** Emits one refresh event on `refreshRequested` and the deprecated `refresh`. */
+  private requestRefresh;
+  /** Ends a refresh: animates the disc away (skipped under reduced motion) and resets state. */
+  complete(): void;
+  private readonly onPointerDown;
+  private readonly onTouchStart;
+  /**
+   * While a finger is down, a negative `scrollTop` is WebKit's rubber band at the top: the disc,
+   * which sits in the content above its top edge, shows in the gap the bounce opens. Direct
+   * manipulation (styles set straight from the scroll position, no animation).
+   */
+  private readonly onBounceScroll;
+  private readonly onTouchEnd;
+  private endBounce;
+  private hideBounceDisc;
+  /**
+   * Non-passive `touchmove` guard, attached only while a press is tracked (the pattern of the
+   * stack outlet's swipe guard). The scroller is `touch-pan-y`, so without it the browser takes a
+   * downward drag as a pan and ends the pointer stream with `pointercancel`. It prevents a
+   * cancelable move once the pull is claimed, or — before the claim — a downward-dominant move
+   * while the scroller is at the top, where a pan has nothing to scroll anyway. Upward and
+   * horizontal drags are left alone, so the list (and any horizontal scroller) keeps its pan.
+   */
+  private readonly touchMoveGuard;
+  /**
+   * A touch pointer is implicitly captured by the element under the finger; claiming it for the
+   * scroller makes that child fire its own `lostpointercapture`, which bubbles here. Only the
+   * scroller losing the capture it took ends the pull.
+   */
+  private readonly onLostPointerCapture;
+  private readonly onPointerMove;
+  private readonly onPointerUp;
+  private readonly onPointerCancel;
+  private endGesture;
+  private removeDragListeners;
+  private setOffset;
+  private settleTo;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfRefresherComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfRefresherComponent, "bf-refresher", never, {
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "refreshRequested": "refreshRequested";
+    "refresh": "refresh";
+  }, never, never, true, never>;
+}
+/**
+ * What `bf-tabs` tells the `bf-stack-outlet` inside it: which tab a URL belongs to. The outlet
+ * keeps one stack per tab key and switches stacks when a navigation lands on another key.
+ *
+ * @since 0.2.0
+ * @summary What the tabs page tells its stack outlet: which tab a URL belongs to
+ */
+interface BfTabContext {
+  /** The active tab's key (the URL segment after the tabs route), or null outside the tabs. */
+  readonly tabKey: Signal<string | null>;
+  /**
+   * The tab key of `url` (query and fragment ignored), or null when it is not under the tabs route.
+   * @param url The URL to read.
+   */
+  keyOf(url: string): string | null;
+}
+/**
+ * Provided by `bf-tabs`; injected optionally by `bf-stack-outlet`.
+ *
+ * @summary Injection token through which the tabs page tells its outlet about the tabs
+ * @since 0.2.0
+ */
+export declare const BF_TAB_CONTEXT: InjectionToken<BfTabContext>;
+/**
+ * The tabs page of a mobile app: one navigation stack per tab. It wraps a `bf-stack-outlet`, which
+ * keeps a separate stack for every tab (keyed by the URL segment after `tabsPath`), and a
+ * `bf-tab-bar`, which it drives through `BF_TAB_BAR_CONTROLLER`: the bar shows the tab of the
+ * in-flight navigation's target, else of the current URL, and hides while the keyboard is open,
+ * without anything writing into it. Selecting another tab brings
+ * that tab back as it was left; re-selecting the active tab pops its stack to the root, or scrolls
+ * its content to the top when it is already there. The bar hides while the soft keyboard is open
+ * or about to open (a focused text control), and `--bf-tab-bar-inset` on the host tells
+ * `bf-content` how much to pad its bottom (the bar's measured height, a `ResizeObserver` on its
+ * `nav`, plus its bottom offset and 8 px; 64 px for the height until it is measured); the same value is mirrored on `<html>` as
+ * `--bf-tab-bar-inset-global` for overlays (the toast), which render outside the host. It is removed when the tabs are destroyed.
+ * It also provides `BF_TAB_LINKS`, so the projected bar is a `nav` of links to each tab's root URL
+ * (`aria-current` on the active one: `page` at the tab's root, `true` on a child page of it)
+ * instead of a `tablist`.
+ *
+ * @example
+ * <bf-tabs tabsPath="tabs">
+ *   <bf-stack-outlet />
+ *   <bf-tab-bar>
+ *     <bf-tab id="today" label="Today"><bf-icon [icon]="Sun" /></bf-tab>
+ *     <bf-tab id="me" label="Me"><bf-icon [icon]="User" /></bf-tab>
+ *   </bf-tab-bar>
+ * </bf-tabs>
+ * @summary Tabs page with one navigation stack per tab, wiring the tab bar to the router
+ * @category Navigation
+ * @since 0.2.0
+ * @slot default The tabs page body: a `bf-stack-outlet` and a `bf-tab-bar`.
+ */
+export declare class BfTabsComponent implements BfTabContext, BfTabBarController {
+  /** Route path of the tabs page (e.g. `'tabs'`); the URL segment after it is the tab key. */
+  readonly tabsPath: import("@angular/core").InputSignal<string>;
+  private readonly router;
+  private readonly nav;
+  private readonly haptics;
+  private readonly keyboard;
+  private readonly platform;
+  private readonly config;
+  private readonly host;
+  private readonly document;
+  private readonly overlays;
+  private readonly locationStrategy;
+  private readonly bar;
+  private readonly barHost;
+  /** The bar's measured height (px), `null` until its `nav` is first measured. */
+  private readonly barHeight;
+  private readonly outlet;
+  /** The settled URL: the last successful navigation's (after redirects), else the router's. */
+  private readonly url;
+  /** The active tab's key, from the router URL; null while the URL is not under `tabsPath`. */
+  readonly tabKey: Signal<string | null>;
+  /**
+   * The tab the bar shows: the in-flight navigation's target (after redirects once they are
+   * applied), else the settled URL's. A refused or cancelled navigation ends, so the bar drops
+   * back to the settled tab by itself. While neither is under `tabsPath` (a page pushed above the
+   * tabs page) it keeps the last tab it showed.
+   */
+  private readonly currentTab;
+  /** The tab the bar shows (read-only): the in-flight navigation's target, else the current URL's;
+   * null when unknown. */
+  readonly current: Signal<string | null>;
+  /** Hide the bar while the keyboard is open or about to open (a focused text control: on Android
+   * the WebView shrinks before will-show and would lift the fixed bar above the keyboard). */
+  readonly hidden: Signal<boolean>;
+  /** The bar hides animated on iOS, instantly on Android and the web. */
+  readonly hideTransition: Signal<boolean>;
+  constructor();
+  /**
+   * The tab key of `url`: the primary segment after `tabsPath`. Query, fragment, matrix params and
+   * auxiliary routes (`(popup:…)`) are ignored.
+   * @param url The URL to read.
+   */
+  keyOf(url: string): string | null;
+  /** `keyOf` for a parsed URL. */
+  private keyOfTree;
+  /**
+   * The URL of tab `id`'s root page (`/tabs/<id>`, with the app's base href), the `href` of its
+   * link in the bar: a new browser tab opens the tab's root. A plain click still restores the page
+   * the tab was left on.
+   * @param id The `id` of the tab.
+   */
+  href(id: string): string;
+  /**
+   * Whether the current URL is tab `id`'s root page (`…/<tabsPath>/<id>` with nothing after it,
+   * ignoring query, fragment and auxiliary routes); reactive through the router's signals.
+   * @param id The `id` of the tab.
+   */
+  isRoot(id: string): boolean;
+  /** The non-empty segments of `tabsPath`; empty when the tabs are mounted at the root URL. */
+  private baseSegments;
+  /**
+   * Another tab, selected by the user in the bar: go back to where that tab was left (its stack's
+   * top page), or its root. The bar shows the target while the navigation is in flight and drops
+   * back by itself when a guard refuses it.
+   * @param id The `id` of the selected tab.
+   */
+  select(id: string): void;
+  /**
+   * The active tab again: pop its stack back to its existing root page (a history step), or
+   * replace the stack with the root when the history position is unknown; at the root, scroll its
+   * content to the top.
+   * @param id The `id` of the active tab.
+   */
+  reselect(id: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfTabsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfTabsComponent, "bf-tabs", never, {
+    "tabsPath": {
+      "alias": "tabsPath";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, ["bar", "barHost", "outlet"], ["*"], true, never>;
+}
+/** @deprecated 0.3.0 use BF_OVERLAY_DATA from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const BF_OVERLAY_DATA: import("@angular/core").InjectionToken<unknown>;
+/** @deprecated 0.3.0 use BfOverlayRef from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const BfOverlayRef: typeof core.BfOverlayRef;
+/** @deprecated 0.3.0 use BfOverlayRef from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export type BfOverlayRef<T = unknown> = core.BfOverlayRef<T>;
+/** @deprecated 0.3.0 use BfComponentOverlayRef from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const BfComponentOverlayRef: typeof core.BfComponentOverlayRef;
+/** @deprecated 0.3.0 use BfComponentOverlayRef from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export type BfComponentOverlayRef<C, T = unknown> = core.BfComponentOverlayRef<C, T>;
+/** @deprecated 0.3.0 use BfOverlayStack from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const BfOverlayStack: typeof core.BfOverlayStack;
+/** @deprecated 0.3.0 use BfOverlayStack from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export type BfOverlayStack = core.BfOverlayStack;
+/** @deprecated 0.3.0 use BfOverlayStackOptions from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+type BfOverlayStackOptions = core.BfOverlayStackOptions;
+/** @deprecated 0.3.0 use BfStackedOverlay from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+type BfStackedOverlay = core.BfStackedOverlay;
+/** @deprecated 0.3.0 use BfOverlayService from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const BfOverlayService: typeof core.BfOverlayService;
+/** @deprecated 0.3.0 use BfOverlayService from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export type BfOverlayService = core.BfOverlayService;
+/** @deprecated 0.3.0 use BfOverlayOptions from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+type BfOverlayOptions = core.BfOverlayOptions;
+/** @deprecated 0.3.0 use BfOverlayPosition from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+type BfOverlayPosition = core.BfOverlayPosition;
+/** @deprecated 0.3.0 use BfOverlayTemplateContext from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+type BfOverlayTemplateContext = core.BfOverlayTemplateContext;
+/** @deprecated 0.3.0 use OVERLAY_DURATION from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const OVERLAY_DURATION = 260;
+/** @deprecated 0.3.0 use OVERLAY_EASING from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const OVERLAY_EASING = "cubic-bezier(0.32, 0.72, 0, 1)";
+/** @deprecated 0.3.0 use fadeDown from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const fadeDown: typeof core.fadeDown;
+/** @deprecated 0.3.0 use fadeIn from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const fadeIn: typeof core.fadeIn;
+/** @deprecated 0.3.0 use fadeOut from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const fadeOut: typeof core.fadeOut;
+/** @deprecated 0.3.0 use fadeUp from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const fadeUp: typeof core.fadeUp;
+/** @deprecated 0.3.0 use scaleIn from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const scaleIn: typeof core.scaleIn;
+/** @deprecated 0.3.0 use slideDown from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const slideDown: typeof core.slideDown;
+/** @deprecated 0.3.0 use slideUp from '@bitforgehq/ui/overlay'; removed in 0.4.0 */
+export declare const slideUp: typeof core.slideUp;
+/** What `BfSheetService` does for a sheet ref; internal. */
+interface BfSheetController extends BfOverlayController {
+  /** True while the underlying overlay is closing (backdrop, `Escape`, back button, drag). */
+  isClosing(): boolean;
+}
+/**
+ * Handle to an open bottom sheet, returned by `BfSheetService.open()` and injectable in the
+ * sheet's content as `BfSheetRef` (and as `BfOverlayRef`). On top of `close(result)` and
+ * `afterClosed` it moves the sheet between its snap points: `snapTo(index)` animates to a point
+ * and `snapIndex()` tracks the current one (also after a drag).
+ *
+ * @example
+ * const ref = sheets.open(FiltersComponent, { snapPoints: [0.4, 0.9] });
+ * ref.snapTo(1);
+ * const filters = await ref.afterClosed;
+ * @since 0.2.0
+ * @summary Handle on an open bottom sheet that moves it between snap points and closes it
+ */
+export declare class BfSheetRef<T = unknown> extends BfOverlayRef$1<T> {
+  private readonly sheetController;
+  private readonly snapIndexState;
+  /** Index of the snap point the sheet rests at (or is settling to). */
+  readonly snapIndex: Signal<number>;
+  private snapHandler;
+  constructor(sheetController: BfSheetController, initialIndex?: number);
+  /** True from the first close on, whichever way the sheet is being closed. */
+  get isClosing(): boolean;
+  /**
+   * Animates the sheet to the snap point at `index` (clamped to the configured points).
+   * @param index The position of the snap point in `snapPoints`.
+   */
+  snapTo(index: number): void;
+  /** @internal Connects the `bf-sheet` container that performs `snapTo`. */
+  connect(handler: (index: number) => void): void;
+  /** @internal Set by `bf-sheet` whenever the sheet settles on a snap point. */
+  setSnapIndex(index: number): void;
+}
+/** What `BfSheetService` hands the `bf-sheet` container (as its `BF_OVERLAY_DATA`); internal. */
+interface BfSheetConfig {
+  content: Type<unknown> | TemplateRef<unknown>;
+  /** Ascending fractions of the viewport height. */
+  snapPoints: number[];
+  initial: number;
+  dismissible: boolean;
+  /** The caller's data, re-provided to the content as `BF_OVERLAY_DATA`. */
+  data: unknown;
+  /** No `ariaLabel` was given: the panel is named by the content's first heading, if any. */
+  labelledByHeading: boolean;
+  ref: BfSheetRef<unknown>;
+}
+/**
+ * The bottom-sheet container that `BfSheetService.open()` renders on the overlay core: a
+ * bottom-anchored `bg-surface` card with a grabber, resting at snap points (fractions of the
+ * viewport height, applied as `--bf-sheet-height`) and rendering the content component or
+ * template with `BF_OVERLAY_DATA` and `BfSheetRef` injectable. Dragging the handle row, any
+ * element marked `data-bf-sheet-drag` (a header) or the content (unless it can scroll up) moves
+ * the sheet with Pointer Events under pointer capture: rubber-banded above the top point, released
+ * onto the nearest point (a fling faster than 0.3 px/ms picks the direction), and dismissed when
+ * released more than 25 % below the lowest point or flung down from it — if the sheet is
+ * dismissible. The content scrolls only at the top snap point, and at every point while the soft
+ * keyboard is up. While the keyboard overlays the sheet's bottom edge (iOS, a mobile browser) the
+ * sheet is lifted by the covered height (`translate`, its bottom safe-area padding dropped); while
+ * the keyboard is up its height is capped at the keyboard's top edge minus the safe-area top minus
+ * 8 px (a drag starts from that capped height), and the content region's `bfKeyboardAssist`
+ * scrolls the focused control 24 px clear of the keyboard. The lift follows the keyboard (250 ms,
+ * instant under `prefers-reduced-motion`). Hiding the keyboard restores the snap height at once
+ * (the drop is instant, so the top edge stays on screen) and scrolls content left scrolled below
+ * the top point back to its top. With two or more snap points the grabber is a button: a press,
+ * `Enter` or `Space` moves one point up (from the top point back to the lowest), the arrow keys
+ * step, `Home` and `End` jump; it is named `expand` or `collapse` (`BF_LABELS`) after the next
+ * press, then `sheetPosition`, and every settle on another point announces `sheetPosition`
+ * politely. A dismissible sheet starts with a visually hidden Close (`BF_LABELS.close`) that screen
+ * readers reach and a keyboard user sees when focused. Not used directly in templates.
+ *
+ * @example
+ * const ref = inject(BfSheetService).open(NewTaskComponent, { snapPoints: [0.5, 0.92] });
+ * @summary Bottom sheet with snap points, drag to dismiss and a backdrop
+ * @category Overlays
+ * @since 0.2.0
+ */
+export declare class BfSheetComponent {
+  private readonly config;
+  private readonly host;
+  private readonly document;
+  private readonly keyboard;
+  private readonly keyboardCover;
+  private readonly contentElement;
+  private readonly contentAssist;
+  protected readonly template: TemplateRef<unknown> | null;
+  protected readonly component: Type<unknown> | null;
+  protected readonly contentInjector: import("@angular/core").DestroyableInjector;
+  protected readonly templateContext: BfOverlayTemplateContext$1;
+  private readonly lastIndex;
+  protected readonly labels: import("@bitforgehq/ui").BfLabels;
+  protected readonly dismissible: boolean;
+  /** Two or more snap points: the grabber is a button that moves between them. */
+  protected readonly adjustable: boolean;
+  private readonly announcer;
+  /**
+   * What the next press does (collapse at the top point, else expand), then where the sheet is:
+   * "Expand, Sheet at 1 of 2".
+   */
+  protected readonly grabberLabel: import("@angular/core").Signal<string>;
+  /** A drag that started on the grabber button ends without the click that may follow it. */
+  private suppressGrabberClick;
+  /**
+   * The content scrolls at the top snap point and whenever the keyboard is up (the sheet may be
+   * capped below its content); otherwise drags move the sheet.
+   */
+  private readonly contentScrolls;
+  protected readonly contentClass: import("@angular/core").Signal<string>;
+  private index;
+  /** Rendered height (px) and downward translation (px) below the lowest point. */
+  private height;
+  private offset;
+  private gesture;
+  private settleAnimation;
+  constructor();
+  /**
+   * Lifts the sheet by the part of the viewport the keyboard covers and caps its height at the
+   * keyboard's top edge; both go away with the keyboard, at once. Separate from
+   * `--bf-sheet-height`, so drag and snap logic never see them.
+   */
+  private applyKeyboard;
+  /** The content's keyboard assist measured a sheet still sliding up: it measures once more. */
+  private readonly onTransitionEnd;
+  protected close(): void;
+  /**
+   * A press: one point higher, or from the top point back to the lowest. The click a pointer drag
+   * may leave behind is swallowed; a keyboard or assistive-technology click (`detail` 0) never is.
+   */
+  protected onGrabberClick(event: MouseEvent): void;
+  /** Arrow keys step between points (never past the ends, never dismissing); Home and End jump. */
+  protected onGrabberKeydown(event: KeyboardEvent): void;
+  private snapTo;
+  /** Viewport height with the keyboard hidden: the `100lvh` probe, else `innerHeight`. */
+  private viewportHeight;
+  private heights;
+  private readonly onResize;
+  private readonly onPointerDown;
+  /**
+   * Whether a content drag may move the sheet: always while the content does not scroll (below the
+   * top snap point, keyboard hidden), and otherwise only downward while it is scrolled to 0.
+   */
+  private contentMayDrag;
+  /**
+   * Non-passive `touchmove` guard, attached only while a press is tracked (the refresher's
+   * pattern): keeps the browser from taking the drag as a pan, which would end the pointer stream
+   * with `pointercancel`. Content drags the sheet does not want (upward at the top point,
+   * horizontal) are left to scroll.
+   */
+  private readonly touchMoveGuard;
+  private readonly onPointerMove;
+  /** Renders a proposed visible height: rubber-banded past the ends, translated below the lowest. */
+  private show;
+  private readonly onPointerUp;
+  private readonly onPointerCancel;
+  /** Only the host losing the capture it took ends the drag (a child's implicit capture bubbles). */
+  private readonly onLostPointerCapture;
+  /** Downward velocity (px/ms) over the last samples; 0 when they carry no elapsed time. */
+  private velocity;
+  private release;
+  private nearest;
+  /** Animates (instantly under reduced motion) to the snap point at `index`. */
+  private settleTo;
+  /**
+   * The height the sheet shows: its snap height, or less while the keyboard caps it (`max-height`),
+   * so a drag of a capped sheet moves it from the first pixel.
+   */
+  private renderedHeight;
+  /** A press during a settle continues from where the animation had got to. */
+  private captureAnimatedHeight;
+  private apply;
+  private endGesture;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfSheetComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfSheetComponent, "bf-sheet", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Where focus goes when a sheet opens: the sheet itself (`panel`), so no soft keyboard comes up
+ * and a screen reader starts reading at the sheet, or its first field (`first-field`): the element
+ * marked `[autofocus]`/`[cdkFocusInitial]`, else the first focusable element of the content, which
+ * raises the keyboard on Android when it is a text field.
+ *
+ * @summary Where focus lands when a sheet opens, the sheet itself or its first field
+ * @since 0.3.0
+ */
+type BfSheetAutoFocus = 'panel' | 'first-field';
+/**
+ * Options of `BfSheetService.open()`.
+ *
+ * @summary Options of a bottom sheet: where it rests, how it closes and its name
+ * @since 0.2.0
+ */
+interface BfSheetOptions {
+  /**
+   * Heights the sheet rests at, as fractions of the viewport height (default `[0.5, 0.92]`).
+   * @default [0.5, 0.92]
+   */
+  snapPoints?: number[];
+  /**
+   * Index of the snap point the sheet opens at (default 0).
+   * @default 0
+   */
+  initial?: number;
+  /**
+   * The backdrop, `Escape`, the hardware back button and a downward drag close the sheet
+   * (default true). When false only `close()` does, or a navigation (see `closeOnNavigation`).
+   * @default true
+   */
+  dismissible?: boolean;
+  /** Injected into the content as `BF_OVERLAY_DATA`. */
+  data?: unknown;
+  /**
+   * A navigation to another URL path (a pushed or popped page, a tab switch) closes the sheet with
+   * no result (default true), also a non-dismissible one.
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /**
+   * Accessible name of the sheet. Without it the sheet is named by the first heading in its
+   * content (`aria-labelledby`), else by `provideBfLabels()`'s `sheet` ("Sheet").
+   */
+  ariaLabel?: string;
+  /**
+   * Where focus goes on open: `panel` (default) focuses the sheet itself (a `role="dialog"` with a
+   * name and `tabindex="-1"`), so a screen reader lands inside it and no soft keyboard hides it;
+   * `first-field` focuses the element marked `[autofocus]`/`[cdkFocusInitial]`, else the first
+   * focusable element of the content (never the sheet's own Close and grabber), which raises the
+   * keyboard on Android when it is a text field.
+   * @default 'panel'
+   */
+  autoFocus?: BfSheetAutoFocus;
+  /**
+   * Injector the sheet resolves its labels (`BF_LABELS`) from and the parent of its content's
+   * injector (default the root injector). Pass the opening component's `inject(Injector)` so a
+   * feature-level `provideBfLabels()` and other feature providers reach it.
+   */
+  injector?: Injector;
+}
+/**
+ * Snap points used when none (or no valid ones) are given.
+ *
+ * @summary The snap points a bottom sheet rests at when none are given, half and full
+ * @since 0.2.0
+ */
+export declare const BF_SHEET_DEFAULT_SNAP_POINTS: readonly number[];
+/**
+ * Opens bottom sheets: a component or template in a `bf-sheet` container on the overlay core,
+ * bottom-anchored over a backdrop, resting at snap points (fractions of the viewport height).
+ * The content injects `BF_OVERLAY_DATA` and `BfSheetRef` (also as `BfOverlayRef`) to read its
+ * data, move between snap points and close with a result. A dismissible sheet (the default)
+ * closes on a backdrop tap, `Escape`, the hardware back button and a drag below its lowest
+ * point; a non-dismissible one only through `close()`, and swallows the back button while open.
+ * A navigation to another URL path closes either (`closeOnNavigation`). On open, focus goes to the
+ * sheet itself, so no soft keyboard comes up (`autoFocus: 'first-field'` focuses the first field).
+ *
+ * @example
+ * const ref = inject(BfSheetService).open<NewTaskComponent, Task>(NewTaskComponent, {
+ *   snapPoints: [0.5, 0.92],
+ *   data: { listId },
+ * });
+ * const task = await ref.afterClosed;
+ * @since 0.2.0
+ * @summary Opens bottom sheets that rest at snap points and close with a result
+ */
+export declare class BfSheetService {
+  private readonly overlays;
+  private readonly stack;
+  private readonly backButton;
+  private readonly injector;
+  /**
+   * Opens `content` (a component or a template) in a bottom sheet.
+   * @param content The component or template to render in the sheet.
+   * @param options Where the sheet rests, how it closes and its name.
+   */
+  open<C, T = unknown>(content: Type<C> | TemplateRef<unknown>, options?: BfSheetOptions): BfSheetRef<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfSheetService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Where `bf-modal` sits: a page-sheet card, or edge to edge.
+ *
+ * @summary How a modal is presented: a page-sheet card over the stack, or fullscreen
+ * @since 0.2.0
+ */
+type BfModalPresentation = 'sheet' | 'fullscreen';
+/** What `BfModalService` hands the `bf-modal` container (as its `BF_OVERLAY_DATA`); internal. */
+interface BfModalConfig {
+  content: Type<unknown>;
+  presentation: BfModalPresentation;
+  /** The caller's data, re-provided to the content as `BF_OVERLAY_DATA`. */
+  data: unknown;
+  /** No `ariaLabel` was given: the panel is named by the content's first heading, if any. */
+  labelledByHeading: boolean;
+}
+/**
+ * The modal frame that `BfModalService.open()` renders on the overlay core, `position:
+ * 'fullscreen'`: a `sheet` presentation (default) is a card whose top sits 10 px below the top
+ * safe area (UIKit's page-sheet inset; `bg-bg rounded-t-card shadow-floating`) over the parked page stack, which scales down and
+ * grows rounded corners behind it (`--bf-modal-depth`, written by `BfOverlayStack`, consumed by
+ * `bf-stack-outlet`'s host rule); `fullscreen` covers the viewport edge to edge with no scale.
+ * Like `bf-page`, it provides a fresh `BfPageContext` so the content's `bf-header` and
+ * `bf-content` work inside it (with `mainLandmark` false, so its content is no `main` landmark,
+ * and in the `sheet` presentation with `safeAreaTop` false, so the header adds no status-bar band
+ * inside the card) — the content supplies its own header (typically a close
+ * `bf-icon-button` in `start`) and content region. While the soft keyboard overlays the bottom of
+ * a `sheet` card (iOS, a mobile browser), the card is padded at the bottom by the covered height,
+ * so the content's `bf-content` ends at the keyboard's top edge and its keyboard assist reveals
+ * the focused control there. Not used directly in templates.
+ *
+ * @example
+ * const ref = inject(BfModalService).open(EditTaskComponent, { data: { taskId } });
+ * @summary Modal overlay shown as an inset card over the scaled-down page, or full screen
+ * @category Overlays
+ * @since 0.2.0
+ */
+export declare class BfModalComponent {
+  protected readonly config: BfModalConfig;
+  private readonly outerRef;
+  private readonly keyboardCover;
+  protected readonly hostClasses: string;
+  /** A sheet card ends at the keyboard's top edge; a fullscreen frame leaves it to `bf-content`. */
+  protected readonly keyboardPadding: import("@angular/core").Signal<number | null>;
+  protected readonly contentInjector: import("@angular/core").DestroyableInjector;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfModalComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfModalComponent, "bf-modal", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Options of `BfModalService.open()`.
+ *
+ * @summary Options of a modal: its data, presentation, dismissal and accessible name
+ * @since 0.2.0
+ */
+interface BfModalOptions {
+  /** Injected into the content as `BF_OVERLAY_DATA`. */
+  data?: unknown;
+  /**
+   * A page-sheet card over the parked page stack (default), or a fullscreen frame.
+   * @default 'sheet'
+   */
+  presentation?: BfModalPresentation;
+  /**
+   * `Escape` and the hardware back button close the modal (default true); with false only the
+   * content's own close control does, or a navigation (see `closeOnNavigation`), and back is
+   * swallowed while the modal is open instead of
+   * falling through to the page behind. There is no backdrop dismiss or drag-to-dismiss.
+   * @default true
+   */
+  dismissible?: boolean;
+  /**
+   * A navigation to another URL path closes the modal with no result (default true).
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /**
+   * Accessible name of the modal panel. Without it the modal is named by the first heading in
+   * its content (`aria-labelledby`, e.g. the `bf-header` title), else by `provideBfLabels()`'s
+   * `modal` ("Modal").
+   */
+  ariaLabel?: string;
+  /**
+   * Injector the modal resolves its labels (`BF_LABELS`) from and the parent of its content's
+   * injector (default the root injector). Pass the opening component's `inject(Injector)` so a
+   * feature-level `provideBfLabels()` and other feature providers reach it.
+   */
+  injector?: Injector;
+}
+/**
+ * Opens modals: a component in a `bf-modal` frame on the overlay core (`position: 'fullscreen'`,
+ * no backdrop dismiss). `presentation: 'sheet'` (default) is a page-sheet card 10 px below the
+ * top safe area over the parked page stack, which in iOS mode scales down and grows rounded corners
+ * behind it (`countsAsModal: true`, driving `--bf-modal-depth` on the registered
+ * `bf-stack-outlet` roots; Material mode leaves the page unscaled); `'fullscreen'` covers the
+ * viewport edge to edge and does not count towards that depth. iOS mode
+ * slides the card up and down; Material mode fades it up (and down) 16 px. The content supplies
+ * its own `bf-header` (`largeTitle="false"`, typically a close `bf-icon-button` in `start`) and
+ * `bf-content` — `bf-modal` provides a `BfPageContext` for them, like `bf-page`. It injects the
+ * caller's `data` as `BF_OVERLAY_DATA` and closes itself with a result through the injected
+ * `BfOverlayRef`, which `open()` also returns. A navigation to another URL path closes it with no
+ * result (`closeOnNavigation`).
+ *
+ * @example
+ * const ref = inject(BfModalService).open<EditTaskComponent, Task>(EditTaskComponent, {
+ *   data: { taskId },
+ * });
+ * const saved = await ref.afterClosed;
+ * @since 0.2.0
+ * @summary Opens a component as a modal page sheet over the stack, or fullscreen
+ */
+export declare class BfModalService {
+  private readonly overlays;
+  private readonly stack;
+  private readonly backButton;
+  private readonly platform;
+  private readonly injector;
+  private readonly config;
+  /**
+   * Opens `component` as a modal.
+   * @param component The component to render; it injects `BfOverlayRef` and `BF_OVERLAY_DATA`.
+   * @param options The modal's data, presentation, dismissal and name.
+   */
+  open<C, T = unknown>(component: Type<C>, options?: BfModalOptions): BfOverlayRef$1<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfModalService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Where the toast pill anchors in the viewport.
+ *
+ * @summary Where a mobile toast pill anchors in the viewport, at the bottom or top
+ * @since 0.2.0
+ */
+type BfToastPosition = 'bottom' | 'top';
+/** The action rendered as a real button inside the pill; internal. */
+interface BfToastActionConfig {
+  label: string;
+  run: () => void;
+}
+/** What holds a toast's timer: the pointer over it, or focus inside it; internal. */
+type BfToastHoldSource = 'pointer' | 'focus';
+/** What `BfToastService` hands the `bf-toast` container (as its `BF_OVERLAY_DATA`); internal. */
+interface BfToastConfig {
+  message: string;
+  action: BfToastActionConfig | null;
+  position: BfToastPosition;
+  /** Told when the pointer or focus enters (`held: true`) or leaves the pill; pauses the timer. */
+  hold?: (source: BfToastHoldSource, held: boolean) => void;
+  /** `Escape` pressed while focus is inside the pill; the service dismisses the toast. */
+  escape?: () => void;
+}
+/**
+ * The status pill that `BfToastService.show()` renders on the overlay core (`passive: true`, no
+ * backdrop, no focus trap, no inert page and no back handler — it never steals focus): an ink
+ * `bg-text text-bg rounded-full shadow-floating` pill holding the message (truncated to two lines)
+ * and an optional action. The pill is not a live region: the service announces each toast once
+ * through CDK `LiveAnnouncer`. The pointer over it or focus inside it pauses its timer, and
+ * `Escape` with focus inside dismisses it. `position: 'bottom'` (default) sits 16 px above the
+ * tab-bar inset (`--bf-tab-bar-inset-global`, published on `<html>` by `bf-tabs`, which leaves
+ * 8 px above the floating bar, so the toast clears it by 24 px) and the soft keyboard
+ * (`--bf-toast-keyboard` on the host: `BfKeyboardService.height()` where the keyboard overlays
+ * the WebView — native iOS — and 0 where the WebView already shrinks); `position: 'top'` sits
+ * 16 px below the status bar (a top margin of the safe-area inset plus 16 px, outside the pill)
+ * instead. Not used directly in templates.
+ *
+ * @example
+ * const ref = inject(BfToastService).show({ message: 'Saved' });
+ * @summary Passive status pill with an optional action that never steals focus
+ * @category Overlays
+ * @since 0.2.0
+ */
+export declare class BfToastComponent {
+  protected readonly config: BfToastConfig;
+  private readonly host;
+  private readonly keyboard;
+  protected readonly classes: string;
+  constructor();
+  protected hold(source: BfToastHoldSource, held: boolean): void;
+  /** Focus moving between elements inside the pill still holds it. */
+  protected focusLeft(event: Event): void;
+  /** `Escape` with focus inside dismisses the toast; claimed, so no overlay underneath sees it. */
+  protected keydown(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfToastComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfToastComponent, "bf-toast", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Options of `BfToastService.show()`.
+ *
+ * @summary Options of a mobile toast: its message, an action, its duration and position
+ * @since 0.2.0
+ */
+interface BfToastOptions {
+  /** Text of the pill, truncated to two lines. */
+  message: string;
+  /** An optional action button. */
+  action?: BfToastAction$1;
+  /**
+   * Milliseconds before the toast auto-dismisses, not counting time the pointer is over it 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;
+  /**
+   * Where the pill anchors (default `'bottom'`).
+   * @default 'bottom'
+   */
+  position?: BfToastPosition;
+}
+/**
+ * Queues status pills: `show(options)` renders `bf-toast` on the overlay core (`passive: true` —
+ * no backdrop, no focus trap, the page stays interactive, and it never counts towards
+ * `BfOverlayStack.count()`) and returns a `BfToastRef`. One toast is visible at a time; later
+ * calls queue in order and show once the current one ends. A toast auto-dismisses after
+ * `duration` ms (default 3000, resolving `'timeout'`); a toast with an action defaults to
+ * `duration: 0`, which keeps it until `dismiss()`, `Escape` inside it (`'dismiss'`) or its action
+ * button (`'action'`) ends it; such a persistent toast never blocks the queue — the next `show()`
+ * replaces it (`'dismiss'`). The timer pauses while the pointer is over the toast or focus is
+ * inside it and resumes with the remaining time. When a toast still holding focus closes, focus
+ * returns to the element focused last outside it. Each toast is announced once, politely, through
+ * CDK `LiveAnnouncer` as it shows. A navigation (a pushed or popped page, a tab switch) never
+ * closes it.
+ *
+ * @example
+ * const ref = inject(BfToastService).show({
+ *   message: 'Task deleted',
+ *   action: { label: 'Undo', handler: () => restore(task) },
+ * });
+ * const reason = await ref.afterDismissed;
+ * @since 0.2.0
+ * @summary Shows brief toast pills on phones, one at a time, queued in order
+ */
+export declare class BfToastService {
+  private readonly overlays;
+  private readonly queue;
+  /**
+   * Queues `options` as a toast; shows it now if none is visible, else once the current one ends.
+   * A persistent toast (`duration` 0, the default with an action) never blocks the queue: a later
+   * `show()` dismisses it (`'dismiss'`), whether it is visible or still waiting.
+   * @param options The toast's message, action, duration and position.
+   * @returns The toast's ref, to dismiss it or await why it ended.
+   */
+  show(options: BfToastOptions): BfToastRef$1;
+  /** Opens one passive overlay per toast, exactly as before the engine moved to `/overlay`. */
+  private present;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The role of an action sheet row: `destructive` renders it in `text-danger`, `cancel` makes it the
+ * separate cancel button.
+ *
+ * @summary The role of an action sheet row, a destructive action or the cancel button
+ * @since 0.3.0
+ */
+type BfActionSheetActionRole = 'destructive' | 'cancel';
+/**
+ * One row of an action sheet, or its cancel action when `role: 'cancel'`.
+ *
+ * @summary One row of an action sheet, or its cancel button, with its answer and role
+ * @since 0.2.0
+ */
+interface BfActionSheetAction {
+  /** What `open()` resolves with when the row is tapped (default `label`); keeps the answer
+   * stable when the label is translated or two rows share a label. Ignored on the cancel action,
+   * which always resolves `undefined`. */
+  id?: string;
+  /** Row text; also what `open()` resolves with when the row is tapped and has no `id`. */
+  label: string;
+  /** Icon rendered in the row's leading slot. */
+  icon?: IconNode;
+  /**
+   * `destructive` renders the row's label in `text-danger`; `cancel` renders it as the separate
+   * cancel button instead of a row (a plain row when omitted).
+   */
+  role?: BfActionSheetActionRole;
+}
+/** What `BfActionSheetService` hands the `bf-action-sheet` container (as its `BF_OVERLAY_DATA`); internal. */
+interface BfActionSheetConfig {
+  /** Heading above the rows, or `undefined` for none. */
+  title: string | undefined;
+  /** The caller's non-cancel actions, in order. */
+  actions: BfActionSheetAction[];
+  /** Label of the cancel button: the caller's `cancel`-role action, or "Cancel". */
+  cancelLabel: string;
+}
+/**
+ * The action sheet panel that `BfActionSheetService.open()` renders on the overlay core
+ * (`position: 'bottom'`): an optional title above a `bf-list` of interactive rows for the
+ * actions (destructive ones in `text-danger`, an icon in the leading slot) and a separate
+ * `tonal` `bf-button` for the cancel action — rendered even when the caller passes none,
+ * labelled "Cancel", which takes the initial focus. Tapping a row resolves the overlay with its
+ * `id ?? label`; the cancel button, like
+ * the backdrop, `Escape` and the hardware back button, resolves `undefined`. Not used directly
+ * in templates.
+ *
+ * @example
+ * const answer = await inject(BfActionSheetService).open({
+ *   title: 'Delete list?',
+ *   actions: [{ id: 'delete', label: 'Delete', role: 'destructive' }],
+ * });
+ * @summary Bottom panel of labelled actions with a separate cancel button, destructive ones shown in red
+ * @category Overlays
+ * @since 0.2.0
+ */
+export declare class BfActionSheetComponent {
+  protected readonly config: BfActionSheetConfig;
+  private readonly ref;
+  protected select(action: BfActionSheetAction): void;
+  protected cancel(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfActionSheetComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfActionSheetComponent, "bf-action-sheet", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Options of `BfActionSheetService.open()`.
+ *
+ * @summary Options of an action sheet: its title, its rows and when it closes
+ * @since 0.2.0
+ */
+interface BfActionSheetOptions {
+  /** Heading above the rows; also the panel's accessible name (default `provideBfLabels()`'s
+   * `actions`, "Actions"). */
+  title?: string;
+  /**
+   * Rows, in order; a `cancel`-role entry becomes the separate cancel button instead of a row.
+   * Only the first `cancel`-role entry is used; any further ones are ignored.
+   */
+  actions: BfActionSheetAction[];
+  /**
+   * A navigation to another URL path closes the sheet, resolving `undefined` (default true).
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /**
+   * Injector the action sheet resolves its labels (`BF_LABELS`) from and the parent of its content's
+   * injector (default the root injector). Pass the opening component's `inject(Injector)` so a
+   * feature-level `provideBfLabels()` and other feature providers reach it.
+   */
+  injector?: Injector;
+}
+/**
+ * Opens action sheets: a bottom-anchored list of actions on the overlay core (`position:
+ * 'bottom'`, not counted as a modal). Renders `title` above a `bf-list` of the non-cancel
+ * `actions` as interactive rows (destructive ones in `text-danger`, an icon in the leading slot
+ * from `icon`), and a separate `tonal` `bf-button` for the cancel action — the caller's
+ * first `cancel`-role entry if any (further ones are ignored), else a synthesized one labelled `provideBfLabels()`'s `cancel` ("Cancel").
+ * Focus starts on the cancel button. `open()` resolves with the tapped row's `id ?? label`; the
+ * cancel button, a backdrop tap, `Escape`, the hardware back button and a navigation to another
+ * URL path all resolve `undefined`.
+ *
+ * @example
+ * const answer = await inject(BfActionSheetService).open({
+ *   title: 'Delete list?',
+ *   actions: [
+ *     { id: 'delete', label: 'Delete', role: 'destructive' },
+ *     { id: 'rename', label: 'Rename' },
+ *   ],
+ * });
+ * @since 0.2.0
+ * @summary Opens bottom action sheets that resolve with the row the user tapped
+ */
+export declare class BfActionSheetService {
+  private readonly overlays;
+  private readonly injector;
+  /**
+   * Opens the action sheet described by `options`; resolves with the tapped row's `id ?? label`,
+   * or `undefined` when cancelled.
+   * @param options The title and rows of the sheet.
+   */
+  open(options: BfActionSheetOptions): Promise<string | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfActionSheetService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The role of an alert dialog button: `cancel` answers `Escape` and the hardware back button,
+ * `destructive` renders `danger`.
+ *
+ * @summary The role of an alert dialog button, the cancel answer or a destructive action
+ * @since 0.3.0
+ */
+type BfAlertDialogButtonRole = 'cancel' | 'destructive';
+/**
+ * A button of `BfAlertDialogService.open()`.
+ *
+ * @summary One button of an alert dialog: its answer, its label and its role
+ * @since 0.2.0
+ */
+interface BfAlertDialogButton {
+  /** What `open()` resolves with when the button is tapped (default `label`); keeps the answer
+   * stable when the label is translated or two buttons share a label. */
+  id?: string;
+  /** Button text; also the value `open()` resolves with when it is tapped and has no `id`. */
+  label: string;
+  /**
+   * `cancel` renders as a `text` button, takes the initial focus and is what `Escape`/the
+   * hardware back button answer with; `destructive` renders `danger` (a plain `primary`/`tonal` button when omitted).
+   */
+  role?: BfAlertDialogButtonRole;
+}
+/**
+ * Options of `BfAlertDialogService.open()`.
+ *
+ * @summary Options of an alert dialog: its title, message, buttons and when it closes
+ * @since 0.2.0
+ */
+interface BfAlertDialogOptions {
+  /** Dialog heading, rendered as the `h2` the panel's `aria-labelledby` points to. */
+  title: string;
+  /** Body text under the title. */
+  message?: string;
+  /** Buttons, left to right (default one button labelled `provideBfLabels()`'s `ok`, "OK"). */
+  buttons?: BfAlertDialogButton[];
+  /**
+   * A navigation to another URL path closes the alert, resolving the cancel button's answer, or
+   * `undefined` without one (default true).
+   * @default true
+   */
+  closeOnNavigation?: boolean;
+  /**
+   * Injector the dialog resolves its labels (`BF_LABELS`) from and the parent of its content's
+   * injector (default the root injector). Pass the opening component's `inject(Injector)` so a
+   * feature-level `provideBfLabels()` and other feature providers reach it.
+   */
+  injector?: Injector;
+}
+/**
+ * Opens alert dialogs: a centred, 300 px card on the overlay core (`position: 'center'`, no
+ * backdrop dismiss). Renders `title` as an `h2`, an optional `message`, and `buttons` (default
+ * one `ok` button from the app's `provideBfLabels()`, "OK") as a right-aligned row — `cancel`-role `text`, `destructive`-role
+ * `danger`, the first plain button `primary`, further plain ones `tonal`. Focus starts on the
+ * `cancel`-role button, else the first one. `open()` resolves with the tapped button's
+ * `id ?? label`. `Escape` and the hardware back button resolve with the cancel button's answer
+ * when `buttons` has one; with none, they are claimed and ignored — an alert
+ * with no cancel button can only be answered by tapping a button, or closed by a navigation to
+ * another URL path, which resolves the cancel button's answer, else `undefined`.
+ *
+ * @example
+ * const answer = await inject(BfAlertDialogService).open({
+ *   title: 'Delete list?',
+ *   message: 'This cannot be undone.',
+ *   buttons: [
+ *     { id: 'cancel', label: 'Cancel', role: 'cancel' },
+ *     { id: 'delete', label: 'Delete', role: 'destructive' },
+ *   ],
+ * });
+ * @since 0.2.0
+ * @summary Opens small centred alerts that resolve with the button the user tapped
+ */
+export declare class BfAlertDialogService {
+  private readonly overlays;
+  private readonly stack;
+  private readonly backButton;
+  private readonly injector;
+  /**
+   * Opens the alert described by `options`; resolves with the tapped button's `id ?? label`, or
+   * `undefined` when a navigation closes an alert that has no cancel button.
+   * @param options The title, message and buttons of the alert.
+   */
+  open(options: BfAlertDialogOptions): Promise<string | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfAlertDialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** A button of an alert dialog, with the variant `BfAlertDialogService` resolved for it. */
+interface BfAlertDialogButtonConfig {
+  /** Button text. */
+  label: string;
+  /** What `open()` resolves with when it is tapped: the caller's `id ?? label`. */
+  answer: string;
+  /** `cancel` answers `Escape`/the hardware back button; `destructive` renders `danger`. */
+  role?: BfAlertDialogButtonRole;
+  variant: BfButtonVariant;
+  /** Whether it takes the initial focus: the `cancel`-role button, else the first one. */
+  initial: boolean;
+}
+/** What `BfAlertDialogService` hands the `bf-alert-dialog` container (as its `BF_OVERLAY_DATA`); internal. */
+interface BfAlertDialogConfig {
+  title: string;
+  message: string | undefined;
+  /** Id of the `h2` title, referenced by the panel's `aria-labelledby`. */
+  titleId: string;
+  /** Id of the message `p`, referenced by the panel's `aria-describedby` when there is a message. */
+  messageId: string;
+  buttons: BfAlertDialogButtonConfig[];
+}
+/**
+ * The alert dialog card that `BfAlertDialogService.open()` renders on the overlay core
+ * (`position: 'center'`): an `h2.text-heading` title, an optional `text-body text-text-secondary`
+ * message, and a right-aligned row of `bf-button`s (`cancel`-role `text`, `destructive`-role
+ * `danger`, the first plain button `primary`, further plain ones `tonal`). Focus starts on the
+ * `cancel`-role button, else the first one. Tapping a button resolves the overlay with its
+ * `id ?? label`. There is no backdrop dismiss; `Escape` and the hardware
+ * back button are handled by `BfAlertDialogService` (the cancel button's answer, or claimed and
+ * ignored when there is none). Not used directly in templates.
+ *
+ * @example
+ * const answer = await inject(BfAlertDialogService).open({
+ *   title: 'Delete list?',
+ *   message: 'This cannot be undone.',
+ *   buttons: [
+ *     { id: 'cancel', label: 'Cancel', role: 'cancel' },
+ *     { id: 'delete', label: 'Delete', role: 'destructive' },
+ *   ],
+ * });
+ * @summary Centred confirmation dialog with a title, message and a row of role-styled buttons
+ * @category Overlays
+ * @since 0.2.0
+ */
+export declare class BfAlertDialogComponent {
+  protected readonly config: BfAlertDialogConfig;
+  private readonly ref;
+  protected select(button: BfAlertDialogButtonConfig): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BfAlertDialogComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BfAlertDialogComponent, "bf-alert-dialog", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Options of `provideBfShellTesting()`.
+ *
+ * @summary Options of the shell test providers: the routes and the shell settings
+ * @since 0.3.0
+ */
+interface BfShellTestingOptions {
+  /**
+   * The routes of the test router.
+   * @default []
+   */
+  routes?: Routes;
+  /** Shell settings over the test defaults (`swipeBack: false`, `hapticsOnTabChange: false`). */
+  config?: Partial<BfShellConfig>;
+}
+/**
+ * Test providers for an app on the mobile shell: `provideRouter(routes ?? [],
+ * withComponentInputBinding(), withBfShellRouting())` plus `provideBfShell({ swipeBack: false,
+ * hapticsOnTabChange: false, ...config })`, an in-memory `BF_THEME_STORAGE` (so a theme change
+ * never reaches `localStorage`), and the same document cleanup as `provideBfTesting()` from
+ * `@bitforgehq/ui/testing` on teardown (`dark` and `cdk-global-scrollblock` on `<html>`, `inert` on
+ * body children, stray overlay panes). Like that cleanup, it needs TestBed's default
+ * `teardown: { destroyAfterEach: true }`. Use it instead of the app's own shell providers in
+ * `TestBed.configureTestingModule()`.
+ *
+ * @example
+ * TestBed.configureTestingModule({
+ *   providers: [provideBfShellTesting({ routes: [{ path: 'inbox', component: InboxPage }] })],
+ * });
+ * @param options The routes and the shell settings.
+ * @returns The environment providers for `TestBed.configureTestingModule()`.
+ * @summary Test providers for the mobile shell: router, shell, in-memory theme and cleanup
+ * @since 0.3.0
+ */
+export declare function provideBfShellTesting(options?: BfShellTestingOptions): EnvironmentProviders;
+export { type BfActionSheetAction, type BfActionSheetActionRole, type BfActionSheetOptions, type BfAlertDialogButton, type BfAlertDialogButtonRole, type BfAlertDialogOptions, type BfBackAtRoot, type BfContentScrollEvent, type BfHapticsImpactStyle, type BfHapticsNotificationType, type BfKeyboardAssistBehavior, type BfKeyboardPhase, type BfModalOptions, type BfModalPresentation, type BfNavDirection, type BfNavTarget, type BfOverlayOptions, type BfOverlayPosition, type BfOverlayStackOptions, type BfOverlayTemplateContext, type BfPlatform, type BfRefresherRefreshEvent, type BfSheetAutoFocus, type BfSheetOptions, type BfShellConfig, type BfShellConfigMode, type BfShellDynamicType, type BfShellDynamicTypeLimit, type BfShellMode, type BfShellTestingOptions, type BfStackChange, type BfStackTransition, type BfStackTransitionEvent, type BfStackedOverlay, type BfTabContext, type BfTheme, type BfToastAction, type BfToastDismissReason, type BfToastOptions, type BfToastPosition, BfToastRef, type BfTransitionKind, type BfViewEvent, type BfViewState, prefersReducedMotion };