@tristan.stavast/blueprintx 0.1.0

package/index.d.ts

@@ -0,0 +1,2728 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _tristan_stavast_blueprintx from '@tristan.stavast/blueprintx';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+/**
+ * Shared cross-component type vocabulary for BlueprintX.
+ * Keeping these in one place means `size="md"` means the same thing on every
+ * component and consumers get consistent autocomplete.
+ */
+/** T-shirt sizes used by most interactive components. */
+type BpxSize = 'sm' | 'md' | 'lg';
+/** Visual emphasis / hierarchy of an action. */
+type BpxVariant = 'solid' | 'soft' | 'outline' | 'ghost' | 'link';
+/** Semantic color role, mapped to design tokens. */
+type BpxColor = 'primary' | 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+/** Fill style shared by "badge-like" presentational components. */
+type BpxTone = 'solid' | 'soft' | 'outline';
+/**
+ * A selectable option for data-driven components (Select, MultiSelect, Filter).
+ * `T` is the type of the underlying value.
+ */
+interface BpxOption<T = string> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+    /** Optional registered icon name to show before the label. */
+    icon?: string;
+}
+
+/**
+ * Generates a process-unique, DOM-safe id with a prefix.
+ * Used to wire up ARIA relationships (aria-labelledby, aria-describedby, etc.)
+ * when the consumer hasn't supplied an explicit id.
+ *
+ * @example uniqueId('bpx-input') // 'bpx-input-0'
+ */
+declare function uniqueId(prefix: string): string;
+
+/**
+ * BlueprintX Button.
+ *
+ * Applied as an attribute on a native `<button>` or `<a>` so it keeps all
+ * native semantics (focus, keyboard, form submission, right-click-open-in-tab):
+ *
+ * ```html
+ * <button bpx-button color="primary" variant="solid">Save</button>
+ * <a bpx-button variant="link" href="/docs">Docs</a>
+ * <button bpx-button [loading]="saving()" (click)="save()">Submit</button>
+ * ```
+ */
+declare class Button {
+    private readonly el;
+    private readonly isAnchor;
+    /** Visual style of the button. */
+    readonly variant: _angular_core.InputSignal<BpxVariant>;
+    /** Semantic color role (maps to design tokens). */
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    /** Size of the button. */
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    /** Whether the button is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Shows a spinner and blocks interaction while an async action runs. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Stretches the button to fill its container's width. */
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Renders as a square icon-only button (removes horizontal padding). */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The `type` for a native button. Defaults to `button` to avoid accidental
+     * form submits. Ignored for anchors.
+     */
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    protected readonly nativeDisabled: _angular_core.Signal<boolean>;
+    protected readonly ariaDisabled: _angular_core.Signal<boolean>;
+    protected readonly resolvedType: _angular_core.Signal<"button" | "submit" | "reset" | null>;
+    protected handleClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Button, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Button, "button[bpx-button], a[bpx-button]", ["bpxButton"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Visually joins a row (or column) of `[bpx-button]`s into a single connected
+ * control — shared borders, rounded only on the outer ends.
+ *
+ * ```html
+ * <bpx-button-group>
+ *   <button bpx-button variant="outline">Day</button>
+ *   <button bpx-button variant="outline">Week</button>
+ *   <button bpx-button variant="outline">Month</button>
+ * </bpx-button-group>
+ * ```
+ */
+declare class ButtonGroup {
+    /** Lay the buttons out in a row (default) or a column. */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroup, "bpx-button-group", ["bpxButtonGroup"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An action inside a `<bpx-menu>`. Emits `select` and closes the menu when
+ * activated.
+ *
+ * ```html
+ * <bpx-menu-item icon="check" (select)="save()">Save</bpx-menu-item>
+ * <bpx-menu-item variant="danger" (select)="remove()">Delete</bpx-menu-item>
+ * ```
+ */
+declare class MenuItem {
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly variant: _angular_core.InputSignal<"danger" | "default">;
+    readonly select: _angular_core.OutputEmitterRef<void>;
+    private readonly menu;
+    private readonly el;
+    get element(): HTMLElement;
+    focus(): void;
+    protected activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItem, "bpx-menu-item", ["bpxMenuItem"], { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A dropdown menu panel. Holds `<bpx-menu-item>`s and is opened by an element
+ * carrying `[bpxMenuTriggerFor]`. It renders nothing inline until opened.
+ *
+ * ```html
+ * <button bpx-button [bpxMenuTriggerFor]="menu">Actions</button>
+ * <bpx-menu #menu>
+ *   <bpx-menu-item icon="check" (select)="publish()">Publish</bpx-menu-item>
+ *   <bpx-menu-item variant="danger" (select)="remove()">Delete</bpx-menu-item>
+ * </bpx-menu>
+ * ```
+ */
+declare class Menu {
+    readonly template: _angular_core.Signal<TemplateRef<any>>;
+    readonly items: _angular_core.Signal<readonly MenuItem[]>;
+    /** Emitted when the menu asks to close (item chosen, Escape, or Tab). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly doc;
+    close(): void;
+    /** Focus the first enabled item — called by the trigger after opening. */
+    focusFirst(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private enabledItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "bpx-menu", ["bpxMenu"], {}, { "closed": "closed"; }, ["items"], ["*"], true, never>;
+}
+
+/**
+ * A primary action button joined to a dropdown toggle that opens a `<bpx-menu>`
+ * of secondary actions. The main button emits `action`; the caret opens the menu.
+ *
+ * ```html
+ * <bpx-split-button [menu]="menu" (action)="save()">Save</bpx-split-button>
+ * <bpx-menu #menu>
+ *   <bpx-menu-item (select)="saveAsDraft()">Save as draft</bpx-menu-item>
+ *   <bpx-menu-item (select)="saveAndClose()">Save and close</bpx-menu-item>
+ * </bpx-menu>
+ * ```
+ */
+declare class SplitButton {
+    /** The menu opened by the dropdown toggle. */
+    readonly menu: _angular_core.InputSignal<Menu>;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly variant: _angular_core.InputSignal<BpxVariant>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires when the main (primary) button is clicked. */
+    readonly action: _angular_core.OutputEmitterRef<MouseEvent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitButton, "bpx-split-button", ["bpxSplitButton"], { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A button that copies text to the clipboard and briefly confirms with a check.
+ *
+ * ```html
+ * <bpx-copy-button [value]="apiKey" />
+ * <bpx-copy-button [value]="url" variant="soft" copiedLabel="Copied link" />
+ * ```
+ */
+declare class CopyButton {
+    /** The text to copy. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Idle label. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label shown briefly after a successful copy. */
+    readonly copiedLabel: _angular_core.InputSignal<string>;
+    /** Show the text label beside the icon. When off, renders icon-only. */
+    readonly showLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly variant: _angular_core.InputSignal<BpxVariant>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires with the copied text on success. */
+    readonly copied$: _angular_core.OutputEmitterRef<string>;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    private readonly isBrowser;
+    private readonly doc;
+    private timer?;
+    constructor();
+    protected copy(): Promise<void>;
+    private flash;
+    /** Last-resort copy for browsers without the async Clipboard API. */
+    private fallbackCopy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyButton, "bpx-copy-button", ["bpxCopyButton"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "copied$": "copied"; }, never, never, true, never>;
+}
+
+/**
+ * BlueprintX Icon — renders a registered SVG glyph that inherits the current
+ * text color and scales with font-size.
+ *
+ * ```html
+ * <bpx-icon name="check" />
+ * <bpx-icon name="warning" size="lg" label="Warning" />
+ * ```
+ *
+ * If `label` is set the icon is exposed to assistive tech; otherwise it is
+ * treated as decorative (aria-hidden).
+ */
+declare class Icon {
+    private readonly registry;
+    private readonly sanitizer;
+    /** Registered icon name to render. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Size token; also settable directly via CSS font-size. */
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    /** Accessible label. Omit for purely decorative icons. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    protected readonly svg: _angular_core.Signal<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Icon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Icon, "bpx-icon", ["bpxIcon"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Inner SVG markup for an icon, drawn on a 0 0 24 24 viewBox. */
+type BpxIconDefinition = string;
+/**
+ * Central registry mapping icon names to their SVG body. Ships with a small
+ * built-in set; apps register their own with `registry.register('name', svg)`.
+ * All icons are authored on a 24×24 grid and inherit `currentColor`.
+ */
+declare class IconRegistry {
+    private readonly icons;
+    /** Register (or override) a single icon by name. */
+    register(name: string, svgBody: BpxIconDefinition): void;
+    /** Register many icons at once. */
+    registerMany(icons: Record<string, BpxIconDefinition>): void;
+    /** Look up an icon's SVG body, or undefined if not registered. */
+    get(name: string): BpxIconDefinition | undefined;
+    /** All registered icon names — handy for docs/story controls. */
+    names(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconRegistry>;
+}
+
+/**
+ * A small status/label badge.
+ *
+ * ```html
+ * <bpx-badge color="success">Active</bpx-badge>
+ * <bpx-badge color="danger" tone="solid" dot>Live</bpx-badge>
+ * ```
+ */
+declare class Badge {
+    /** Semantic color role. */
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    /** Fill style. */
+    readonly tone: _angular_core.InputSignal<BpxTone>;
+    /** Size. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Fully rounded (pill) shape. */
+    readonly pill: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a leading status dot. */
+    readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "bpx-badge", ["bpxBadge"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "pill": { "alias": "pill"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An indeterminate loading spinner.
+ *
+ * ```html
+ * <bpx-spinner />
+ * <bpx-spinner size="lg" label="Loading results" />
+ * ```
+ */
+declare class Spinner {
+    /** Size of the spinner. */
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    /** Accessible label announced to screen readers. */
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Spinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Spinner, "bpx-spinner", ["bpxSpinner"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Placeholder shape. */
+type BpxSkeletonVariant = 'text' | 'rect' | 'circle';
+/** How the placeholder animates while content loads. */
+type BpxSkeletonAnimation = 'pulse' | 'wave' | 'none';
+/**
+ * A content-shaped loading placeholder. Render it in the same layout slot as the
+ * real content so the page doesn't jump when data arrives.
+ *
+ * ```html
+ * <bpx-skeleton variant="circle" width="40" />
+ * <bpx-skeleton [lines]="3" />
+ * <bpx-skeleton variant="rect" height="160" animation="wave" />
+ * ```
+ */
+declare class Skeleton {
+    /** Placeholder shape. */
+    readonly variant: _angular_core.InputSignal<BpxSkeletonVariant>;
+    /** CSS width. A bare number is treated as pixels. */
+    readonly width: _angular_core.InputSignal<string | number | null>;
+    /** CSS height. A bare number is treated as pixels. */
+    readonly height: _angular_core.InputSignal<string | number | null>;
+    /** Number of lines to render for the `text` variant. */
+    readonly lines: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Animation style. Automatically disabled under `prefers-reduced-motion`. */
+    readonly animation: _angular_core.InputSignal<BpxSkeletonAnimation>;
+    /** Accessible label. When set, the skeleton announces itself as a busy status. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly lineArray: _angular_core.Signal<unknown[]>;
+    protected readonly circleSize: _angular_core.Signal<string>;
+    /** Per-line width: honor an explicit width, else make the last line shorter. */
+    protected lineWidth(index: number): string;
+    /**
+     * Normalize a width/height input to a CSS length. Numbers and bare numeric
+     * strings (e.g. `56` or `"56"` from a template attribute) become px; values
+     * that already carry a unit (`"50%"`, `"3rem"`) pass through unchanged.
+     */
+    protected cssSize(value: string | number | null): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Skeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Skeleton, "bpx-skeleton", ["bpxSkeleton"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A ready-made loading layout that mirrors a common UI shape. */
+type BpxSkeletonPreset = 'list' | 'card' | 'article' | 'table' | 'form';
+/**
+ * Ready-made skeleton layouts for common UI shapes — a profile list, a card
+ * grid, an article, a table or a form — composed from `bpx-skeleton` primitives.
+ * Drop one in place of the content that's loading.
+ *
+ * ```html
+ * <bpx-skeleton-layout preset="list" [count]="5" />
+ * <bpx-skeleton-layout preset="card" [count]="3" animation="wave" />
+ * <bpx-skeleton-layout preset="table" [count]="6" [columns]="4" />
+ * ```
+ */
+declare class SkeletonLayout {
+    /** Which layout to render. */
+    readonly preset: _angular_core.InputSignal<BpxSkeletonPreset>;
+    /**
+     * How many repeated units to render (rows for `list`/`table`/`form`, cards for
+     * `card`, paragraph lines for `article`). `0` uses a sensible per-preset default.
+     */
+    readonly count: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Number of columns for the `table` preset. */
+    readonly columns: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show the leading avatar circle in the `list` preset. */
+    readonly avatar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Animation forwarded to every bone. Pauses under `prefers-reduced-motion`. */
+    readonly animation: _angular_core.InputSignal<BpxSkeletonAnimation>;
+    /** Accessible label announced while loading. */
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly defaultCount;
+    private readonly resolvedCount;
+    /** Array to iterate the repeated units in the template. */
+    protected readonly items: _angular_core.Signal<unknown[]>;
+    /** Array to iterate table columns in the template. */
+    protected readonly cols: _angular_core.Signal<unknown[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonLayout, "bpx-skeleton-layout", ["bpxSkeletonLayout"], { "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "avatar": { "alias": "avatar"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type BpxAvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+type BpxAvatarStatus = 'online' | 'offline' | 'busy' | 'away';
+/**
+ * A user avatar. Shows an image when `src` loads, otherwise falls back to
+ * initials on a gradient derived from the name (so every user looks distinct).
+ *
+ * ```html
+ * <bpx-avatar name="Ada Lovelace" />
+ * <bpx-avatar src="/me.jpg" name="Me" size="lg" status="online" />
+ * ```
+ */
+declare class Avatar {
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<BpxAvatarSize>;
+    readonly shape: _angular_core.InputSignal<"circle" | "rounded">;
+    readonly status: _angular_core.InputSignal<BpxAvatarStatus | undefined>;
+    /** Flips to true if the image fails to load, so we fall back to initials. */
+    protected readonly imgFailed: _angular_core.WritableSignal<boolean>;
+    protected readonly showImage: _angular_core.Signal<boolean>;
+    protected readonly initials: _angular_core.Signal<string>;
+    /** Deterministic gradient from the name so avatars are visually distinct. */
+    protected readonly gradient: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Avatar, "bpx-avatar", ["bpxAvatar"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A compact chip / tag. Can be static, selectable (toggle) or removable.
+ *
+ * ```html
+ * <bpx-chip>Design</bpx-chip>
+ * <bpx-chip removable (removed)="drop(t)">{{ t }}</bpx-chip>
+ * <bpx-chip selectable [selected]="on()" (click)="on.set(!on())">Filter</bpx-chip>
+ * ```
+ */
+declare class Chip {
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly tone: _angular_core.InputSignal<BpxTone>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    /** Shows a remove (×) button. */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks the chip selectable (adds button semantics + keyboard). */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Selected/active state (visual + aria-pressed). */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when the remove button is activated. */
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected remove(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Chip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Chip, "bpx-chip", ["bpxChip"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Layout container that groups related chips with consistent spacing and
+ * wrapping (or horizontal scrolling). Provides `role="group"` for a11y.
+ *
+ * ```html
+ * <bpx-chip-set label="Tags">
+ *   <bpx-chip removable>Angular</bpx-chip>
+ *   <bpx-chip removable>Signals</bpx-chip>
+ * </bpx-chip-set>
+ * ```
+ */
+declare class ChipSet {
+    /** Accessible group label. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Scroll horizontally on overflow instead of wrapping. */
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipSet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipSet, "bpx-chip-set", ["bpxChipSet"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A status callout / banner.
+ *
+ * ```html
+ * <bpx-alert color="success" title="Saved">Your changes are live.</bpx-alert>
+ * <bpx-alert color="danger" dismissible (dismissed)="hide()">Something broke.</bpx-alert>
+ * ```
+ */
+declare class Alert {
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly tone: _angular_core.InputSignal<BpxTone>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Show a leading status icon (auto-selected from color, or override). */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly resolvedIcon: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Alert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Alert, "bpx-alert", ["bpxAlert"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A single-select dropdown built on the CDK overlay. Data-driven via `options`,
+ * two-way bound with `[(value)]`. Fully keyboard operable with listbox ARIA.
+ *
+ * ```html
+ * <bpx-select [options]="fruits" [(value)]="fruit" placeholder="Pick one" />
+ * ```
+ */
+declare class Select<T> {
+    readonly options: _angular_core.InputSignal<BpxOption<T>[]>;
+    readonly value: _angular_core.ModelSignal<T | null>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly triggerWidth: _angular_core.WritableSignal<number>;
+    protected readonly positions: _angular_cdk_overlay.ConnectedPosition[];
+    private readonly baseId;
+    protected readonly listId: string;
+    protected readonly selectedOption: _angular_core.Signal<BpxOption<T> | null>;
+    protected optionId(i: number): string;
+    protected onTriggerClick(el: HTMLElement): void;
+    protected openPanel(el?: HTMLElement): void;
+    protected close(): void;
+    protected select(opt: BpxOption<T>): void;
+    protected clear(event: Event): void;
+    protected onTriggerKeydown(event: KeyboardEvent, el: HTMLElement): void;
+    private move;
+    private firstEnabled;
+    private lastEnabled;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Select<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select<any>, "bpx-select", ["bpxSelect"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A multiple-select dropdown. Selected values show as removable chips in the
+ * trigger; the panel stays open while toggling options.
+ *
+ * ```html
+ * <bpx-multi-select [options]="skills" [(value)]="selected" placeholder="Skills" />
+ * ```
+ */
+declare class MultiSelect<T> {
+    readonly options: _angular_core.InputSignal<BpxOption<T>[]>;
+    readonly value: _angular_core.ModelSignal<T[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Max chips to show in the trigger before collapsing to "+N". */
+    readonly maxDisplay: _angular_core.InputSignal<number>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly triggerWidth: _angular_core.WritableSignal<number>;
+    protected readonly positions: _angular_cdk_overlay.ConnectedPosition[];
+    private readonly baseId;
+    protected readonly listId: string;
+    protected readonly selectedOptions: _angular_core.Signal<BpxOption<T>[]>;
+    protected readonly visibleChips: _angular_core.Signal<BpxOption<T>[]>;
+    protected readonly overflowCount: _angular_core.Signal<number>;
+    protected isSelected(opt: BpxOption<T>): boolean;
+    protected optionId(i: number): string;
+    protected onTriggerClick(el: HTMLElement): void;
+    protected openPanel(el?: HTMLElement): void;
+    protected close(): void;
+    protected toggle(opt: BpxOption<T>): void;
+    protected removeValue(value: T, event?: Event): void;
+    protected clearAll(event: Event): void;
+    protected onTriggerKeydown(event: KeyboardEvent, el: HTMLElement): void;
+    private move;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelect<any>, "bpx-multi-select", ["bpxMultiSelect"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxDisplay": { "alias": "maxDisplay"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A single-select autocomplete: a text field that filters a list of options as
+ * you type, on the CDK overlay. Works standalone with `[(value)]` and as a form
+ * control via `formControlName` / `[(ngModel)]`. Fully keyboard operable with
+ * combobox/listbox ARIA.
+ *
+ * ```html
+ * <bpx-combobox [options]="countries" [(value)]="country" placeholder="Search…" />
+ * <bpx-combobox formControlName="assignee" [options]="people" clearable />
+ * ```
+ */
+declare class Combobox<T> implements ControlValueAccessor {
+    readonly options: _angular_core.InputSignal<BpxOption<T>[]>;
+    /** The selected value. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<T | null>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text shown in the panel when the filter matches nothing. */
+    readonly noResultsText: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    /** The current text in the field (the filter query). */
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly triggerWidth: _angular_core.WritableSignal<number>;
+    protected readonly positions: _angular_cdk_overlay.ConnectedPosition[];
+    private readonly baseId;
+    protected readonly listId: string;
+    protected readonly selectedOption: _angular_core.Signal<BpxOption<T> | null>;
+    /** Options matching the query — everything when the query is empty or equals
+     * the current selection's label (so re-opening shows the full list). */
+    protected readonly filtered: _angular_core.Signal<BpxOption<T>[]>;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    protected optionId(i: number): string;
+    protected onFocus(field: HTMLElement, input: HTMLInputElement): void;
+    protected openPanel(field?: HTMLElement): void;
+    protected close(): void;
+    protected onInput(event: Event): void;
+    protected select(opt: BpxOption<T>): void;
+    protected clear(event: Event, input: HTMLInputElement): void;
+    protected onKeydown(event: KeyboardEvent, field: HTMLElement): void;
+    private move;
+    private firstEnabled;
+    private lastEnabled;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Combobox<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Combobox<any>, "bpx-combobox", ["bpxCombobox"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Why a dropped/picked file was turned away. */
+interface BpxFileRejection {
+    file: File;
+    reason: 'type' | 'size' | 'count';
+}
+/**
+ * A file dropzone: pick files with a click or drag-and-drop, with built-in
+ * `accept`, size and count validation and a removable file list. Works
+ * standalone with `[(files)]` and as a form control via `formControlName`.
+ * Uploading itself is left to the app — bind `(filesChange)` and send them.
+ *
+ * ```html
+ * <bpx-file-upload [(files)]="files" accept="image/*" multiple [maxSize]="5_000_000" />
+ * <bpx-file-upload formControlName="resume" accept=".pdf,.doc,.docx" />
+ * ```
+ */
+declare class FileUpload implements ControlValueAccessor {
+    /** The selected files. Two-way bindable via `[(files)]`. */
+    readonly files: _angular_core.ModelSignal<File[]>;
+    /** Allow selecting more than one file. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Native `accept` string, e.g. `"image/*,.pdf"`. Also enforced on drop. */
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Reject files larger than this many bytes. `0` = no limit. */
+    readonly maxSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Cap the number of files kept (multiple only). `0` = no limit. */
+    readonly maxFiles: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Secondary hint shown under the prompt (e.g. accepted types). */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Error styling. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    /** Emitted with the files turned away by validation. */
+    readonly rejected: _angular_core.OutputEmitterRef<BpxFileRejection[]>;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    private dragDepth;
+    private onChange;
+    protected onTouched: () => void;
+    protected open(input: HTMLInputElement): void;
+    protected onKeydown(event: KeyboardEvent, input: HTMLInputElement): void;
+    protected onPicked(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragLeave(): void;
+    protected onDrop(event: DragEvent): void;
+    protected remove(target: File, event: Event): void;
+    private addFiles;
+    private setFiles;
+    /** De-duplicate by identity and by name+size+lastModified. */
+    private dedupe;
+    /** Match a file against the `accept` list (mime, mime/* wildcard, or .ext). */
+    private matchesAccept;
+    /** Human-readable file size for the list. */
+    protected formatSize(bytes: number): string;
+    writeValue(value: File[] | null): void;
+    registerOnChange(fn: (value: File[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUpload, "bpx-file-upload", ["bpxFileUpload"], { "files": { "alias": "files"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+/**
+ * A compact filter control — ideal for data-table column headers. A small
+ * trigger shows the label and a count of active filters; the popover offers a
+ * search box and a checkbox list. Emits selections live via `[(value)]`.
+ *
+ * ```html
+ * <bpx-filter label="Status" [options]="statuses" [(value)]="active" />
+ * ```
+ */
+declare class Filter<T> {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<BpxOption<T>[]>;
+    readonly value: _angular_core.ModelSignal<T[]>;
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly search: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly positions: _angular_cdk_overlay.ConnectedPosition[];
+    private readonly searchInput;
+    protected readonly count: _angular_core.Signal<number>;
+    protected readonly filtered: _angular_core.Signal<BpxOption<T>[]>;
+    protected isSelected(opt: BpxOption<T>): boolean;
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(): void;
+    protected onAttach(): void;
+    protected onSearch(event: Event): void;
+    protected toggleOption(opt: BpxOption<T>): void;
+    protected clearAll(): void;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Filter<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Filter<any>, "bpx-filter", ["bpxFilter"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A boolean on/off toggle. Works standalone with `[(checked)]` and as a form
+ * control via `formControlName` / `[(ngModel)]`.
+ *
+ * ```html
+ * <bpx-switch [(checked)]="notifications">Email me</bpx-switch>
+ * <bpx-switch formControlName="darkMode" color="success" />
+ * ```
+ */
+declare class Switch implements ControlValueAccessor {
+    /** On/off state. Two-way bindable via `[(checked)]`. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Disables interaction via the template. */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    /** Set by Angular forms through `setDisabledState`. */
+    private readonly cvaDisabled;
+    /** Effective disabled state — either the input or a disabled form control. */
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private onChange;
+    /** Called on blur so forms mark the control touched. Invoked from the host. */
+    protected onTouched: () => void;
+    protected toggle(): void;
+    protected onKey(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Switch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Switch, "bpx-switch", ["bpxSwitch"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A single-value range slider. Works standalone with `[(value)]` and as a form
+ * control via `formControlName` / `[(ngModel)]`. Fully keyboard operable.
+ *
+ * ```html
+ * <bpx-slider [(value)]="volume" [min]="0" [max]="100" />
+ * <bpx-slider formControlName="opacity" [step]="0.05" [max]="1" color="success" />
+ * ```
+ */
+declare class Slider implements ControlValueAccessor {
+    private readonly el;
+    /** Current value. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    /** Disables interaction via the template. */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    /** Set by Angular forms through `setDisabledState`. */
+    private readonly cvaDisabled;
+    /** Effective disabled state — either the input or a disabled form control. */
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    /** Filled fraction of the track, 0–100, clamped for out-of-range values. */
+    protected readonly pct: _angular_core.Signal<number>;
+    private dragging;
+    private onChange;
+    protected onTouched: () => void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(): void;
+    private setFromClientX;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Snap to the step grid, clamp to range, and emit only on a real change. */
+    private commit;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Slider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Slider, "bpx-slider", ["bpxSlider"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+type BpxInputType = 'text' | 'email' | 'password' | 'search' | 'tel' | 'url' | 'number';
+/**
+ * A single-line text field. Works standalone with `[(value)]` and as a form
+ * control via `formControlName` / `[(ngModel)]`. Project `[bpxPrefix]` /
+ * `[bpxSuffix]` content (icons, units, buttons) into the ends.
+ *
+ * ```html
+ * <bpx-input [(value)]="email" type="email" placeholder="you@example.com" />
+ * <bpx-input formControlName="query" clearable>
+ *   <bpx-icon bpxPrefix name="search" />
+ * </bpx-input>
+ * ```
+ */
+declare class Input implements ControlValueAccessor {
+    /** Field text. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly type: _angular_core.InputSignal<BpxInputType>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Read-only via the template (aliased so `readonly` works in markup). */
+    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear button while there is text. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error styling + `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    protected onInput(event: Event): void;
+    protected clear(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Input, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Input, "bpx-input", ["bpxInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[bpxPrefix]", "[bpxSuffix]"], true, never>;
+}
+
+/**
+ * A multi-line text field. Works standalone with `[(value)]` and as a form
+ * control via `formControlName` / `[(ngModel)]`. Set `autoResize` to grow with
+ * its content.
+ *
+ * ```html
+ * <bpx-textarea [(value)]="bio" [rows]="4" placeholder="Tell us about yourself" />
+ * <bpx-textarea formControlName="notes" autoResize />
+ * ```
+ */
+declare class Textarea implements ControlValueAccessor {
+    private readonly field;
+    /** Field text. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<number>;
+    /** Grow the field to fit its content instead of scrolling. */
+    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    protected onInput(event: Event): void;
+    private resize;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Textarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Textarea, "bpx-textarea", ["bpxTextarea"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Visual shape of a progress indicator. */
+type BpxProgressShape = 'line' | 'half' | 'circle';
+/**
+ * A determinate progress indicator in three shapes: a flat `line`, a `half`
+ * circle gauge, and a full `circle` ring.
+ *
+ * ```html
+ * <bpx-progress [value]="65" />
+ * <bpx-progress shape="half" [value]="40" showLabel />
+ * <bpx-progress shape="circle" [value]="80" color="success" showLabel />
+ * ```
+ */
+declare class Progress {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly shape: _angular_core.InputSignal<BpxProgressShape>;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    /** Diameter in px for the `half` / `circle` shapes. */
+    readonly size: _angular_core.InputSignal<number>;
+    /** Track / stroke thickness in px (also the line height). */
+    readonly thickness: _angular_core.InputSignal<number>;
+    /** Show the rounded percentage in the centre (half / circle shapes). */
+    readonly showLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly fraction: _angular_core.Signal<number>;
+    protected readonly pct: _angular_core.Signal<number>;
+    protected readonly rounded: _angular_core.Signal<number>;
+    protected readonly center: _angular_core.Signal<number>;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly circumference: _angular_core.Signal<number>;
+    protected readonly circleOffset: _angular_core.Signal<number>;
+    protected readonly semiLength: _angular_core.Signal<number>;
+    protected readonly semiOffset: _angular_core.Signal<number>;
+    /** Height of the half-circle viewport: top half of the ring plus its stroke. */
+    protected readonly halfHeight: _angular_core.Signal<number>;
+    /** Semicircle arc, left point over the top to the right point. */
+    protected readonly semiPath: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Progress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Progress, "bpx-progress", ["bpxProgress"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A single panel within `<bpx-tabs>`. Its content is lazily rendered only while
+ * the tab is active.
+ *
+ * ```html
+ * <bpx-tabs>
+ *   <bpx-tab label="Overview">…</bpx-tab>
+ *   <bpx-tab label="Settings" icon="search">…</bpx-tab>
+ * </bpx-tabs>
+ * ```
+ */
+declare class Tab {
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional registered icon name shown before the label. */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Toggled by the parent `<bpx-tabs>`. */
+    readonly active: _angular_core.WritableSignal<boolean>;
+    private readonly baseId;
+    readonly tabId: string;
+    readonly panelId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tab, "bpx-tab", ["bpxTab"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A tabbed interface with a sliding active-indicator, keyboard navigation and
+ * full tablist ARIA. Compose it from `<bpx-tab>` children.
+ *
+ * ```html
+ * <bpx-tabs [(activeIndex)]="tab" color="primary">
+ *   <bpx-tab label="Overview">…</bpx-tab>
+ *   <bpx-tab label="Activity">…</bpx-tab>
+ * </bpx-tabs>
+ * ```
+ */
+declare class Tabs {
+    readonly tabs: _angular_core.Signal<readonly Tab[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    private readonly list;
+    private readonly tabButtons;
+    protected readonly indicatorLeft: _angular_core.WritableSignal<number>;
+    protected readonly indicatorWidth: _angular_core.WritableSignal<number>;
+    private readonly resizeTick;
+    constructor();
+    protected select(index: number): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** First enabled tab index stepping `dir` from `from` (wraps), or -1. */
+    private step;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tabs, "bpx-tabs", ["bpxTabs"], { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["tabs"], ["*"], true, never>;
+}
+
+type BpxTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Shows a small floating label on hover and keyboard focus. Built on the CDK
+ * overlay, so it flips to stay on-screen and never clips inside scroll areas.
+ *
+ * ```html
+ * <button bpx-button bpxTooltip="Save changes">Save</button>
+ * <bpx-icon name="info" bpxTooltip="More info" bpxTooltipPosition="right" />
+ * ```
+ */
+declare class Tooltip {
+    /** Tooltip text. */
+    readonly text: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<BpxTooltipPosition>;
+    /** Delay in ms before showing. */
+    readonly showDelay: _angular_core.InputSignal<number>;
+    private readonly overlay;
+    private readonly el;
+    private overlayRef?;
+    private showTimer?;
+    constructor();
+    protected show(): void;
+    protected hide(): void;
+    private attach;
+    private ensureOverlay;
+    private clearTimer;
+    /** Preferred placement plus its opposite as a flip fallback. */
+    private positionsFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tooltip, "[bpxTooltip]", never, { "text": { "alias": "bpxTooltip"; "required": true; "isSignal": true; }; "position": { "alias": "bpxTooltipPosition"; "required": false; "isSignal": true; }; "showDelay": { "alias": "bpxTooltipDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A surface container for grouping related content. Three visual variants and
+ * an optional `interactive` state for clickable cards.
+ *
+ * ```html
+ * <bpx-card>…</bpx-card>
+ * <bpx-card variant="outline" interactive>…</bpx-card>
+ * ```
+ */
+declare class Card {
+    readonly variant: _angular_core.InputSignal<"soft" | "outline" | "elevated">;
+    /** Adds hover lift, pointer cursor and a focus ring for clickable cards. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Card, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "bpx-card", ["bpxCard"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A frosted "liquid glass" surface. Blurs and saturates whatever is behind it,
+ * warps it with an SVG refraction filter, and carries a specular sheen that
+ * follows the cursor. Wrap any content — a card, a toolbar, a hero panel — and
+ * place it over something colorful for the effect to read.
+ *
+ * ```html
+ * <bpx-liquid-glass [blur]="12" [distortion]="40">
+ *   <h2>Liquid Glass</h2>
+ * </bpx-liquid-glass>
+ * ```
+ */
+declare class LiquidGlass {
+    /** Backdrop blur radius, in px. */
+    readonly blur: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Backdrop saturation multiplier (1 = unchanged). */
+    readonly saturation: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Refraction strength (SVG displacement scale). `0` disables the warp. */
+    readonly distortion: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Glass tint — a translucent color layered over the blur. */
+    readonly tint: _angular_core.InputSignal<string>;
+    /** Corner radius (any CSS length). */
+    readonly radius: _angular_core.InputSignal<string>;
+    /** Drop shadow for lift. */
+    readonly elevated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Specular sheen follows the cursor on hover. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    protected readonly filterId: string;
+    protected readonly blurPx: _angular_core.Signal<string>;
+    protected readonly hasDistortion: _angular_core.Signal<boolean>;
+    protected readonly refractFilter: _angular_core.Signal<string>;
+    private readonly host;
+    protected onMove(event: PointerEvent): void;
+    protected onEnter(): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LiquidGlass, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LiquidGlass, "bpx-liquid-glass", ["bpxLiquidGlass"], { "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "saturation": { "alias": "saturation"; "required": false; "isSignal": true; }; "distortion": { "alias": "distortion"; "required": false; "isSignal": true; }; "tint": { "alias": "tint"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Minimal contract the accordion needs from its items (avoids a circular import). */
+interface AccordionPanel {
+    setOpen(open: boolean): void;
+}
+/**
+ * A vertical stack of collapsible `<bpx-accordion-item>` panels. By default only
+ * one panel is open at a time; set `multi` to allow several.
+ *
+ * ```html
+ * <bpx-accordion>
+ *   <bpx-accordion-item heading="Shipping">…</bpx-accordion-item>
+ *   <bpx-accordion-item heading="Returns">…</bpx-accordion-item>
+ * </bpx-accordion>
+ * ```
+ */
+declare class Accordion {
+    /** Allow multiple panels open simultaneously. */
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private openPanel;
+    /** Called by an item when it opens; closes the previous one in single mode. */
+    notifyOpen(panel: AccordionPanel): void;
+    notifyClose(panel: AccordionPanel): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Accordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Accordion, "bpx-accordion", ["bpxAccordion"], { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A single collapsible panel inside `<bpx-accordion>`. Two-way bindable via
+ * `[(open)]`; its content animates open/closed and is `inert` while collapsed.
+ */
+declare class AccordionItem implements AccordionPanel {
+    private readonly parent;
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Open state. Two-way bindable via `[(open)]`. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    private readonly baseId;
+    protected readonly triggerId: string;
+    protected readonly regionId: string;
+    constructor();
+    protected toggle(): void;
+    /** Called by the parent accordion to close this panel in single-open mode. */
+    setOpen(open: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItem, "bpx-accordion-item", ["bpxAccordionItem"], { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A modal dialog rendered in the CDK overlay (so it escapes any clipping or
+ * stacking context). Controlled declaratively with `[(open)]`; traps focus,
+ * locks background scroll, and closes on backdrop click or Escape.
+ *
+ * ```html
+ * <button bpx-button (click)="confirm.set(true)">Delete</button>
+ * <bpx-dialog [(open)]="confirm" title="Delete item?">
+ *   <p>This can't be undone.</p>
+ *   <div bpxDialogFooter>
+ *     <button bpx-button variant="ghost" (click)="confirm.set(false)">Cancel</button>
+ *     <button bpx-button color="danger" (click)="remove()">Delete</button>
+ *   </div>
+ * </bpx-dialog>
+ * ```
+ */
+declare class Dialog {
+    /** Open state. Two-way bindable via `[(open)]`. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Prevent closing via backdrop click and Escape. */
+    readonly disableClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly titleId: string;
+    private readonly tpl;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly isBrowser;
+    private overlayRef?;
+    constructor();
+    protected close(): void;
+    private attach;
+    private detach;
+    private ensureOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dialog, "bpx-dialog", ["bpxDialog"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*", "[bpxDialogFooter]"], true, never>;
+}
+
+/**
+ * A checkbox with an optional indeterminate state. Works standalone with
+ * `[(checked)]` and as a form control via `formControlName` / `[(ngModel)]`.
+ *
+ * ```html
+ * <bpx-checkbox [(checked)]="agree">I agree to the terms</bpx-checkbox>
+ * <bpx-checkbox formControlName="selectAll" [indeterminate]="some" />
+ * ```
+ */
+declare class Checkbox implements ControlValueAccessor {
+    /** Checked state. Two-way bindable via `[(checked)]`. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Mixed state — cleared to `checked` on the next user toggle. */
+    readonly indeterminate: _angular_core.ModelSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    protected toggle(): void;
+    protected onKey(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Checkbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "bpx-checkbox", ["bpxCheckbox"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "indeterminate": "indeterminateChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A single option inside `<bpx-radio-group>`. Its label is projected content.
+ *
+ * ```html
+ * <bpx-radio value="pro">Pro plan</bpx-radio>
+ * ```
+ */
+declare class Radio {
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly group: RadioGroup;
+    private readonly el;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** Roving tabindex: the checked radio (or the first enabled one when none is
+     * selected) is the single tab stop for the group. */
+    protected readonly tabindex: _angular_core.Signal<0 | -1>;
+    protected select(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Radio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Radio, "bpx-radio", ["bpxRadio"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Groups a set of `<bpx-radio>` buttons into a single-choice control. Works
+ * standalone with `[(value)]` and as a form control via `formControlName` /
+ * `[(ngModel)]`. Arrow keys move (and select) between options.
+ *
+ * ```html
+ * <bpx-radio-group [(value)]="plan">
+ *   <bpx-radio value="free">Free</bpx-radio>
+ *   <bpx-radio value="pro">Pro</bpx-radio>
+ * </bpx-radio-group>
+ * ```
+ */
+declare class RadioGroup implements ControlValueAccessor {
+    /** Selected value. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly color: _angular_core.InputSignal<BpxColor>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly radios: _angular_core.Signal<readonly Radio[]>;
+    private onChange;
+    onTouched: () => void;
+    select(value: unknown): void;
+    /** First non-disabled radio — the roving-tabindex entry point when nothing is selected. */
+    firstEnabled(): Radio | undefined;
+    handleKey(event: KeyboardEvent, current: Radio): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroup, "bpx-radio-group", ["bpxRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], ["*"], true, never>;
+}
+
+interface PaginationItem {
+    type: 'page' | 'ellipsis';
+    page: number;
+}
+/**
+ * Page navigation with automatic ellipsis truncation. `page` is 1-based and
+ * two-way bindable.
+ *
+ * ```html
+ * <bpx-pagination [(page)]="page" [pageCount]="12" />
+ * ```
+ */
+declare class Pagination {
+    /** Current 1-based page. Two-way bindable via `[(page)]`. */
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly pageCount: _angular_core.InputSignal<number>;
+    /** Pages to show on each side of the current page. */
+    readonly siblingCount: _angular_core.InputSignal<number>;
+    /** Pages to always show at the start and end. */
+    readonly boundaryCount: _angular_core.InputSignal<number>;
+    /** The rendered sequence of page buttons and ellipses. */
+    readonly items: _angular_core.Signal<PaginationItem[]>;
+    protected go(target: number): void;
+    protected prev(): void;
+    protected next(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Pagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Pagination, "bpx-pagination", ["bpxPagination"], { "page": { "alias": "page"; "required": false; "isSignal": true; }; "pageCount": { "alias": "pageCount"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "boundaryCount": { "alias": "boundaryCount"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+}
+
+/**
+ * A scroll container with a slim, custom overlay scrollbar. Native scrolling
+ * (wheel, touch, keyboard) is preserved — the native bar is hidden and replaced
+ * with a styled, draggable thumb that only appears when content overflows.
+ *
+ * Give the host a bounded height (fixed, `max-height`, or a flex context).
+ *
+ * ```html
+ * <bpx-scroll-area style="max-height: 320px">…long content…</bpx-scroll-area>
+ * ```
+ */
+declare class ScrollArea {
+    private readonly viewport;
+    private readonly content;
+    protected readonly overflowing: _angular_core.WritableSignal<boolean>;
+    protected readonly thumbSize: _angular_core.WritableSignal<number>;
+    protected readonly thumbOffset: _angular_core.WritableSignal<number>;
+    private dragging;
+    private dragStartY;
+    private dragStartScrollTop;
+    private readonly minThumb;
+    constructor();
+    protected onScroll(): void;
+    protected onThumbPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(): void;
+    /** Click on the track (not the thumb) pages toward the click. */
+    protected onTrackPointerDown(event: PointerEvent): void;
+    private measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollArea, "bpx-scroll-area", ["bpxScrollArea"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An HSV color picker: a saturation/value field, a hue slider, a hex input and
+ * preset swatches. Value is a hex string. Works standalone with `[(value)]` and
+ * as a form control.
+ *
+ * ```html
+ * <bpx-color-picker [(value)]="brand" />
+ * <bpx-color-picker formControlName="accent" [swatches]="palette" />
+ * ```
+ */
+declare class ColorPicker implements ControlValueAccessor {
+    /** Hex color. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly swatches: _angular_core.InputSignal<string[]>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly hue: _angular_core.WritableSignal<number>;
+    protected readonly sat: _angular_core.WritableSignal<number>;
+    protected readonly val: _angular_core.WritableSignal<number>;
+    protected readonly hex: _angular_core.Signal<string>;
+    protected readonly pureHue: _angular_core.Signal<string>;
+    private readonly svArea;
+    private readonly hueTrack;
+    private dragTarget;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    protected onSvPointerDown(event: PointerEvent): void;
+    protected onHuePointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(): void;
+    protected onHexInput(event: Event): void;
+    protected pickSwatch(swatch: string): void;
+    private updateSv;
+    private updateHue;
+    private applyHex;
+    private commit;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPicker, "bpx-color-picker", ["bpxColorPicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "swatches": { "alias": "swatches"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Semantic type of a toast. */
+type BpxToastType = 'info' | 'success' | 'warning' | 'danger';
+/** An optional action button rendered inside a toast. */
+interface BpxToastAction {
+    label: string;
+    run: () => void;
+}
+interface BpxToastOptions {
+    type?: BpxToastType;
+    /** Auto-dismiss delay in ms; `0` keeps it until dismissed. */
+    duration?: number;
+    action?: BpxToastAction;
+}
+interface BpxToast extends Required<Omit<BpxToastOptions, 'action'>> {
+    id: number;
+    message: string;
+    action?: BpxToastAction;
+}
+
+/**
+ * Fires transient toast notifications. They render in a single top-right overlay
+ * that the service lazily creates on first use.
+ *
+ * ```ts
+ * const toasts = inject(ToastService);
+ * toasts.success('Saved');
+ * toasts.error('Upload failed', { action: { label: 'Retry', run: () => retry() } });
+ * ```
+ */
+declare class ToastService {
+    private readonly overlay;
+    private readonly injector;
+    private readonly isBrowser;
+    private readonly list;
+    /** The current live toasts (read-only). */
+    readonly toasts: _angular_core.Signal<BpxToast[]>;
+    private overlayRef?;
+    private counter;
+    private readonly timers;
+    /** Milliseconds still to run before auto-dismiss (updated on pause). */
+    private readonly remaining;
+    /** Wall-clock time the current running timer was (re)started. */
+    private readonly startedAt;
+    show(message: string, options?: BpxToastOptions): number;
+    /** Pause a toast's auto-dismiss countdown (e.g. while hovered). */
+    pause(id: number): void;
+    /** Resume a paused countdown with whatever time was left. */
+    resume(id: number): void;
+    private startTimer;
+    success(message: string, options?: BpxToastOptions): number;
+    error(message: string, options?: BpxToastOptions): number;
+    warning(message: string, options?: BpxToastOptions): number;
+    info(message: string, options?: BpxToastOptions): number;
+    dismiss(id: number): void;
+    clear(): void;
+    private ensureContainer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
+}
+
+/**
+ * Opens a `<bpx-menu>` from the element it's placed on (typically a button).
+ *
+ * ```html
+ * <button bpx-button [bpxMenuTriggerFor]="menu">Actions</button>
+ * ```
+ */
+declare class MenuTrigger {
+    readonly menu: _angular_core.InputSignal<Menu>;
+    private readonly overlay;
+    private readonly el;
+    private readonly vcr;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private overlayRef?;
+    private closedSub?;
+    constructor();
+    protected toggle(): void;
+    protected onArrowDown(event: Event): void;
+    private open;
+    private close;
+    private ensureOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTrigger, "[bpxMenuTriggerFor]", ["bpxMenuTrigger"], { "menu": { "alias": "bpxMenuTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A column definition for `<bpx-table>`. */
+interface BpxColumn {
+    key: string;
+    header: string;
+    sortable?: boolean;
+    align?: 'start' | 'center' | 'end';
+    /** Any CSS width, e.g. `'40%'` or `'8rem'`. */
+    width?: string;
+}
+interface BpxSort {
+    key: string;
+    direction: 'asc' | 'desc';
+}
+/**
+ * A data table with column-config, click-to-sort, row selection (built on
+ * `bpx-checkbox`), an optional sticky header, and custom cell templates via
+ * `[bpxCell]`.
+ *
+ * ```html
+ * <bpx-table [columns]="cols" [data]="rows" selectable [(selected)]="picked">
+ *   <ng-template bpxCell="status" let-row>
+ *     <bpx-badge [color]="row.color">{{ row.status }}</bpx-badge>
+ *   </ng-template>
+ * </bpx-table>
+ * ```
+ */
+declare class Table<T = Record<string, unknown>> {
+    readonly columns: _angular_core.InputSignal<BpxColumn[]>;
+    readonly data: _angular_core.InputSignal<T[]>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Active sort. Two-way bindable. */
+    readonly sort: _angular_core.ModelSignal<BpxSort | null>;
+    /** Selected rows (by reference). Two-way bindable. */
+    readonly selected: _angular_core.ModelSignal<T[]>;
+    private readonly cellDefs;
+    protected readonly sortedData: _angular_core.Signal<T[]>;
+    private readonly selectedCount;
+    protected readonly allSelected: _angular_core.Signal<boolean>;
+    protected readonly someSelected: _angular_core.Signal<boolean>;
+    protected readonly colspan: _angular_core.Signal<number>;
+    protected cellValue(row: T, key: string): unknown;
+    protected cellTemplate(key: string): TemplateRef<unknown> | null;
+    protected ariaSort(col: BpxColumn): 'ascending' | 'descending' | 'none' | null;
+    protected toggleSort(col: BpxColumn): void;
+    protected isSelected(row: T): boolean;
+    protected toggleRow(row: T): void;
+    protected toggleAll(checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Table<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Table<any>, "bpx-table", ["bpxTable"], { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; "selected": "selectedChange"; }, ["cellDefs"], never, true, never>;
+}
+
+/**
+ * Marks an `<ng-template>` as the custom cell renderer for a column, keyed by
+ * the column's `key`. The row is the template's implicit context.
+ *
+ * ```html
+ * <ng-template bpxCell="status" let-row>
+ *   <bpx-badge [color]="row.active ? 'success' : 'neutral'">{{ row.status }}</bpx-badge>
+ * </ng-template>
+ * ```
+ */
+declare class BpxCellDef {
+    readonly column: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BpxCellDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BpxCellDef, "[bpxCell]", never, { "column": { "alias": "bpxCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Type vocabulary for `<bpx-pivot-grid>`.
+ *
+ * The grid mirrors an Excel PivotTable: fields are dragged into four areas —
+ * Rows, Columns, Values and Filters — and the engine cross-tabulates the source
+ * data into a nested, collapsible matrix with subtotals and grand totals.
+ */
+/** Aggregation applied to a value field. Mirrors Excel's "Summarize by" list. */
+type BpxPivotAggregation = 'sum' | 'count' | 'avg' | 'min' | 'max' | 'countDistinct';
+/** The four drop areas of a pivot layout. */
+type BpxPivotArea = 'rows' | 'columns' | 'values' | 'filters';
+/**
+ * Declares a field the pivot can work with. `key` is the property read off each
+ * source record; everything else is presentation. Fields are the palette the
+ * user drags from — where a field ends up (rows/columns/values) is layout, held
+ * separately in {@link BpxPivotConfig}.
+ */
+interface BpxPivotField {
+    /** Property key on each source record. */
+    key: string;
+    /** Display name. Defaults to `key`. */
+    label?: string;
+    /**
+     * `dimension` fields group (go in Rows/Columns/Filters); `measure` fields are
+     * summarized (go in Values). A field may be usable as either — this is just
+     * the default area suggested by the field pane. Defaults to inference from
+     * the first non-null value (number → measure, else dimension).
+     */
+    kind?: 'dimension' | 'measure';
+    /** Default aggregation when dropped into Values. Defaults to `sum`. */
+    defaultAggregation?: BpxPivotAggregation;
+    /** Formats an aggregated numeric cell for this field, e.g. currency. */
+    format?: (value: number) => string;
+    /** Formats a group label (dimension member) for headers. */
+    formatLabel?: (value: unknown) => string;
+}
+/** A field placed in the Values area, with the aggregation to apply. */
+interface BpxPivotValue {
+    key: string;
+    aggregation: BpxPivotAggregation;
+    /** Overrides the column caption. Defaults to e.g. "Sum of Revenue". */
+    label?: string;
+}
+/**
+ * A value filter on a dimension field. When `included` is set, only records
+ * whose value (stringified) is in the list survive; `undefined` means "all".
+ */
+interface BpxPivotFilter {
+    key: string;
+    included?: string[];
+}
+/** How an axis is ordered. */
+interface BpxPivotSort {
+    /** `'label'` sorts groups by their member label. `'value'` sorts row groups
+     *  by a value column (identified by `measure`). */
+    by: 'label' | 'value';
+    direction: 'asc' | 'desc';
+    /** Index into the flattened value-column list — required when `by` is `'value'`. */
+    measure?: number;
+}
+/**
+ * The full pivot layout. This is what `<bpx-pivot-grid>` takes as a two-way
+ * `[(config)]` — the field pane mutates it, and consumers can seed it.
+ */
+interface BpxPivotConfig {
+    /** Dimension field keys nested outer→inner down the row axis. */
+    rows: string[];
+    /** Dimension field keys nested outer→inner across the column axis. */
+    columns: string[];
+    /** Measures shown as value columns, in order. */
+    values: BpxPivotValue[];
+    /** Report filters applied before pivoting. */
+    filters: BpxPivotFilter[];
+    /** Ordering of the row axis. Defaults to label-ascending. */
+    rowSort?: BpxPivotSort;
+    /** Ordering of the column axis. Defaults to label-ascending. */
+    columnSort?: BpxPivotSort;
+}
+/** One measure column resolved against one column-group leaf. */
+interface BpxPivotLeafColumn {
+    /** Stable id used for cell lookup and `track`. */
+    id: string;
+    /** The column-group path this measure sits under (empty when no col fields). */
+    path: string[];
+    value: BpxPivotValue;
+    /** Caption, e.g. "Sum of Revenue". */
+    label: string;
+    align: 'start' | 'end';
+    /** True for the trailing grand-total measure columns. */
+    grandTotal: boolean;
+}
+/** A node in the column header tree (for rendering the banded header). */
+interface BpxPivotColumnNode {
+    key: string;
+    label: string;
+    path: string[];
+    depth: number;
+    children: BpxPivotColumnNode[];
+    /** Number of leaf measure-columns spanned — the header cell's colspan. */
+    span: number;
+}
+/** A single aggregated data cell. */
+interface BpxPivotCell {
+    /** Raw aggregated number (NaN when empty). */
+    value: number;
+    /** Pre-formatted display string. */
+    display: string;
+    /** True for subtotal / grand-total cells (styled distinctly). */
+    total: boolean;
+}
+/** A node in the row axis tree. */
+interface BpxPivotRowNode {
+    /** Path of member values from the root (identity for expand state + track). */
+    path: string[];
+    key: string;
+    label: string;
+    depth: number;
+    children: BpxPivotRowNode[];
+    /** Cells aligned to the engine's flat leaf-column order (incl. grand-total col). */
+    cells: BpxPivotCell[];
+    /** Whether this node has children that can be expanded. */
+    expandable: boolean;
+    /** A grand-total row sits at the bottom, spanning all row-header columns. */
+    grandTotal: boolean;
+}
+/** Everything the template needs to draw the grid. */
+interface BpxPivotModel {
+    /** Leaf measure columns in render order (grand-total cols appended last). */
+    leafColumns: BpxPivotLeafColumn[];
+    /** Column-group header nodes per column-field depth (outer→inner). Empty when
+     *  there are no column fields. Used to render the banded header rows. */
+    columnLevels: BpxPivotColumnNode[][];
+    /** Root-level row nodes (grand total appended last when enabled). */
+    rows: BpxPivotRowNode[];
+    /** Field labels forming the row axis (for the corner header cells). */
+    rowFields: string[];
+    /** Number of column-field levels (`config.columns.length`). */
+    columnFieldCount: number;
+    /** Number of value measures (`config.values.length`). */
+    valueCount: number;
+    /** True when a grand-total column band is present (column fields exist). */
+    hasGrandTotalColumn: boolean;
+}
+
+/** A record the pivot can read. Consumers pass their own row objects. */
+type PivotRecord = Record<string, unknown>;
+/** Options controlling what the engine emits (mostly wired from grid inputs). */
+interface PivotEngineOptions {
+    /** Append a grand-total row across everything. Default true. */
+    grandTotalRow?: boolean;
+    /** Append a grand-total column when column fields exist. Default true. */
+    grandTotalColumn?: boolean;
+    /** Show subtotal rows for parent groups. Default true. When false, only leaf
+     *  rows carry values (parents render as bare labels). */
+    subtotals?: boolean;
+}
+/**
+ * Cross-tabulate `data` into a full pivot model according to `config`. Pure and
+ * synchronous — the grid calls this inside a `computed()` so it re-runs only
+ * when data/config change.
+ */
+declare function computePivot(data: PivotRecord[], fields: BpxPivotField[], config: BpxPivotConfig, options?: PivotEngineOptions): BpxPivotModel;
+/**
+ * Flatten a row tree into visible rows given a set of collapsed path-keys. The
+ * grid uses this for rendering (and virtualization) so expand/collapse never
+ * re-runs the aggregation.
+ */
+declare function flattenRows(rows: BpxPivotRowNode[], collapsed: ReadonlySet<string>): BpxPivotRowNode[];
+/** Stable identity for a row node (used for expand state + `track`). */
+declare function rowKey(node: BpxPivotRowNode): string;
+/** List the distinct member labels for a field, for the filter checkbox list. */
+declare function distinctMembers(data: PivotRecord[], fields: BpxPivotField[], key: string): string[];
+
+/**
+ * An Excel-style pivot grid. Give it flat `data` and a set of `fields`, then
+ * either seed a `[(config)]` (which dimensions go on rows/columns/values) or let
+ * users build it live by dragging fields in the field pane.
+ *
+ * It cross-tabulates the data into a nested, collapsible matrix with per-group
+ * subtotals and grand totals, six aggregations, click-to-sort headers and
+ * Excel-style value filters.
+ *
+ * ```html
+ * <bpx-pivot-grid
+ *   [data]="sales"
+ *   [fields]="fields"
+ *   [(config)]="config"
+ *   fieldPane
+ * />
+ * ```
+ */
+declare class PivotGrid<T = PivotRecord> {
+    /** Flat source records to pivot. */
+    readonly data: _angular_core.InputSignal<T[]>;
+    /** Field catalogue — the palette users pivot by. */
+    readonly fields: _angular_core.InputSignal<BpxPivotField[]>;
+    /** The pivot layout. Two-way bindable; the field pane mutates it. */
+    readonly config: _angular_core.ModelSignal<BpxPivotConfig>;
+    /** Show the drag-and-drop field pane alongside the grid. */
+    readonly fieldPane: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Append a grand-total row across everything. */
+    readonly grandTotalRow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Append a grand-total column when column fields exist. */
+    readonly grandTotalColumn: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Render subtotal rows for parent groups. */
+    readonly subtotals: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Keep the header (and row-label column) pinned while the body scrolls. */
+    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Max height of the scroll area, e.g. `'480px'`. Unset = grow to content. */
+    readonly maxHeight: _angular_core.InputSignal<string | undefined>;
+    /** Collapsed row-node keys. Everything is expanded by default (Excel-like). */
+    private readonly collapsed;
+    /** Data as plain records — the engine and pane read fields off these. */
+    protected readonly records: _angular_core.Signal<PivotRecord[]>;
+    /** The cross-tabulated model — recomputes only when data/config/opts change. */
+    protected readonly model: _angular_core.Signal<_tristan_stavast_blueprintx.BpxPivotModel>;
+    /** Visible rows after applying expand/collapse. */
+    protected readonly visibleRows: _angular_core.Signal<BpxPivotRowNode[]>;
+    /** Column-band level indices, for the `@for` over header rows. */
+    protected readonly columnLevelIndexes: _angular_core.Signal<number[]>;
+    /** Corner-cell rowspan: all band rows plus the measure-caption row. */
+    protected readonly cornerRowspan: _angular_core.Signal<number>;
+    /** Caption for the row-label corner (the nested row field names). */
+    protected readonly rowLabelHeader: _angular_core.Signal<string>;
+    protected rowNodeKey: typeof rowKey;
+    protected isCollapsed(node: BpxPivotRowNode): boolean;
+    protected toggle(node: BpxPivotRowNode): void;
+    /** Expand or collapse every group at once (toolbar affordance). */
+    protected setAllCollapsed(collapse: boolean): void;
+    protected sortRowLabelDir(): 'asc' | 'desc' | null;
+    protected sortMeasureDir(index: number): 'asc' | 'desc' | null;
+    protected sortColumnsDir(): 'asc' | 'desc' | null;
+    protected cycleRowLabelSort(): void;
+    protected cycleMeasureSort(index: number): void;
+    protected cycleColumnSort(): void;
+    protected trackColumn: (_: number, col: BpxPivotLeafColumn) => string;
+    private patch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PivotGrid<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PivotGrid<any>, "bpx-pivot-grid", ["bpxPivotGrid"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "fieldPane": { "alias": "fieldPane"; "required": false; "isSignal": true; }; "grandTotalRow": { "alias": "grandTotalRow"; "required": false; "isSignal": true; }; "grandTotalColumn": { "alias": "grandTotalColumn"; "required": false; "isSignal": true; }; "subtotals": { "alias": "subtotals"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
+}
+
+/** A field resolved for display in one of the pane's area boxes. */
+interface PaneChip {
+    key: string;
+    label: string;
+    /** Only set for Values chips. */
+    aggregation?: BpxPivotAggregation;
+    /** True when a value filter is narrowing this dimension. */
+    filtered: boolean;
+}
+/**
+ * The Excel-style "PivotTable Fields" pane: a list of available fields on top,
+ * and four drop areas (Filters, Columns, Rows, Values) below. Drag fields
+ * between areas to reshape the pivot; pick an aggregation per value; filter the
+ * members of any dimension. Binds to the same `[(config)]` as the grid.
+ */
+declare class PivotFieldPane {
+    readonly fields: _angular_core.InputSignal<BpxPivotField[]>;
+    readonly data: _angular_core.InputSignal<PivotRecord[]>;
+    readonly config: _angular_core.ModelSignal<BpxPivotConfig>;
+    private readonly registry;
+    constructor();
+    readonly aggregations: {
+        value: BpxPivotAggregation;
+        label: string;
+    }[];
+    /** Which dimension's filter panel is open (by field key), or null. */
+    protected readonly openFilter: _angular_core.WritableSignal<string | null>;
+    private label;
+    private isFiltered;
+    /** Keys already placed somewhere — hidden from the "available" list. */
+    private readonly usedKeys;
+    protected readonly available: _angular_core.Signal<PaneChip[]>;
+    protected readonly rowChips: _angular_core.Signal<PaneChip[]>;
+    protected readonly columnChips: _angular_core.Signal<PaneChip[]>;
+    protected readonly filterChips: _angular_core.Signal<PaneChip[]>;
+    protected readonly valueChips: _angular_core.Signal<PaneChip[]>;
+    protected onDrop(event: CdkDragDrop<PaneChip[]>, target: BpxPivotArea | 'available'): void;
+    private reorder;
+    private removeKey;
+    private addKey;
+    private newValue;
+    /** Remove a chip from its area (the × button). */
+    protected remove(key: string): void;
+    /** Change the aggregation on a Values chip. */
+    protected changeAggregation(index: number, agg: string): void;
+    protected toggleFilterPanel(key: string): void;
+    protected membersFor(key: string): string[];
+    /** "(Select All)" is fully checked when no filter narrows the field. */
+    protected allSelected(key: string): boolean;
+    /** Indeterminate when some — but not all — members are included. */
+    protected partiallySelected(key: string): boolean;
+    protected memberChecked(key: string, member: string): boolean;
+    protected toggleMember(key: string, member: string): void;
+    protected setAllMembers(key: string, checked: boolean): void;
+    private setIncluded;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PivotFieldPane, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PivotFieldPane, "bpx-pivot-field-pane", ["bpxPivotFieldPane"], { "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
+}
+
+/** A single command in the palette. */
+interface BpxCommand {
+    id: string;
+    label: string;
+    /** Short trailing hint, e.g. a shortcut or category. */
+    hint?: string;
+    icon?: string;
+    /** Extra text matched by the search (synonyms, category…). */
+    keywords?: string;
+    run?: () => void;
+}
+/**
+ * A ⌘K-style command palette: a centered overlay with fuzzy(ish) search and
+ * keyboard-driven results. Toggle with `[(open)]` or the built-in ⌘K / Ctrl+K.
+ *
+ * ```html
+ * <bpx-command-palette [(open)]="open" [commands]="commands" (run)="handle($event)" />
+ * ```
+ */
+declare class CommandPalette {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly commands: _angular_core.InputSignal<BpxCommand[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Enable the built-in ⌘K / Ctrl+K toggle. */
+    readonly hotkey: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly run: _angular_core.OutputEmitterRef<BpxCommand>;
+    protected readonly query: _angular_core.ModelSignal<string>;
+    protected readonly activeIndex: _angular_core.ModelSignal<number>;
+    protected readonly filtered: _angular_core.Signal<BpxCommand[]>;
+    private readonly baseId;
+    protected readonly listId: string;
+    private readonly tpl;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly isBrowser;
+    private overlayRef?;
+    constructor();
+    protected onHotkey(event: Event): void;
+    protected onSearch(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected select(cmd: BpxCommand): void;
+    protected optionId(index: number): string;
+    private close;
+    private attach;
+    private detach;
+    private ensureOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandPalette, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandPalette, "bpx-command-palette", ["bpxCommandPalette"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "commands": { "alias": "commands"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "run": "run"; "query": "queryChange"; "activeIndex": "activeIndexChange"; }, never, never, true, never>;
+}
+
+/**
+ * A floating panel of arbitrary content, opened by `[bpxPopoverTriggerFor]`.
+ * Renders nothing inline until opened.
+ *
+ * ```html
+ * <button bpx-button [bpxPopoverTriggerFor]="pop">Filters</button>
+ * <bpx-popover #pop>…any content…</bpx-popover>
+ * ```
+ */
+declare class Popover {
+    readonly template: _angular_core.Signal<TemplateRef<any>>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Popover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Popover, "bpx-popover", ["bpxPopover"], {}, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/** Opens a `<bpx-popover>` from the element it's placed on. */
+declare class PopoverTrigger {
+    readonly popover: _angular_core.InputSignal<Popover>;
+    private readonly overlay;
+    private readonly el;
+    private readonly vcr;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private overlayRef?;
+    private closedSub?;
+    constructor();
+    protected toggle(): void;
+    private open;
+    private close;
+    private ensureOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTrigger, "[bpxPopoverTriggerFor]", ["bpxPopoverTrigger"], { "popover": { "alias": "bpxPopoverTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type BpxDrawerSide = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * A panel that slides in from an edge of the viewport. CDK-overlay backed with
+ * focus trap and scroll lock; controlled with `[(open)]`.
+ *
+ * ```html
+ * <button bpx-button (click)="open.set(true)">Open</button>
+ * <bpx-drawer [(open)]="open" side="right" title="Filters">…</bpx-drawer>
+ * ```
+ */
+declare class Drawer {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly side: _angular_core.InputSignal<BpxDrawerSide>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disableClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly titleId: string;
+    private readonly tpl;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly isBrowser;
+    private overlayRef?;
+    constructor();
+    protected close(): void;
+    private attach;
+    private detach;
+    private ensureOverlay;
+    private positionFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Drawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Drawer, "bpx-drawer", ["bpxDrawer"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*", "[bpxDrawerFooter]"], true, never>;
+}
+
+interface BpxBreadcrumb {
+    label: string;
+    /** Optional href — renders an anchor. Omit to render a button that emits `(navigate)`. */
+    href?: string;
+    icon?: string;
+}
+/**
+ * A breadcrumb trail. The last item is rendered as the current page.
+ *
+ * ```html
+ * <bpx-breadcrumbs [items]="crumbs" (navigate)="go($event)" />
+ * ```
+ */
+declare class Breadcrumbs {
+    readonly items: _angular_core.InputSignal<BpxBreadcrumb[]>;
+    readonly navigate: _angular_core.OutputEmitterRef<BpxBreadcrumb>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Breadcrumbs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Breadcrumbs, "bpx-breadcrumbs", ["bpxBreadcrumbs"], { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "navigate": "navigate"; }, never, never, true, never>;
+}
+
+/**
+ * A single step within `<bpx-stepper>`. Its content shows only while active.
+ */
+declare class Step {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Step, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Step, "bpx-step", ["bpxStep"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A stepped process indicator with numbered markers, completed check-marks, and
+ * an active step panel. Compose from `<bpx-step>` children; `[(activeIndex)]`
+ * controls the current step.
+ *
+ * ```html
+ * <bpx-stepper [(activeIndex)]="step">
+ *   <bpx-step label="Account">…</bpx-step>
+ *   <bpx-step label="Profile">…</bpx-step>
+ *   <bpx-step label="Done">…</bpx-step>
+ * </bpx-stepper>
+ * ```
+ */
+declare class Stepper {
+    readonly steps: _angular_core.Signal<readonly Step[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    /** When true, steps can't be jumped to by clicking their header. */
+    readonly linear: _angular_core.InputSignal<boolean>;
+    constructor();
+    protected select(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Stepper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Stepper, "bpx-stepper", ["bpxStepper"], { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["steps"], ["*"], true, never>;
+}
+
+/**
+ * A compact single-select control — a row of segments where one is active.
+ * Works standalone with `[(value)]` and as a form control. Arrow keys move the
+ * selection.
+ *
+ * ```html
+ * <bpx-segmented [options]="views" [(value)]="view" />
+ * ```
+ */
+declare class Segmented<T = string> {
+    readonly options: _angular_core.InputSignal<BpxOption<T>[]>;
+    readonly value: _angular_core.ModelSignal<T | null>;
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private readonly el;
+    private onChange;
+    protected onTouched: () => void;
+    protected select(option: BpxOption<T>): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected tabindex(option: BpxOption<T>): number;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Segmented<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Segmented<any>, "bpx-segmented", ["bpxSegmented"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Which grid the calendar is currently showing. */
+type CalendarView = 'days' | 'months' | 'years';
+/**
+ * A calendar with day, month and year views. Usable on its own with `[(value)]`,
+ * and used by `bpx-date-picker` as the popup body. Click the header label to
+ * zoom out (day → month → year) and jump across time without paging one month
+ * at a time. Fully keyboard operable in every view: arrows move within the grid,
+ * Home/End jump to the period edges, PageUp/PageDown step by the larger unit,
+ * Enter/Space select or drill in, Escape steps back out.
+ *
+ * ```html
+ * <bpx-calendar [(value)]="date" [min]="today" />
+ * ```
+ */
+declare class Calendar {
+    /** The selected date. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    /** Earliest selectable day (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable day (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Extra predicate to disable individual days (holidays, weekends, …). */
+    readonly dateDisabled: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** First column of the week: 0 = Sunday (default), 1 = Monday. */
+    readonly weekStartsOn: _angular_core.InputSignal<0 | 1>;
+    /** BCP-47 locale for month and weekday names. Defaults to the runtime locale. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Move DOM focus to the active cell once rendered (used when opened in a popup). */
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires when a day is chosen (also updates `value`). */
+    readonly dateSelected: _angular_core.OutputEmitterRef<Date>;
+    /** Fires on Escape from the day view — lets a host popup close itself. */
+    readonly escaped: _angular_core.OutputEmitterRef<void>;
+    private readonly today;
+    protected readonly view: _angular_core.WritableSignal<CalendarView>;
+    /** First-of-month anchoring the currently shown period. */
+    protected readonly viewDate: _angular_core.WritableSignal<Date>;
+    /** The cell that owns the roving tabindex / keyboard focus. */
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    private readonly cells;
+    /** Set right before a keyboard/drill move so the effect knows to grab focus. */
+    private pendingFocus;
+    constructor();
+    /** Six weeks of seven days covering the visible month (plus spill-over days). */
+    protected readonly weeks: _angular_core.Signal<Date[][]>;
+    protected readonly weekdays: _angular_core.Signal<string[]>;
+    /** The 12 months of the visible year, in rows of three. */
+    protected readonly monthRows: _angular_core.Signal<Date[][]>;
+    /** A 12-year window around the visible decade (one padding year each end). */
+    protected readonly yearRows: _angular_core.Signal<Date[][]>;
+    protected readonly headerLabel: _angular_core.Signal<string>;
+    /** The larger period is empty within range → hide the way there. */
+    protected readonly canPrev: _angular_core.Signal<boolean>;
+    protected readonly canNext: _angular_core.Signal<boolean>;
+    protected readonly focusKey: _angular_core.Signal<string>;
+    protected dayKey(d: Date): string;
+    protected monthKey(d: Date): string;
+    protected yearKey(d: Date): string;
+    protected isSelected(d: Date): boolean;
+    protected isToday(d: Date): boolean;
+    protected isOutsideMonth(d: Date): boolean;
+    protected isDisabled(d: Date): boolean;
+    protected isMonthSelected(d: Date): boolean;
+    protected isMonthCurrent(d: Date): boolean;
+    protected isMonthDisabled(d: Date): boolean;
+    protected isYearSelected(d: Date): boolean;
+    protected isYearCurrent(d: Date): boolean;
+    protected isYearOutside(d: Date): boolean;
+    protected isYearDisabled(d: Date): boolean;
+    protected monthName(d: Date): string;
+    /** Page the visible period by the header arrows (month / year / decade). */
+    protected step(dir: 1 | -1): void;
+    private shiftFocusAndView;
+    /** Zoom out one level: day → month → year. */
+    protected drillUp(): void;
+    private setView;
+    protected selectDate(d: Date): void;
+    /** Choose a month → drop into its day view. */
+    protected pickMonth(cell: Date): void;
+    /** Choose a year → drop into its month view. */
+    protected pickYear(cell: Date): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private onEnter;
+    /** Compute the next focus target for an arrow/Home/End/Page key, per view. */
+    private nextFocus;
+    private moveFocus;
+    /** Bring the visible period into line with the focused cell after a move. */
+    private syncViewToFocus;
+    /** Move DOM focus onto the currently focused cell (used on popup open). */
+    focusActiveCell(): void;
+    private decadeStart;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Calendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Calendar, "bpx-calendar", ["bpxCalendar"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateDisabled": { "alias": "dateDisabled"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "dateSelected": "dateSelected"; "escaped": "escaped"; }, never, never, true, never>;
+}
+
+/**
+ * A date field that opens a `bpx-calendar` in a CDK overlay. Works standalone
+ * with `[(value)]` and as a form control via `formControlName` / `[(ngModel)]`.
+ * The displayed text is formatted with `Intl.DateTimeFormat` — control it with
+ * `[displayFormat]` and `[locale]`.
+ *
+ * ```html
+ * <bpx-date-picker [(value)]="date" [min]="today" clearable />
+ * <bpx-date-picker formControlName="dob" [displayFormat]="{ dateStyle: 'full' }" />
+ * ```
+ */
+declare class DatePicker implements ControlValueAccessor {
+    /** The selected date. Two-way bindable via `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<BpxSize>;
+    /** Earliest selectable day (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable day (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Extra predicate to disable individual days. */
+    readonly dateDisabled: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** First column of the week: 0 = Sunday (default), 1 = Monday. */
+    readonly weekStartsOn: _angular_core.InputSignal<0 | 1>;
+    /** `Intl.DateTimeFormat` options for the field's displayed text. */
+    readonly displayFormat: _angular_core.InputSignal<Intl.DateTimeFormatOptions>;
+    /** BCP-47 locale for the field text and calendar labels. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Show a clear button while a date is set. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error styling + `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly positions: _angular_cdk_overlay.ConnectedPosition[];
+    protected readonly displayValue: _angular_core.Signal<string>;
+    private onChange;
+    protected onTouched: () => void;
+    protected toggle(trigger: HTMLElement): void;
+    protected openPanel(): void;
+    protected close(returnFocusTo?: HTMLElement): void;
+    protected onSelect(date: Date, trigger: HTMLElement): void;
+    protected clear(event: Event): void;
+    protected onTriggerKeydown(event: KeyboardEvent, trigger: HTMLElement): void;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePicker, "bpx-date-picker", ["bpxDatePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateDisabled": { "alias": "dateDisabled"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A card whose surface lights up with a radial glow that follows the cursor.
+ *
+ * ```html
+ * <bpx-spotlight-card>…content…</bpx-spotlight-card>
+ * <bpx-spotlight-card color="var(--bpx-color-info)" [size]="320">…</bpx-spotlight-card>
+ * ```
+ */
+declare class SpotlightCard {
+    private readonly el;
+    /** Diameter of the glow in px. */
+    readonly size: _angular_core.InputSignal<number>;
+    /** Glow color (any CSS color / token). */
+    readonly color: _angular_core.InputSignal<string>;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpotlightCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpotlightCard, "bpx-spotlight-card", ["bpxSpotlightCard"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A card that tilts in 3D toward the pointer, with an optional moving glare.
+ *
+ * ```html
+ * <bpx-tilt-card>…content…</bpx-tilt-card>
+ * <bpx-tilt-card [max]="18" [glare]="false">…</bpx-tilt-card>
+ * ```
+ */
+declare class TiltCard {
+    private readonly el;
+    /** Maximum tilt in degrees. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Show the moving glare highlight. */
+    readonly glare: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TiltCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TiltCard, "bpx-tilt-card", ["bpxTiltCard"], { "max": { "alias": "max"; "required": false; "isSignal": true; }; "glare": { "alias": "glare"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Text with an animated gradient sweep.
+ *
+ * ```html
+ * <bpx-gradient-text>BlueprintX</bpx-gradient-text>
+ * <bpx-gradient-text from="#f43f5e" via="#a855f7" to="#22d3ee" [speed]="6">Custom</bpx-gradient-text>
+ * ```
+ */
+declare class GradientText {
+    readonly from: _angular_core.InputSignal<string>;
+    readonly via: _angular_core.InputSignal<string>;
+    readonly to: _angular_core.InputSignal<string>;
+    /** Animation duration in seconds. */
+    readonly speed: _angular_core.InputSignal<number>;
+    protected readonly gradient: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GradientText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GradientText, "bpx-gradient-text", ["bpxGradientText"], { "from": { "alias": "from"; "required": false; "isSignal": true; }; "via": { "alias": "via"; "required": false; "isSignal": true; }; "to": { "alias": "to"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Text with a shimmering light band that sweeps across the glyphs.
+ *
+ * ```html
+ * <bpx-shiny-text>Just shipped</bpx-shiny-text>
+ * <bpx-shiny-text base="#94a3b8" [speed]="4">Loading…</bpx-shiny-text>
+ * ```
+ */
+declare class ShinyText {
+    /** Base (dim) text color. */
+    readonly base: _angular_core.InputSignal<string>;
+    /** Sweep duration in seconds. */
+    readonly speed: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShinyText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShinyText, "bpx-shiny-text", ["bpxShinyText"], { "base": { "alias": "base"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Wraps content in a card with an animated gradient "beam" traveling around
+ * the border.
+ *
+ * ```html
+ * <bpx-border-beam>…content…</bpx-border-beam>
+ * <bpx-border-beam color="var(--bpx-color-success)" [speed]="3">…</bpx-border-beam>
+ * ```
+ */
+declare class BorderBeam {
+    /** Beam color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Rotation duration in seconds. */
+    readonly speed: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BorderBeam, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BorderBeam, "bpx-border-beam", ["bpxBorderBeam"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Makes any element magnetic: it's gently pulled toward the pointer while
+ * hovering and springs back on leave.
+ *
+ * ```html
+ * <button bpx-button bpxMagnetic>Hover me</button>
+ * <div bpxMagnetic [magnetStrength]="0.5">…</div>
+ * ```
+ */
+declare class Magnetic {
+    private readonly el;
+    /** How strongly the element follows the pointer (0–1). */
+    readonly strength: _angular_core.InputSignal<number>;
+    protected readonly tx: _angular_core.WritableSignal<number>;
+    protected readonly ty: _angular_core.WritableSignal<number>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Magnetic, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Magnetic, "[bpxMagnetic]", never, { "strength": { "alias": "magnetStrength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Emits a burst of little sparks from the point of a click.
+ *
+ * ```html
+ * <button bpx-button bpxClickSpark>Click me</button>
+ * <div bpxClickSpark sparkColor="var(--bpx-color-success)" [sparkCount]="12">…</div>
+ * ```
+ */
+declare class ClickSpark {
+    private readonly el;
+    private readonly renderer;
+    private readonly doc;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly count: _angular_core.InputSignal<number>;
+    readonly radius: _angular_core.InputSignal<number>;
+    /**
+     * Scatter radius (px) for where each spark is *born*. `0` spawns every spark
+     * exactly at the cursor; larger values pick a random origin within this radius
+     * of the click, so the burst looks like it erupts from an area, not a point.
+     */
+    readonly spread: _angular_core.InputSignal<number>;
+    constructor();
+    protected spark(event: MouseEvent): void;
+    private ensureStyles;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClickSpark, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClickSpark, "[bpxClickSpark]", never, { "color": { "alias": "sparkColor"; "required": false; "isSignal": true; }; "count": { "alias": "sparkCount"; "required": false; "isSignal": true; }; "radius": { "alias": "sparkRadius"; "required": false; "isSignal": true; }; "spread": { "alias": "sparkSpread"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A material-style ripple that expands from the pointer on press. Adds
+ * `position: relative` + `overflow: hidden` to its host.
+ *
+ * ```html
+ * <button bpx-button bpxRipple>Click</button>
+ * <div bpxRipple bpxRippleColor="var(--bpx-color-primary)">…</div>
+ * ```
+ */
+declare class Ripple {
+    private readonly el;
+    private readonly renderer;
+    private readonly doc;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected spawn(event: PointerEvent): void;
+    private ensureStyles;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Ripple, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Ripple, "[bpxRipple]", never, { "color": { "alias": "bpxRippleColor"; "required": false; "isSignal": true; }; "disabled": { "alias": "bpxRippleDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Animates a number from `from` to `to` with an ease-out curve.
+ *
+ * ```html
+ * <bpx-count-up [to]="1284" suffix="+" />
+ * <bpx-count-up [to]="99.9" [decimals]="1" suffix="%" />
+ * ```
+ */
+declare class CountUp {
+    readonly to: _angular_core.InputSignal<number>;
+    readonly from: _angular_core.InputSignal<number>;
+    readonly duration: _angular_core.InputSignal<number>;
+    readonly decimals: _angular_core.InputSignal<number>;
+    readonly prefix: _angular_core.InputSignal<string>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    private readonly doc;
+    private readonly isBrowser;
+    private readonly current;
+    private raf?;
+    protected readonly display: _angular_core.Signal<string>;
+    constructor();
+    private animate;
+    private cancel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CountUp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CountUp, "bpx-count-up", ["bpxCountUp"], { "to": { "alias": "to"; "required": true; "isSignal": true; }; "from": { "alias": "from"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Types out text one character at a time with a blinking cursor.
+ *
+ * ```html
+ * <bpx-typewriter text="Ship faster with BlueprintX." />
+ * <bpx-typewriter text="Hello" [speed]="90" />
+ * ```
+ */
+declare class Typewriter {
+    readonly text: _angular_core.InputSignal<string>;
+    /** Milliseconds per character. */
+    readonly speed: _angular_core.InputSignal<number>;
+    /** Delay before typing starts, in ms. */
+    readonly startDelay: _angular_core.InputSignal<number>;
+    private readonly isBrowser;
+    protected readonly shown: _angular_core.WritableSignal<string>;
+    protected readonly finished: _angular_core.Signal<boolean>;
+    private timer?;
+    constructor();
+    private start;
+    private clear;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Typewriter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Typewriter, "bpx-typewriter", ["bpxTypewriter"], { "text": { "alias": "text"; "required": true; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "startDelay": { "alias": "startDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Seamlessly scrolls its projected content on a loop. Pauses on hover.
+ *
+ * ```html
+ * <bpx-marquee [speed]="24">
+ *   <span>Ship faster</span><span>Design tokens</span><span>Accessible</span>
+ * </bpx-marquee>
+ * ```
+ */
+declare class Marquee {
+    /** Seconds for one full loop. */
+    readonly speed: _angular_core.InputSignal<number>;
+    readonly direction: _angular_core.InputSignal<"left" | "right">;
+    private readonly group;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Marquee, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Marquee, "bpx-marquee", ["bpxMarquee"], { "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An animated aurora backdrop — soft drifting color blobs behind your content.
+ *
+ * ```html
+ * <bpx-aurora>
+ *   <h1>BlueprintX</h1>
+ * </bpx-aurora>
+ * ```
+ */
+declare class Aurora {
+    readonly color1: _angular_core.InputSignal<string>;
+    readonly color2: _angular_core.InputSignal<string>;
+    readonly color3: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Aurora, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Aurora, "bpx-aurora", ["bpxAurora"], { "color1": { "alias": "color1"; "required": false; "isSignal": true; }; "color2": { "alias": "color2"; "required": false; "isSignal": true; }; "color3": { "alias": "color3"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Wraps content in a glowing, lightning-like animated border. The edge is
+ * distorted by an animated SVG turbulence + displacement filter, with layered
+ * blur for the neon glow.
+ *
+ * ```html
+ * <bpx-electric-border color="#5eb3ff">
+ *   <div style="padding: 2rem">Charged up</div>
+ * </bpx-electric-border>
+ * ```
+ */
+declare class ElectricBorder {
+    /** Bolt / glow color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Seconds for one flow cycle (lower = faster crackle). */
+    readonly speed: _angular_core.InputSignal<number>;
+    /** Border thickness in px. */
+    readonly thickness: _angular_core.InputSignal<number>;
+    /** Displacement strength — how wild the lightning wobble is. */
+    readonly intensity: _angular_core.InputSignal<number>;
+    /** Corner radius (any CSS length). */
+    readonly radius: _angular_core.InputSignal<string>;
+    /** Unique so multiple instances don't share one SVG filter. */
+    protected readonly filterId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElectricBorder, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElectricBorder, "bpx-electric-border", ["bpxElectricBorder"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "intensity": { "alias": "intensity"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An interactive particle-network backdrop: drifting dots linked by lines, with
+ * the lines reaching toward the cursor. Project your content on top.
+ *
+ * ```html
+ * <bpx-particles color="#6366f1">
+ *   <h1>BlueprintX</h1>
+ * </bpx-particles>
+ * ```
+ */
+declare class Particles {
+    /** Number of particles. */
+    readonly count: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Dot color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Line color; defaults to the dot color. */
+    readonly linkColor: _angular_core.InputSignal<string>;
+    /** Drift speed (px per frame, roughly). */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Max distance at which two dots (or a dot and the cursor) are linked. */
+    readonly linkDistance: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Dot radius in px. */
+    readonly radius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Link dots to the cursor on hover. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly canvasRef;
+    private readonly host;
+    private readonly isBrowser;
+    private ctx;
+    private dots;
+    private raf;
+    private ro?;
+    private readonly pointer;
+    constructor();
+    private start;
+    private stop;
+    private resize;
+    private seed;
+    private loop;
+    private draw;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Particles, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Particles, "bpx-particles", ["bpxParticles"], { "count": { "alias": "count"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "linkColor": { "alias": "linkColor"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "linkDistance": { "alias": "linkDistance"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A dotted-grid backdrop with an accent glow that follows the cursor — the dots
+ * near the pointer light up. Project your content on top.
+ *
+ * ```html
+ * <bpx-dot-grid accentColor="#6366f1">
+ *   <h1>BlueprintX</h1>
+ * </bpx-dot-grid>
+ * ```
+ */
+declare class DotGrid {
+    /** Spacing between dots, in px. */
+    readonly gap: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Base dot color. Defaults to a theme-aware subtle tint of the text color. */
+    readonly dotColor: _angular_core.InputSignal<string>;
+    /** Color of the dots lit under the cursor. */
+    readonly accentColor: _angular_core.InputSignal<string>;
+    /** Radius of the cursor spotlight, in px. */
+    readonly spotlightRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Light up dots under the cursor. When off, the grid is static. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly host;
+    protected onMove(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DotGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DotGrid, "bpx-dot-grid", ["bpxDotGrid"], { "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "dotColor": { "alias": "dotColor"; "required": false; "isSignal": true; }; "accentColor": { "alias": "accentColor"; "required": false; "isSignal": true; }; "spotlightRadius": { "alias": "spotlightRadius"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface MeteorStyle {
+    left: string;
+    delay: string;
+    duration: string;
+}
+/**
+ * A shower of shooting-star meteors streaking across the backdrop. Project your
+ * content on top.
+ *
+ * ```html
+ * <bpx-meteors [count]="24" color="#a5b4fc">
+ *   <h1>BlueprintX</h1>
+ * </bpx-meteors>
+ * ```
+ */
+declare class Meteors {
+    /** Number of meteors. */
+    readonly count: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Meteor and trail color. */
+    readonly color: _angular_core.InputSignal<string>;
+    protected readonly meteors: _angular_core.Signal<MeteorStyle[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Meteors, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Meteors, "bpx-meteors", ["bpxMeteors"], { "count": { "alias": "count"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A synthwave-style perspective grid that scrolls toward the horizon. Project
+ * your content on top.
+ *
+ * ```html
+ * <bpx-retro-grid color="#6366f1">
+ *   <h1>BlueprintX</h1>
+ * </bpx-retro-grid>
+ * ```
+ */
+declare class RetroGrid {
+    /** Grid line color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Seconds for one full scroll cycle (lower = faster). */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Grid cell size in px. */
+    readonly cellSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly speedS: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RetroGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RetroGrid, "bpx-retro-grid", ["bpxRetroGrid"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "cellSize": { "alias": "cellSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A soft, slowly shifting multi-color mesh gradient — a lively backdrop for
+ * heroes and cards. Project your content on top.
+ *
+ * ```html
+ * <bpx-gradient-mesh>
+ *   <h1>BlueprintX</h1>
+ * </bpx-gradient-mesh>
+ * ```
+ */
+declare class GradientMesh {
+    readonly color1: _angular_core.InputSignal<string>;
+    readonly color2: _angular_core.InputSignal<string>;
+    readonly color3: _angular_core.InputSignal<string>;
+    readonly color4: _angular_core.InputSignal<string>;
+    /** Seconds for one full drift cycle. */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly speedS: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GradientMesh, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GradientMesh, "bpx-gradient-mesh", ["bpxGradientMesh"], { "color1": { "alias": "color1"; "required": false; "isSignal": true; }; "color2": { "alias": "color2"; "required": false; "isSignal": true; }; "color3": { "alias": "color3"; "required": false; "isSignal": true; }; "color4": { "alias": "color4"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A backdrop where a soft colored spotlight follows the cursor across a grid or
+ * dot pattern. Project your content on top.
+ *
+ * ```html
+ * <bpx-spotlight color="#6366f1" pattern="grid">
+ *   <h1>BlueprintX</h1>
+ * </bpx-spotlight>
+ * ```
+ */
+declare class Spotlight {
+    /** Spotlight color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Spotlight diameter in px. */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Backdrop pattern under the glow. */
+    readonly pattern: _angular_core.InputSignal<"none" | "grid" | "dots">;
+    /** Pattern color. Defaults to a theme-aware subtle tint of the text color. */
+    readonly patternColor: _angular_core.InputSignal<string>;
+    /** Pattern cell size in px. */
+    readonly cellSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    protected readonly sizePx: _angular_core.Signal<string>;
+    protected readonly cellPx: _angular_core.Signal<string>;
+    private readonly host;
+    protected onMove(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Spotlight, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Spotlight, "bpx-spotlight", ["bpxSpotlight"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "patternColor": { "alias": "patternColor"; "required": false; "isSignal": true; }; "cellSize": { "alias": "cellSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A grid backdrop where the cell under the cursor lights up, snapping from cell
+ * to cell as you move. Project your content on top.
+ *
+ * ```html
+ * <bpx-grid-highlight color="#6366f1">
+ *   <h1>BlueprintX</h1>
+ * </bpx-grid-highlight>
+ * ```
+ */
+declare class GridHighlight {
+    /** Highlight color of the hovered cell. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Grid line color. Defaults to a theme-aware subtle tint of the text color. */
+    readonly lineColor: _angular_core.InputSignal<string>;
+    /** Cell size in px. */
+    readonly cellSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    protected readonly cellPx: _angular_core.Signal<string>;
+    private readonly host;
+    protected onMove(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridHighlight, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridHighlight, "bpx-grid-highlight", ["bpxGridHighlight"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "lineColor": { "alias": "lineColor"; "required": false; "isSignal": true; }; "cellSize": { "alias": "cellSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A canvas field of evenly-spaced dots that flee the cursor and ease back to
+ * their home positions. Project your content on top.
+ *
+ * ```html
+ * <bpx-repel-dots color="#6366f1">
+ *   <h1>BlueprintX</h1>
+ * </bpx-repel-dots>
+ * ```
+ */
+declare class RepelDots {
+    /** Distance between dots, in px. */
+    readonly spacing: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Dot color. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Dot radius, in px. */
+    readonly dotRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Radius of the cursor's influence, in px. */
+    readonly repelRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** How strongly dots are pushed away (0–1+). */
+    readonly strength: _angular_core.InputSignalWithTransform<number, unknown>;
+    private readonly canvasRef;
+    private readonly host;
+    private readonly isBrowser;
+    private ctx;
+    private dots;
+    private raf;
+    private ro?;
+    private readonly pointer;
+    constructor();
+    private start;
+    private stop;
+    private resize;
+    private seed;
+    private loop;
+    private draw;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RepelDots, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RepelDots, "bpx-repel-dots", ["bpxRepelDots"], { "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "dotRadius": { "alias": "dotRadius"; "required": false; "isSignal": true; }; "repelRadius": { "alias": "repelRadius"; "required": false; "isSignal": true; }; "strength": { "alias": "strength"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A backdrop with a gooey liquid-glass blob that follows the cursor. A trail of
+ * blobs chase the pointer and an SVG metaball filter melts them into one organic
+ * shape; that shape masks a real `backdrop-filter` layer, so the blob is actual
+ * frosted glass — it refracts the content behind it while it stretches and wobbles.
+ *
+ * ```html
+ * <bpx-glass-cursor color="#c7d2fe">
+ *   <h1>BlueprintX</h1>
+ * </bpx-glass-cursor>
+ * ```
+ */
+declare class GlassCursor {
+    /** Diameter of the leading blob, in px (trailing blobs taper down). */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Glass tint layered over the frosted backdrop. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Backdrop blur inside the glass, in px. */
+    readonly blur: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Backdrop saturation inside the glass (1 = unchanged). */
+    readonly saturation: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Refraction strength — how much the blob lenses the content behind it (SVG
+     * displacement scale). `0` disables the warp and leaves a plain frost. */
+    readonly distortion: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** How many blobs trail the cursor. More = longer, gooier tail. */
+    readonly count: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Follow easing per frame, 0–1. Lower = looser, longer liquid tail; higher =
+     * tighter and snappier.
+     */
+    readonly lag: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Park the blob at center when the cursor isn't over the surface. */
+    readonly idleCenter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly filterId: string;
+    protected readonly rimFilterId: string;
+    protected readonly refractId: string;
+    protected readonly gooGroupId: string;
+    protected readonly maskId: string;
+    protected readonly rimMaskId: string;
+    protected readonly maskUrl: _angular_core.Signal<string>;
+    protected readonly rimMaskUrl: _angular_core.Signal<string>;
+    protected readonly blurPx: _angular_core.Signal<string>;
+    /** Whether the refractive lens layer is active. */
+    protected readonly hasDistortion: _angular_core.Signal<boolean>;
+    /** The refraction backdrop-filter (warp + a hair of blur), or `none`. */
+    protected readonly refractFilter: _angular_core.Signal<string>;
+    /** Per-blob descriptors — the lead is full size, the tail tapers. */
+    protected readonly blobs: _angular_core.Signal<{
+        radius: number;
+    }[]>;
+    private readonly circles;
+    private readonly host;
+    private readonly isBrowser;
+    private readonly target;
+    private points;
+    private started;
+    private raf;
+    constructor();
+    private start;
+    private loop;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlassCursor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GlassCursor, "bpx-glass-cursor", ["bpxGlassCursor"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "saturation": { "alias": "saturation"; "required": false; "isSignal": true; }; "distortion": { "alias": "distortion"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "lag": { "alias": "lag"; "required": false; "isSignal": true; }; "idleCenter": { "alias": "idleCenter"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { Accordion, AccordionItem, Alert, Aurora, Avatar, Badge, BorderBeam, BpxCellDef, Breadcrumbs, Button, ButtonGroup, Calendar, Card, Checkbox, Chip, ChipSet, ClickSpark, ColorPicker, Combobox, CommandPalette, CopyButton, CountUp, DatePicker, Dialog, DotGrid, Drawer, ElectricBorder, FileUpload, Filter, GlassCursor, GradientMesh, GradientText, GridHighlight, Icon, IconRegistry, Input, LiquidGlass, Magnetic, Marquee, Menu, MenuItem, MenuTrigger, Meteors, MultiSelect, Pagination, Particles, PivotFieldPane, PivotGrid, Popover, PopoverTrigger, Progress, Radio, RadioGroup, RepelDots, RetroGrid, Ripple, ScrollArea, Segmented, Select, ShinyText, Skeleton, SkeletonLayout, Slider, Spinner, SplitButton, Spotlight, SpotlightCard, Step, Stepper, Switch, Tab, Table, Tabs, Textarea, TiltCard, ToastService, Tooltip, Typewriter, computePivot, distinctMembers, flattenRows, uniqueId };
+export type { BpxAvatarSize, BpxAvatarStatus, BpxBreadcrumb, BpxColor, BpxColumn, BpxCommand, BpxDrawerSide, BpxFileRejection, BpxIconDefinition, BpxInputType, BpxOption, BpxPivotAggregation, BpxPivotArea, BpxPivotCell, BpxPivotColumnNode, BpxPivotConfig, BpxPivotField, BpxPivotFilter, BpxPivotLeafColumn, BpxPivotModel, BpxPivotRowNode, BpxPivotSort, BpxPivotValue, BpxProgressShape, BpxSize, BpxSkeletonAnimation, BpxSkeletonPreset, BpxSkeletonVariant, BpxSort, BpxToast, BpxToastAction, BpxToastOptions, BpxToastType, BpxTone, BpxTooltipPosition, BpxVariant, PivotEngineOptions, PivotRecord };