@brickclay-org/ui 0.1.76 → 0.1.78

package/index.d.ts

@@ -1,9 +1,10 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, OnChanges, EventEmitter, ElementRef, Renderer2, SimpleChanges, AfterViewInit, QueryList, ComponentRef, Type, InjectionToken, ApplicationRef, EnvironmentInjector, ChangeDetectorRef } from '@angular/core';
+import { OnInit, OnDestroy, OnChanges, EventEmitter, ElementRef, Renderer2, SimpleChanges, AfterViewInit, QueryList, ComponentRef, Type, InjectionToken, ApplicationRef, EnvironmentInjector, ChangeDetectorRef, TemplateRef, WritableSignal } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, NgControl, NgModel } from '@angular/forms';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i1 from '@angular/common';
+import * as i1$3 from '@angular/cdk/drag-drop';
 import { CdkDragDrop, CdkDragMove, CdkDragStart } from '@angular/cdk/drag-drop';
 import { NgxMaskDirective } from 'ngx-mask';
 import * as i1$2 from '@angular/cdk/dialog';
@@ -915,6 +916,9 @@ declare class BkGrid<T = any> {
     actionClass: string;
     showNoRecords: boolean;
     noRecordFoundHeight: string;
+    /** Custom illustration for the empty state. Falls back to a built-in SVG when omitted. */
+    noRecordImgUrl?: string;
+    noRecordMessage: string;
     change: EventEmitter<{
         row: T;
         column: TableColumn<T>;
@@ -948,8 +952,9 @@ declare class BkGrid<T = any> {
     dropList(event: CdkDragDrop<T[]>): void;
     onDragMoved(event: CdkDragMove<any>): void;
     onDragStart(event: CdkDragStart<any>): void;
+    get noRecordImagePath(): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkGrid<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkGrid<any>, "bk-grid", never, { "draggable": { "alias": "draggable"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "result": { "alias": "result"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "actionIconClass": { "alias": "actionIconClass"; "required": false; }; "actionClass": { "alias": "actionClass"; "required": false; }; "showNoRecords": { "alias": "showNoRecords"; "required": false; }; "noRecordFoundHeight": { "alias": "noRecordFoundHeight"; "required": false; }; }, { "change": "change"; "actionClick": "actionClick"; "sortChange": "sortChange"; "dragDropChange": "dragDropChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkGrid<any>, "bk-grid", never, { "draggable": { "alias": "draggable"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "result": { "alias": "result"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "actionIconClass": { "alias": "actionIconClass"; "required": false; }; "actionClass": { "alias": "actionClass"; "required": false; }; "showNoRecords": { "alias": "showNoRecords"; "required": false; }; "noRecordFoundHeight": { "alias": "noRecordFoundHeight"; "required": false; }; "noRecordImgUrl": { "alias": "noRecordImgUrl"; "required": false; }; "noRecordMessage": { "alias": "noRecordMessage"; "required": false; }; }, { "change": "change"; "actionClick": "actionClick"; "sortChange": "sortChange"; "dragDropChange": "dragDropChange"; }, never, never, true, never>;
 }
 
 /** How an accent colour is applied to a control. */
@@ -969,9 +974,9 @@ interface Rgb {
 /** The neutral look used when there is no colour (or an unparseable one). */
 declare const NEUTRAL_APPEARANCE: ColorAppearance;
 /**
- * Parses hex and rgb()/rgba() colours. Named CSS colours ("red") are not
- * supported — they'd need a live DOM to resolve — and return null, which makes
- * the caller fall back to the neutral (uncoloured) appearance.
+ * Parses hex, rgb()/rgba() and hsl()/hsla() colours. Named CSS colours ("red")
+ * are not supported — they'd need a live DOM to resolve — and return null, which
+ * makes the caller fall back to the neutral (uncoloured) appearance.
  */
 declare function parseColor(input: string | null | undefined): Rgb | null;
 /**
@@ -1204,6 +1209,7 @@ type BkInputAutoComplete = 'on' | 'off' | 'name' | 'honorific-prefix' | 'given-n
 type BkInputAutoCapitalize = 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
 type BkInputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
 type IconOrientation = 'left' | 'right';
+type BkInputSize = 'default' | 'sm';
 interface CountryOption {
     code: string;
     name: string;
@@ -1222,6 +1228,8 @@ declare class BkInput implements OnInit, OnDestroy, AfterViewInit, ControlValueA
     hint: string;
     required: boolean;
     type: BkInputType;
+    /** 'sm' shrinks height, padding, font size and icon sizing for compact contexts (e.g. dropdown search boxes). */
+    size: BkInputSize;
     value: string;
     hasError: boolean;
     showErrorIcon: boolean;
@@ -1290,7 +1298,7 @@ declare class BkInput implements OnInit, OnDestroy, AfterViewInit, ControlValueA
     get currentInputType(): string;
     private writeMaskedViewValue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkInput, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkInput, "bk-input", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "dropSpecialCharacters": { "alias": "dropSpecialCharacters"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "showErrorIcon": { "alias": "showErrorIcon"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "autoCapitalize": { "alias": "autoCapitalize"; "required": false; }; "inputMode": { "alias": "inputMode"; "required": false; }; "iconSrc": { "alias": "iconSrc"; "required": false; }; "iconAlt": { "alias": "iconAlt"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "phone": { "alias": "phone"; "required": false; }; "countryCode": { "alias": "countryCode"; "required": false; }; "countryOptions": { "alias": "countryOptions"; "required": false; }; "iconOrientation": { "alias": "iconOrientation"; "required": false; }; "password": { "alias": "password"; "required": false; }; "showPassword": { "alias": "showPassword"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; }, { "input": "input"; "change": "change"; "focus": "focus"; "blur": "blur"; "clicked": "clicked"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkInput, "bk-input", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "dropSpecialCharacters": { "alias": "dropSpecialCharacters"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "value": { "alias": "value"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "showErrorIcon": { "alias": "showErrorIcon"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "autoCapitalize": { "alias": "autoCapitalize"; "required": false; }; "inputMode": { "alias": "inputMode"; "required": false; }; "iconSrc": { "alias": "iconSrc"; "required": false; }; "iconAlt": { "alias": "iconAlt"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "phone": { "alias": "phone"; "required": false; }; "countryCode": { "alias": "countryCode"; "required": false; }; "countryOptions": { "alias": "countryOptions"; "required": false; }; "iconOrientation": { "alias": "iconOrientation"; "required": false; }; "password": { "alias": "password"; "required": false; }; "showPassword": { "alias": "showPassword"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; }, { "input": "input"; "change": "change"; "focus": "focus"; "blur": "blur"; "clicked": "clicked"; }, never, never, true, never>;
 }
 
 declare class BkInputChips implements ControlValueAccessor, AfterViewInit {
@@ -2076,6 +2084,9 @@ declare class BKTooltipDirective implements OnInit, OnChanges, OnDestroy {
     onInteract(): void;
     onWindowChange(): void;
     private isTooltipContentEmpty;
+    /** Snap-hide with no fade: used when something else (a dropdown panel, another
+     *  tooltip) is opening right now, so the two never visibly overlap mid-fade. */
+    private hideTooltipInstant;
     private hideTooltip;
     private setupTooltipHoverListeners;
     private cleanupTooltipListeners;
@@ -2224,8 +2235,6 @@ declare class BkHierarchicalSelect implements ControlValueAccessor, AfterViewIni
     dropdownPosition: _angular_core.InputSignal<"top" | "bottom">;
     /** Key for option color (e.g. "color"). When set, option label and selected value use this color. */
     colorKey: _angular_core.InputSignal<string>;
-    /** Whether to show clear button when a value is selected. */
-    clearable: _angular_core.InputSignal<boolean>;
     /**
      * Show an accent dot beside each option, driven by `colorKey`, and tint the
      * control with the selected node's colour (same treatment as bk-status-select).
@@ -2237,6 +2246,8 @@ declare class BkHierarchicalSelect implements ControlValueAccessor, AfterViewIni
      * trees render exactly as before.
      */
     inheritColor: _angular_core.InputSignal<boolean>;
+    /** Whether to show clear button when a value is selected. */
+    clearable: _angular_core.InputSignal<boolean>;
     /** Optional anchor key to scope dropdown to one subtree (e.g. module/category key). */
     restrictKey: _angular_core.InputSignal<any>;
     hasError: _angular_core.InputSignal<boolean>;
@@ -2336,6 +2347,12 @@ declare class BkHierarchicalSelect implements ControlValueAccessor, AfterViewIni
     goBack(): void;
     onSearchInput(event: Event): void;
     selectItem(node: HierarchicalNode, event?: Event): void;
+    /**
+     * Select/deselect any node from its checkbox — parent, child or leaf, at any
+     * depth. Stops the event so a parent row's own handler doesn't also navigate
+     * into its children.
+     */
+    toggleParentSelection(node: HierarchicalNode, event?: Event): void;
     openFromLabel(event: MouseEvent): void;
     onClickOutside(e: Event): void;
     private _value;
@@ -2349,7 +2366,7 @@ declare class BkHierarchicalSelect implements ControlValueAccessor, AfterViewIni
     private findNodeByValue;
     handleClear(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkHierarchicalSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkHierarchicalSelect, "bk-hierarchical-select", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "valueKey": { "alias": "valueKey"; "required": false; "isSignal": true; }; "childrenKey": { "alias": "childrenKey"; "required": false; "isSignal": true; }; "clearTooltip": { "alias": "clearTooltip"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "iconAlt": { "alias": "iconAlt"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "allowParentSelection": { "alias": "allowParentSelection"; "required": false; "isSignal": true; }; "backToMainText": { "alias": "backToMainText"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; "isSignal": true; }; "colorKey": { "alias": "colorKey"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "inheritColor": { "alias": "inheritColor"; "required": false; "isSignal": true; }; "restrictKey": { "alias": "restrictKey"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; "clear": "clear"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkHierarchicalSelect, "bk-hierarchical-select", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "valueKey": { "alias": "valueKey"; "required": false; "isSignal": true; }; "childrenKey": { "alias": "childrenKey"; "required": false; "isSignal": true; }; "clearTooltip": { "alias": "clearTooltip"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "iconAlt": { "alias": "iconAlt"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "allowParentSelection": { "alias": "allowParentSelection"; "required": false; "isSignal": true; }; "backToMainText": { "alias": "backToMainText"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; "isSignal": true; }; "colorKey": { "alias": "colorKey"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "inheritColor": { "alias": "inheritColor"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "restrictKey": { "alias": "restrictKey"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; "clear": "clear"; }, never, never, true, never>;
 }
 
 type ToastSeverity = 'success' | 'error' | 'warn' | 'info' | 'default';
@@ -2493,6 +2510,9 @@ declare class BkColumnFilterService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<BkColumnFilterService>;
 }
 
+type BkColumnSelectVertical = 'top' | 'bottom';
+type BkColumnSelectHorizontal = 'left' | 'right';
+type BkColumnSelectPosition = `${BkColumnSelectVertical}-${BkColumnSelectHorizontal}`;
 declare class BkColumnSelect implements ControlValueAccessor, OnChanges {
     columnFilterService: BkColumnFilterService;
     searchable: boolean;
@@ -2502,8 +2522,15 @@ declare class BkColumnSelect implements ControlValueAccessor, OnChanges {
     isOpened: boolean;
     label: string;
     lefticon: string;
+    /** Corner the dropdown opens from, relative to the trigger button. */
+    position: BkColumnSelectPosition;
+    /** When true, flips each axis independently if there isn't enough viewport room for `position`. */
+    autoFlip: boolean;
     isOpenedChange: EventEmitter<boolean>;
     formBoxRef: ElementRef;
+    triggerRef?: ElementRef<HTMLElement>;
+    /** Corner actually rendered on — starts from `position`, auto-flipped on open when needed. */
+    resolvedPosition: BkColumnSelectPosition;
     /** Value bound via ngModel – only updated when user ticks/unticks a checkbox, never on search. */
     columnsFilterList: ColumnFilterOption[];
     search: string;
@@ -2512,6 +2539,12 @@ declare class BkColumnSelect implements ControlValueAccessor, OnChanges {
     constructor(columnFilterService: BkColumnFilterService);
     writeValue(value: ColumnFilterOption[] | null | undefined): void;
     ngOnChanges(changes: SimpleChanges): void;
+    /** Picks `position`, flipping each axis independently if the trigger doesn't have room for it. */
+    private computePlacement;
+    /** Flips `current` to its opposite when it doesn't have `needed` space and the opposite has more room. */
+    private flipIfShort;
+    /** Tailwind classes placing the panel on `resolvedPosition`'s corner of the trigger. */
+    get panelPositionClass(): string;
     private shouldLoadFromService;
     private loadColumnsFilterListFromService;
     registerOnChange(fn: (value: ColumnFilterOption[]) => void): void;
@@ -2525,7 +2558,7 @@ declare class BkColumnSelect implements ControlValueAccessor, OnChanges {
     onClick(event: Event): void;
     get list(): ColumnFilterOption[];
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkColumnSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkColumnSelect, "bk-column-select", never, { "searchable": { "alias": "searchable"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "cacheKey": { "alias": "cacheKey"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "isOpened": { "alias": "isOpened"; "required": false; }; "label": { "alias": "label"; "required": false; }; "lefticon": { "alias": "lefticon"; "required": false; }; }, { "isOpenedChange": "isOpenedChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkColumnSelect, "bk-column-select", never, { "searchable": { "alias": "searchable"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "cacheKey": { "alias": "cacheKey"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "isOpened": { "alias": "isOpened"; "required": false; }; "label": { "alias": "label"; "required": false; }; "lefticon": { "alias": "lefticon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "autoFlip": { "alias": "autoFlip"; "required": false; }; }, { "isOpenedChange": "isOpenedChange"; }, never, never, true, never>;
 }
 
 declare class BkFilePicker implements ControlValueAccessor, Validator {
@@ -2702,6 +2735,10 @@ declare class BkDropdown {
 
 type MenuOrientation = 'horizontal' | 'vertical';
 type MenuSubmenuMode = 'inline' | 'popup';
+type MenuTrigger = 'hover' | 'click';
+type MenuSize = 'default' | 'compact';
+/** Side a fly-out ended up on, once measured against the viewport. */
+type MenuPopupSide = 'right' | 'left' | 'down' | 'up';
 interface MenuItem {
     /** Unique id — matched against `activeItemId`. */
     id: string;
@@ -2713,6 +2750,17 @@ interface MenuItem {
     iconAlt?: string;
     /** Disables just this item (and blocks opening its submenu). */
     disabled?: boolean;
+    /** Heading shown above this item's children, titling the group. */
+    childrenLabel?: string;
+    /**
+     * Splits this item among its siblings into a labeled section — a heading
+     * above the run of siblings that share the same `groupLabel`, with a rule
+     * before each section after the first. Unlike `childrenLabel` (one heading
+     * for a whole `children` array), this groups items within a single flat
+     * list, so several named sections can sit in one always-visible panel (e.g.
+     * a mega-menu). Siblings without a `groupLabel` render ungrouped, as today.
+     */
+    groupLabel?: string;
     /** Nested items — presence of children turns this into an expandable node. */
     children?: MenuItem[];
 }
@@ -2723,21 +2771,46 @@ interface MenuItem {
  * - Orientation: `vertical` (stacked) / `horizontal` (menubar row).
  * - Items with `children` are expandable, shown with a chevron that rotates
  *   open/closed.
- * - Submenus render inline (accordion) or as pop-ups. Pop-ups adapt to the
- *   orientation: they drop *below* a horizontal top-level item and fly out to
- *   the *right* for vertical menus / deeper levels.
+ * - Submenus render inline (accordion) or as pop-ups, opened by hover or click.
+ *   Pop-ups adapt to the orientation: they drop *below* a horizontal top-level
+ *   item and fly out to the side for vertical menus / deeper levels. Side
+ *   fly-outs flip when the preferred side has no room; menubar drop-downs never
+ *   flip — they stay under their trigger and scroll instead.
  */
-declare class BkMenu {
+declare class BkMenu implements OnChanges, OnDestroy {
     private readonly host;
     items: MenuItem[];
     orientation: MenuOrientation;
     submenuMode: MenuSubmenuMode;
+    /**
+     * How pop-up submenus open: on `hover` (fly-out follows the pointer and
+     * closes when it leaves) or on `click` (stays put until you click the parent
+     * again, pick a leaf, or click outside). Inline submenus are always click.
+     */
+    trigger: MenuTrigger;
+    /** `compact` shrinks the type, padding and icons for dense layouts. */
+    size: MenuSize;
+    /** Fallback grace period for the pointer to cross the gap into a fly-out. */
+    private static readonly HOVER_CLOSE_DELAY_MS;
+    /**
+     * Hover mode only: how long (ms) a fly-out survives after the pointer leaves,
+     * giving it time to cross the gap into the panel. Raise it for menus whose
+     * fly-outs sit further from their trigger, or for touch-ish pointers.
+     */
+    hoverCloseDelay: number;
     /**
      * Keep only one submenu open per level: opening a parent collapses its
      * siblings (and their descendants) so the menu stays compact. Pop-up mode
      * always behaves this way; this input adds it to inline (accordion) mode.
      */
     singleOpen: boolean;
+    /**
+     * Tints an inline (accordion) submenu's whole block — title + rows — with
+     * the lightest gray token. Off by default. Pop-up submenus don't offer
+     * this: their padding/insets are different, and the panel's own border
+     * already sets it apart from the page.
+     */
+    submenuBackground: boolean;
     /** Id of the currently selected leaf item. Two-way bindable. */
     activeItemId: string;
     /** Tint item icons: dark by default, white on the active (dark) row. */
@@ -2752,33 +2825,81 @@ declare class BkMenu {
     itemClick: EventEmitter<MenuItem>;
     /** Ids of currently expanded/opened parent nodes. */
     private readonly openIds;
-    /** Viewport coordinates for each open fixed-position fly-out, keyed by id. */
-    readonly popupPos: Map<string, {
-        top: number;
-        left: number;
-    }>;
+    /** Viewport box for each open fixed-position fly-out, keyed by id. */
+    private readonly popupPos;
+    /** Side each open fly-out resolved to — drives the chevron and hover bridge. */
+    private readonly popupSide;
+    /**
+     * Fly-outs whose real size has been measured. Until then the panel is in the
+     * DOM (it has to be, to be measurable) but transparent, so the estimated
+     * position never flashes on the wrong side.
+     */
+    private readonly measuredIds;
+    /** Floor for a fly-out's height cap, so a trigger near the bottom edge still
+     *  gets a usable (scrollable) panel rather than a sliver. */
+    private static readonly MIN_POPUP_H;
+    /**
+     * Ceiling for a fly-out's height — automatic, not a consumer input. Without
+     * one, a popup with many items grows to fill nearly the whole viewport just
+     * because the room is there. Same three-tier breakpoints bk-select uses for
+     * its options list, so a "large" panel reads the same across the design
+     * system regardless of which component renders it.
+     */
+    private static popupHeightCeiling;
+    private closeTimer;
     constructor(host: ElementRef<HTMLElement>);
+    /**
+     * Inline mode: whenever the active leaf is (re)set — including the very
+     * first binding, so a deep link or a page refresh lands with the section
+     * already open — expand every ancestor on its path. Pop-up fly-outs are
+     * driven by hover/click, not by which leaf is active, so this is skipped
+     * in `popup` mode.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    private expandAncestorsOfActive;
+    /** Ids of every ancestor leading to `targetId` (root-first), `[]` if it's top-level, or `null` if not found. */
+    private findAncestorChain;
     get isVertical(): boolean;
     get isPopup(): boolean;
+    get isCompact(): boolean;
+    get isHoverTrigger(): boolean;
     get maxHeightStyle(): string | null;
     popupTop(item: MenuItem): number | null;
     popupLeft(item: MenuItem): number | null;
+    popupMaxWidth(item: MenuItem): string | null;
+    popupMaxHeight(item: MenuItem): string | null;
+    onLabelEnter(event: MouseEvent): void;
+    /** Resolved side of an open fly-out, or null before it has been placed. */
+    submenuSide(item: MenuItem): MenuPopupSide | null;
+    /** True while a fly-out is open but not yet measured — kept transparent. */
+    isPlacing(item: MenuItem): boolean;
+    /** Which way the parent's chevron points. */
+    chevronDir(item: MenuItem, level: number): 'down' | 'right' | 'left';
     hasChildren(item: MenuItem): boolean;
+    isGroupStart(items: MenuItem[], index: number): boolean;
     isOpen(item: MenuItem): boolean;
     isActive(item: MenuItem): boolean;
     isActiveAncestor(item: MenuItem): boolean;
     isHighlighted(item: MenuItem): boolean;
     inlineIndent(level: number): number | null;
-    onItemClick(item: MenuItem, siblings: MenuItem[], event: Event): void;
-    onItemEnter(item: MenuItem, siblings: MenuItem[], event: MouseEvent, level: number): void;
-    private computePopupPos;
+    groupTitleIndent(level: number): number | null;
+    onItemClick(item: MenuItem, siblings: MenuItem[], event: Event, level: number, parent: MenuItem | null): void;
+    onItemEnter(item: MenuItem, siblings: MenuItem[], event: MouseEvent, level: number, parent: MenuItem | null): void;
     onItemLeave(item: MenuItem): void;
+    private cancelPendingClose;
+    ngOnDestroy(): void;
+    private placePopup;
+    private preferredSide;
+    private applyPos;
+    private computePopupPos;
+    private clamp;
     private toggle;
     private closeBranch;
+    private closeAll;
     onDocumentClick(event: MouseEvent): void;
     onViewportChange(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkMenu, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkMenu, "bk-menu", never, { "items": { "alias": "items"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "submenuMode": { "alias": "submenuMode"; "required": false; }; "singleOpen": { "alias": "singleOpen"; "required": false; }; "activeItemId": { "alias": "activeItemId"; "required": false; }; "tintIcons": { "alias": "tintIcons"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "activeItemIdChange": "activeItemIdChange"; "itemClick": "itemClick"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkMenu, "bk-menu", never, { "items": { "alias": "items"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "submenuMode": { "alias": "submenuMode"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hoverCloseDelay": { "alias": "hoverCloseDelay"; "required": false; }; "singleOpen": { "alias": "singleOpen"; "required": false; }; "submenuBackground": { "alias": "submenuBackground"; "required": false; }; "activeItemId": { "alias": "activeItemId"; "required": false; }; "tintIcons": { "alias": "tintIcons"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "activeItemIdChange": "activeItemIdChange"; "itemClick": "itemClick"; }, never, never, true, never>;
 }
 
 /** Which edge of the anchor the panel sits against. */
@@ -2992,5 +3113,965 @@ declare class BkAvatarGroup {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkAvatarGroup, "bk-avatar-group", never, { "avatars": { "alias": "avatars"; "required": false; }; "size": { "alias": "size"; "required": false; }; "max": { "alias": "max"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "showOverflow": { "alias": "showOverflow"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { BKTooltipDirective, BK_DEFAULT_DIALOG_CONFIG, BK_DIALOG_DATA, BK_DIALOG_GLOBAL_CONFIG, BkAvatar, BkAvatarGroup, BkAvatarUploader, BkBadge, BkButton, BkButtonGroup, BkCalendarManagerService, BkCheckbox, BkColumnFilterService, BkColumnSelect, BkCustomCalendar, BkDialogActions, BkDialogClose, BkDialogContent, BkDialogModule, BkDialogRef, BkDialogService, BkDialogTitle, BkDropdown, BkFileCard, BkFilePicker, BkGrid, BkHierarchicalSelect, BkIconButton, BkInput, BkInputChips, BkLoader, BkMenu, BkPagination, BkPill, BkPopover, BkRadioButton, BkScheduledDatePicker, BkSelect, BkSpinner, BkTabs, BkTextarea, BkTimePicker, BkToastr, BkToastrService, BkToggle, BkValidator, BrickclayIcons, BrickclayLib, CalendarModule, CalendarSelection, ColumnFilterOption, NEUTRAL_APPEARANCE, POPOVER_PLACEMENTS, computePopoverPosition, deriveAppearance, getDialogBackdropAnimation, getDialogPanelAnimation, joinPlacement, parseColor, splitPlacement };
-export type { AvatarFallback, AvatarGroupItem, AvatarSize, AvatarVariant, BadgeColor, BadgeSize, BadgeVariant, BkAnimationKeyframes, BkAvatarFallback, BkAvatarSize, BkDialogAnimation, BkDialogConfig, BkDialogPosition, BkInputAutoCapitalize, BkInputAutoComplete, BkInputMode, BkInputType, BkLoaderVariant, BkPageSize, BkTextAreaAutoCapitalize, BkTextAreaAutoComplete, BkTextAreaInputMode, ButtonSize, ButtonVariant, CalendarRange, ColorAppearance, ColorFill, CountryOption, CustomRangesConfig, DotPosition, DotStatus, DropdownItem, DropdownPlacement, DropdownSize, DropdownTrigger, DropdownVariant, FileState, GroupItem, GroupMode, HierarchicalNode, IconButtonSize, IconButtonVariant, IconOrientation, MenuItem, MenuOrientation, MenuSubmenuMode, PillColor, PillSize, PillVariant, PopoverAlign, PopoverPlacement, PopoverPosition, PopoverPositionOptions, PopoverSide, Rect, ScheduledDateSelection, Size, SortDirection, SpinnerSize, TabIconDirection, TabItem, TableAction, TableBadge, TableColumn, TableIcon, TabsColors, TabsOrientation, TabsVariant, TimeConfiguration, ToastConfig, ToastMessage, ToastMethodOptions, ToastPosition, ToastSeverity };
+/**
+ * Types for bk-table.
+ *
+ * The control is template-driven: consumers write their own <thead>/<tbody>
+ * markup and the component supplies behaviour. These types describe the
+ * contracts passed *into* that markup — sorting, filtering and query state.
+ */
+/** Ascending, descending, or unsorted. Matches the tri-state sort cycle. */
+type BkSortOrder = 'ascend' | 'descend' | null;
+/** Which orders a column cycles through, in order. `null` clears the sort. */
+type BkSortDirection = BkSortOrder;
+/**
+ * How a column sorts.
+ *
+ * A comparator sorts client-side. `true` means "this column is sortable but
+ * the server does the work" — the table emits queryParams and leaves the rows
+ * untouched.
+ */
+type BkSortFn<T = any> = ((a: T, b: T, sortOrder: BkSortOrder) => number) | boolean;
+/** One entry in a column's filter menu. */
+interface BkFilterOption {
+    text: string;
+    value: any;
+    /** Pre-select this option on first render. */
+    byDefault?: boolean;
+}
+/**
+ * How a column filters.
+ *
+ * The predicate receives the selected values (always an array, even in single
+ * mode) and a row, and returns whether the row survives. `true` defers to the
+ * server, like the sort equivalent.
+ */
+type BkFilterFn<T = any> = ((selected: any[], item: T) => boolean) | boolean;
+/** Everything the server needs to reproduce the current view. */
+interface BkTableQueryParams {
+    pageIndex: number;
+    pageSize: number;
+    sort: {
+        key: string;
+        value: BkSortOrder;
+    }[];
+    filter: {
+        key: string;
+        value: any[];
+    }[];
+}
+/**
+ * Table density, roomiest first: `lg`, `default`, `md`, `sm`.
+ *
+ * `sm` is the one to reach for inside a modal, where the surrounding chrome
+ * has already spent most of the height. `middle` and `small` are ng-zorro's
+ * names for `md` and `sm`, kept so existing markup keeps working.
+ */
+type BkTableSize = 'lg' | 'default' | 'md' | 'sm' | 'middle' | 'small';
+/** The four real densities, once the ng-zorro aliases are resolved. */
+type BkTableSizeToken = 'lg' | 'default' | 'md' | 'sm';
+declare function normalizeBkTableSize(size: BkTableSize): BkTableSizeToken;
+/**
+ * Fixed-header / fixed-column configuration.
+ *
+ * `x` sets a minimum table width so columns stop collapsing and scroll
+ * horizontally instead; `y` caps body height and pins the header.
+ */
+interface BkTableScroll {
+    x?: string | null;
+    y?: string | null;
+    /**
+     * `y` is a ceiling by default (`max-height`) — a table with fewer rows
+     * than that shrinks to fit them, same as `nz-table`. Set `fill` to make it
+     * a floor instead (`height`): the body always occupies that space, even
+     * with one row, so surrounding layout (a pager below it, a page built
+     * around a fixed grid height) doesn't shift with the row count.
+     */
+    fill?: boolean;
+}
+/** A custom entry in the select-all dropdown (e.g. "Select odd rows"). */
+interface BkTableSelection {
+    text: string;
+    onSelect: () => void;
+}
+/** Horizontal cell alignment. */
+type BkCellAlign = 'left' | 'center' | 'right';
+/**
+ * Flattens a tree into the linear array a <tbody> can iterate, keeping only
+ * the branches whose ancestors are all expanded.
+ *
+ * The table can't do this itself: it never sees the tree, only the rows you
+ * hand it. Call this in your component whenever expansion state changes.
+ *
+ * @param root       top-level nodes
+ * @param childrenKey property holding each node's children
+ * @param isExpanded  whether a node's children should be visible
+ */
+interface BkTreeRow<T> {
+    data: T;
+    level: number;
+    /** Undefined at the root. Carrying it is what makes a drop resolvable. */
+    parent?: T;
+}
+declare function flattenBkTreeData<T extends Record<string, any>>(root: T[], childrenKey?: keyof T & string, isExpanded?: (node: T) => boolean): BkTreeRow<T>[];
+/**
+ * Whether `node` sits anywhere inside `ancestor`'s subtree.
+ *
+ * The guard a tree drag cannot do without: dropping a node into its own
+ * descendant detaches that whole branch from the tree, and nothing afterwards
+ * can find it again.
+ */
+declare function containsBkTreeNode<T extends Record<string, any>>(ancestor: T, node: T, childrenKey?: keyof T & string): boolean;
+/**
+ * Where a tree drop lands relative to its target row: as the sibling before
+ * it, the sibling after it, or as its child.
+ */
+type BkTreeDropPosition = 'before' | 'after' | 'inside';
+/** What `BkTreeDrag` resolves a completed drag into. */
+interface BkTreeDropEvent<T = any> {
+    dragged: BkTreeRow<T>;
+    target: BkTreeRow<T>;
+    position: BkTreeDropPosition;
+}
+/**
+ * Applies a resolved tree drop to the tree behind the rows.
+ *
+ * `before` / `after` insert into the target's sibling list; `inside` makes the
+ * dragged node the target's **first** child — first, not last, so the row
+ * appears directly beneath the row it was dropped on rather than teleporting
+ * to the bottom of a long branch.
+ *
+ * A node's subtree travels with it, because it is nested inside it. Dropping a
+ * node into its own descendant is refused: that move would detach the branch
+ * from the tree with nothing left pointing at it.
+ *
+ * Mutates `root` in place and reports whether anything moved; re-emit your
+ * signal with a fresh array identity when it returns true.
+ */
+declare function moveBkTreeNode<T extends Record<string, any>>(root: T[], dragged: BkTreeRow<T>, target: BkTreeRow<T>, position: BkTreeDropPosition, childrenKey?: keyof T & string): boolean;
+
+/** Marks projected content as the table's title bar. */
+declare class BkTableTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTableTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTableTitle, "[bkTableTitle]", never, {}, {}, never, never, true, never>;
+}
+/** Marks projected content as the table's footer bar. */
+declare class BkTableFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTableFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTableFooter, "[bkTableFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Row template for virtual scroll mode.
+ *
+ * Virtual scrolling can't use a projected <tbody> — the rows have to be created
+ * and destroyed by the viewport as it scrolls, so they must come from a
+ * template the table instantiates itself:
+ *
+ *   <tbody>
+ *     <ng-template bkVirtualScroll let-row let-i="index">
+ *       <tr>…</tr>
+ *     </ng-template>
+ *   </tbody>
+ */
+declare class BkVirtualScroll {
+    templateRef: TemplateRef<{
+        $implicit: any;
+        index: number;
+    }>;
+    constructor(templateRef: TemplateRef<{
+        $implicit: any;
+        index: number;
+    }>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkVirtualScroll, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkVirtualScroll, "[bkVirtualScroll]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Anything a column needs to expose so the table can sort and filter it.
+ * `th[bk-th]` implements this and registers itself on construction; the
+ * interface exists only to keep the two files from importing each other.
+ */
+interface BkColumnRef {
+    columnKey: string | null;
+    width: string | null;
+    sortOrder: WritableSignal<BkSortOrder>;
+    sortPriority: number | null;
+    clientSortFn: ((a: any, b: any, order: BkSortOrder) => number) | null;
+    filterValue: WritableSignal<any[]>;
+    clientFilterFn: ((selected: any[], item: any) => boolean) | null;
+    clearSort(): void;
+    clearFilter(): void;
+}
+/**
+ * Template-driven table.
+ *
+ * Unlike `bk-grid`, this component renders none of your cells — you write the
+ * `<thead>`/`<tbody>` markup and it supplies behaviour: sort and filter state,
+ * pagination, sticky header and columns, virtual scrolling. That's what makes
+ * colspan, nested tables, editable cells and grouped headers possible at all;
+ * none of them can be expressed as a column config object.
+ *
+ *   <bk-table #t [data]="rows" [bordered]="true" size="middle">
+ *     <thead>
+ *       <tr><th bk-th [sortFn]="byName">Name</th></tr>
+ *     </thead>
+ *     <tbody>
+ *       @for (row of t.renderData(); track row.id) {
+ *         <tr><td bk-td>{{ row.name }}</td></tr>
+ *       }
+ *     </tbody>
+ *   </bk-table>
+ *
+ * Client vs server work is decided per column, exactly like ng-zorro: pass a
+ * comparator to `sortFn` and the table sorts; pass `true` and it only reports
+ * the change through `queryParams` for you to handle.
+ */
+declare class BkTable<T = any> implements AfterViewInit, OnDestroy {
+    private readonly host;
+    private readonly zone;
+    constructor();
+    /** Full row set. In server mode, only the current page's rows. */
+    data: _angular_core.InputSignal<readonly T[]>;
+    /** Roomiest first: `lg`, `default`, `md`, `sm`. `sm` suits modals. */
+    size: _angular_core.InputSignal<BkTableSize>;
+    /** One class rather than a binding per size, and it resolves the aliases. */
+    readonly sizeClass: _angular_core.Signal<string>;
+    bordered: _angular_core.InputSignal<boolean>;
+    /** Convenience alternative to projecting `[bkTableTitle]`. */
+    title: _angular_core.InputSignal<string>;
+    /** Convenience alternative to projecting `[bkTableFooter]`. */
+    footer: _angular_core.InputSignal<string>;
+    /**
+     * `x` is a min-width that forces horizontal scrolling instead of column
+     * collapse; `y` caps the body height and pins the header. Fixed columns
+     * (`th[bk-th][left]`) need `x` set to have anything to scroll over.
+     */
+    scroll: _angular_core.InputSignal<BkTableScroll>;
+    loading: _angular_core.InputSignal<boolean>;
+    /**
+     * `loading` always suppresses the empty state — a fetch in flight isn't
+     * "no data," and shouldn't flash that message just because the previous
+     * page's rows haven't arrived yet. This is only about the *spinner*
+     * overlay `loading` draws on top of the table. Turn it off when a
+     * consumer already shows its own loading indicator elsewhere and doesn't
+     * want a second one competing with it — `loading` keeps doing its other
+     * job either way.
+     */
+    showLoadingOverlay: _angular_core.InputSignal<boolean>;
+    /** Shown when there are no rows to render. */
+    noResultText: _angular_core.InputSignal<string>;
+    noResultImage: _angular_core.InputSignal<string>;
+    /**
+     * Set once `noResultImage()` fails to load, so the template can drop the
+     * `<img>` instead of leaving the browser's broken-image glyph sitting next
+     * to the empty-state text — bk-grid's empty state does exactly that on any
+     * deployment where the asset path doesn't resolve. The text alone still
+     * communicates "no data"; a broken icon just looks like the component is
+     * broken.
+     */
+    readonly emptyImageFailed: WritableSignal<boolean>;
+    onEmptyImageError(): void;
+    showPagination: _angular_core.InputSignal<boolean>;
+    /**
+     * When true the table slices `data` itself. Turn it off for server-side
+     * paging and feed `total` instead.
+     */
+    frontPagination: _angular_core.InputSignal<boolean>;
+    pageIndex: _angular_core.ModelSignal<number>;
+    /**
+     * Defaults to 25 because that is the smallest size `bk-pagination` offers
+     * (25/50/75/100). A value outside that list matches no option and leaves its
+     * "rows per page" select rendering blank.
+     */
+    pageSize: _angular_core.ModelSignal<number>;
+    /** Row count for server mode. Ignored when `frontPagination` is on. */
+    total: _angular_core.InputSignal<number>;
+    /**
+     * Row height in px. Required for virtual scroll — the viewport can't measure
+     * rows it hasn't created. Rows must be uniform height, which is why virtual
+     * scroll does not combine with rowspan, tree data or expandable rows.
+     */
+    virtualItemSize: _angular_core.InputSignal<number>;
+    virtualTrackBy: _angular_core.InputSignal<(index: number, item: T) => any>;
+    private viewport?;
+    /**
+     * Scrolls the virtual viewport so the row at `index` (into `renderData()`)
+     * lands at the top.
+     *
+     * Indexes are 0-based against the rendered rows, not the raw `data` input —
+     * sorting/filtering already reduced it to what's actually on screen, and
+     * jumping against the raw array would land on the wrong row the moment
+     * either is active.
+     */
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    /**
+     * Hold the columns still once they have been measured.
+     *
+     * A table left on `table-layout: auto` sizes its columns from whatever
+     * content is currently on screen, so sorting, filtering or paging — none of
+     * which change the columns — visibly resizes them. Freezing the proportions
+     * after the first real layout keeps the header from jumping under the
+     * pointer that just clicked it.
+     *
+     * Turn it off if the content genuinely should drive the widths on every
+     * change. Columns with an explicit `width` are never overwritten either way.
+     */
+    stableColumnWidth: _angular_core.InputSignal<boolean>;
+    /** Everything the server needs to reproduce the current view. */
+    queryParams: _angular_core.OutputEmitterRef<BkTableQueryParams>;
+    /** The rows actually rendered, after filter/sort/paging. */
+    currentPageDataChange: _angular_core.OutputEmitterRef<readonly T[]>;
+    titleContent?: BkTableTitle;
+    footerContent?: BkTableFooter;
+    virtualScroll?: BkVirtualScroll;
+    /**
+     * Registered `th[bk-th]` instances. Sorting and filtering are driven by
+     * column state, so the pipeline below reads through this signal — replacing
+     * the array (rather than mutating it) is what makes the computeds re-run.
+     */
+    readonly columns: WritableSignal<BkColumnRef[]>;
+    registerColumn(column: BkColumnRef): void;
+    unregisterColumn(column: BkColumnRef): void;
+    /**
+     * Re-emits query params. Columns call this when their sort or filter
+     * changes; the data pipeline reacts on its own through signals, so this
+     * exists purely to notify the consumer.
+     */
+    onColumnStateChange(): void;
+    /**
+     * Rows surviving every column's client-side filter. Columns whose filter is
+     * handled server-side contribute nothing here.
+     */
+    private readonly filtered;
+    /**
+     * Filtered rows in sort order.
+     *
+     * Multi-sort runs columns by descending `sortPriority`, and comparators are
+     * applied in that order until one breaks the tie — so a priority-2 column
+     * only orders rows a priority-3 column considers equal.
+     */
+    private readonly sorted;
+    /** Row count before paging — what the pager needs to size itself. */
+    readonly totalCount: _angular_core.Signal<number>;
+    /**
+     * The rows to render. Iterate this in your `<tbody>`, not the raw input:
+     * it is the input after filtering, sorting and paging.
+     */
+    readonly renderData: _angular_core.Signal<readonly T[]>;
+    readonly isVirtual: _angular_core.Signal<boolean>;
+    /**
+     * Column widths for the virtual-scroll `<colgroup>`.
+     *
+     * Virtual scroll splits the header and body into two tables, so they can no
+     * longer size each other — a shared colgroup is what keeps their columns
+     * lined up, and it needs a declared width per column to do it.
+     */
+    readonly colWidths: _angular_core.Signal<(string | null)[]>;
+    readonly hasTitle: _angular_core.Signal<boolean>;
+    readonly hasFooter: _angular_core.Signal<boolean>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    /** Floor for the empty state's home: `.bk-table-empty` is absolutely
+     *  positioned against this container (see table.css), so without either
+     *  `scroll.y` or this fallback it'd have a ~0px-tall box to center in
+     *  (just the header row, since an empty `<tbody>` contributes nothing)
+     *  and get clipped by `overflow-auto`. */
+    private static readonly EMPTY_STATE_MIN_HEIGHT;
+    readonly containerStyle: _angular_core.Signal<{
+        'min-height': string;
+        'overflow-y'?: undefined;
+    } | {
+        'min-height'?: undefined;
+        'overflow-y'?: undefined;
+    } | {
+        [x: string]: string;
+        'overflow-y': string;
+        'min-height'?: undefined;
+    }>;
+    /** Set once the columns have been measured and pinned. */
+    readonly layoutFixed: WritableSignal<boolean>;
+    readonly tableStyle: _angular_core.Signal<Record<string, string>>;
+    virtualHead?: ElementRef<HTMLElement>;
+    private headResizeObserver?;
+    private layoutResizeObserver?;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Publishes the first header row's height as `--bk-thead-row-1`.
+     *
+     * A grouped header's second row has to stick *below* the first, which means
+     * knowing how tall the first is — and that changes with density, with font
+     * loading, and with any header that wraps. Measuring it is the only offset
+     * that stays correct; a constant is right for exactly one configuration.
+     */
+    private observeHeaderHeight;
+    /**
+     * Two unrelated jobs that both boil down to "re-check this whenever the
+     * table's or the container's box size changes," so one `ResizeObserver`
+     * watching both elements does them together.
+     *
+     * **Retries the column freeze.** A table that mounts inside a `[hidden]`
+     * ancestor — a collapsed `tr[bkExpand]` holding a nested `bk-table`, most
+     * commonly — measures 0 on its first freeze attempt, so
+     * `freezeColumnWidths()` correctly declines to pin widths it can't see
+     * (`if (!tableWidth) return;`). Nothing else ever asks it to try again: the
+     * constructor effect only reruns when one of its own signals changes, and
+     * none of them do just because the table became visible. Left alone, that
+     * table stays on `table-layout: auto` forever — and an auto-layout cell
+     * can't give a nested table's `min-width: 100%` a real number to resolve
+     * against, which is what leaves a nested `bk-table` stuck at its own
+     * shrink-to-fit width even after the row expands. Once `layoutFixed` is
+     * true the call is a no-op, so this can just stay connected for the
+     * table's life rather than tracking whether it still needs to be.
+     *
+     * **Tracks whether the rows fall short of the container.** See
+     * `updateUnderfilled`.
+     */
+    private observeTableVisibility;
+    /**
+     * Marks the host when rows end well short of a reserved `scroll.y`
+     * (`fill`, most commonly) height, so `.bk-table-underfilled` in the
+     * stylesheet can close the real data off with a border instead of letting
+     * it trail into blank reserved space with nothing marking where it
+     * stopped. Left off whenever rows fill or overflow the container — the
+     * frame's own border (or the scroll cutoff) already closes those cases,
+     * and adding another border would double up against it.
+     */
+    private updateUnderfilled;
+    /**
+     * Pins the columns at the proportions auto layout arrived at.
+     *
+     * Widths are stored as percentages, not pixels: under `table-layout: fixed`
+     * a percentage resolves against the table, so the columns keep their
+     * relationship when the container resizes. Pixels would freeze the table at
+     * whatever width it happened to have when the rows first arrived.
+     *
+     * Only the first header row is written to — that is the row `table-layout:
+     * fixed` reads widths from. A grouped header's second row inherits its share
+     * of whatever the group above it was given.
+     */
+    private freezeColumnWidths;
+    /** The cells this component wrote a width to, so it can undo exactly those. */
+    private frozenCells;
+    /** Column count the frozen widths were measured against. */
+    private frozenColumnCount;
+    /** Guards against stacking timeouts while columns are still registering. */
+    private freezeScheduled;
+    /**
+     * Drops the frozen widths so the columns are measured again. Call it after
+     * replacing the dataset with one whose shape is different enough that the
+     * old proportions no longer suit it.
+     */
+    remeasureColumns(): void;
+    /**
+     * Keeps the detached virtual-scroll header aligned with the body it no
+     * longer shares a table with.
+     */
+    onViewportScroll(event: Event): void;
+    onPageIndexChange(index: number): void;
+    onPageSizeChange(size: number): void;
+    /** Clears every column's sort. Backs "reset sorters" in the demo. */
+    clearSort(): void;
+    /** Clears every column's filter selection. */
+    clearFilter(): void;
+    /** Clears sorts and filters together and returns to the first page. */
+    reset(): void;
+    private emitQueryParams;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTable<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkTable<any>, "bk-table", ["bkTable"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "footer": { "alias": "footer"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "showLoadingOverlay": { "alias": "showLoadingOverlay"; "required": false; "isSignal": true; }; "noResultText": { "alias": "noResultText"; "required": false; "isSignal": true; }; "noResultImage": { "alias": "noResultImage"; "required": false; "isSignal": true; }; "showPagination": { "alias": "showPagination"; "required": false; "isSignal": true; }; "frontPagination": { "alias": "frontPagination"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "virtualItemSize": { "alias": "virtualItemSize"; "required": false; "isSignal": true; }; "virtualTrackBy": { "alias": "virtualTrackBy"; "required": false; "isSignal": true; }; "stableColumnWidth": { "alias": "stableColumnWidth"; "required": false; "isSignal": true; }; }, { "pageIndex": "pageIndexChange"; "pageSize": "pageSizeChange"; "queryParams": "queryParams"; "currentPageDataChange": "currentPageDataChange"; }, ["titleContent", "footerContent", "virtualScroll"], ["thead", "tbody", "tfoot", "[bkTableTitle]", "[bkTableFooter]"], true, never>;
+}
+
+/**
+ * Behaviour shared by `th[bk-th]` and `td[bk-td]`: fixed columns, text
+ * overflow handling and alignment.
+ *
+ * Fixed columns are `position: sticky`, which needs a pixel offset — and the
+ * correct offset is the cell's distance from the edge of the table, which is
+ * only knowable after layout. Subclasses get that measurement for free.
+ */
+declare abstract class BkCellBase implements AfterViewInit, OnDestroy {
+    protected readonly el: ElementRef<any>;
+    private readonly zone;
+    /**
+     * Pin this column to the left edge while the table scrolls horizontally.
+     * `true` measures the offset; a string sets it explicitly.
+     *
+     * Pinned columns must be contiguous from the edge — a gap leaves the columns
+     * beyond it overlapping as they scroll underneath.
+     */
+    left: _angular_core.InputSignal<string | boolean>;
+    /** Pin to the right edge. Same rules as `left`. */
+    right: _angular_core.InputSignal<string | boolean>;
+    /**
+     * Truncate overflow with an ellipsis instead of wrapping.
+     *
+     * Put it on the `td`, not the `th`. It works by setting `max-width: 0` on
+     * whichever cell carries it, and `table-layout: fixed` sizes a column from
+     * its header cell alone — a `max-width` on the header collapses the whole
+     * column toward zero regardless of any declared `width`. A `td`'s own width
+     * is never consulted by `fixed` layout, so the same rule there only clips
+     * the content, which is the point.
+     */
+    ellipsis: _angular_core.InputSignal<boolean>;
+    /**
+     * Allow breaks *inside* words. Without it a long unbroken string (a URL, an
+     * ID) pushes past the cell instead of wrapping.
+     */
+    breakWord: _angular_core.InputSignal<boolean>;
+    align: _angular_core.InputSignal<BkCellAlign | null>;
+    /** Resolved sticky offsets, written after measurement. */
+    protected readonly stickyLeft: _angular_core.WritableSignal<string | null>;
+    protected readonly stickyRight: _angular_core.WritableSignal<string | null>;
+    private resizeObserver?;
+    get isSticky(): boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Resolves the sticky offsets.
+     *
+     * Offsets are summed from sibling `offsetWidth`s rather than read from
+     * `getBoundingClientRect()`: once a cell is sticky its rect reflects where it
+     * has been *held*, not where the column sits, so measuring a scrolled table
+     * that way feeds each cell its own displacement back. `offsetWidth` is
+     * unaffected by the sticky shift.
+     */
+    protected measure(): void;
+    private sumWidths;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkCellBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkCellBase, never, never, { "left": { "alias": "left"; "required": false; "isSignal": true; }; "right": { "alias": "right"; "required": false; "isSignal": true; }; "ellipsis": { "alias": "ellipsis"; "required": false; "isSignal": true; }; "breakWord": { "alias": "breakWord"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Header cell.
+ *
+ * Carries a column's sort state, filter menu and select-all checkbox, and
+ * registers itself with the parent `bk-table` so the table's data pipeline can
+ * read them. It renders whatever you project as the label:
+ *
+ *   <th bk-th [sortFn]="byName" [filters]="statuses" [filterFn]="byStatus">
+ *     Name
+ *   </th>
+ *
+ * Use the native `colspan` / `rowspan` attributes for grouped headers — they
+ * need no wrapper input.
+ */
+declare class BkTh extends BkCellBase implements BkColumnRef, OnInit, OnDestroy {
+    /** Optional: the parent table only exists when the th is inside one. */
+    private readonly table;
+    /** Identifies the column in `queryParams`. Required for server-side work. */
+    columnKeyInput: _angular_core.InputSignal<string | null>;
+    /**
+     * Column width. Required in virtual-scroll mode, where the header is a
+     * separate table and has no body cells to size itself against.
+     */
+    widthInput: _angular_core.InputSignal<string | null>;
+    /** Plain-value views of the inputs, so the table can read them off BkColumnRef. */
+    get columnKey(): string | null;
+    get width(): string | null;
+    /**
+     * A comparator sorts client-side; `true` marks the column sortable but
+     * leaves the sorting to the server.
+     */
+    sortFn: _angular_core.InputSignal<BkSortFn | null>;
+    sortOrder: _angular_core.ModelSignal<BkSortOrder>;
+    /** The cycle the header steps through on each click. */
+    sortDirections: _angular_core.InputSignal<BkSortOrder[]>;
+    /**
+     * Ranks this column against other sorted columns — higher wins. Columns
+     * without a priority sort in registration order after those with one.
+     */
+    sortPriorityInput: _angular_core.InputSignal<number | null>;
+    /** Options for the filter menu. An empty list hides the funnel icon. */
+    filters: _angular_core.InputSignal<BkFilterOption[]>;
+    /** Predicate for client-side filtering, or `true` to defer to the server. */
+    filterFn: _angular_core.InputSignal<BkFilterFn | null>;
+    /** Multiple shows checkboxes; single shows radios and closes on pick. */
+    filterMultiple: _angular_core.InputSignal<boolean>;
+    checkbox: _angular_core.InputSignal<boolean>;
+    checked: _angular_core.ModelSignal<boolean>;
+    indeterminate: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Extra entries in the select-all dropdown ("Select odd rows", …). Providing
+     * any adds a caret beside the checkbox.
+     */
+    selections: _angular_core.InputSignal<BkTableSelection[]>;
+    /** Reserves the narrow width used by the expand-icon column. */
+    showExpand: _angular_core.InputSignal<boolean>;
+    readonly filterValue: _angular_core.WritableSignal<any[]>;
+    /** Menu selection while the popover is open, before OK is pressed. */
+    readonly pendingFilter: _angular_core.WritableSignal<any[]>;
+    readonly showSort: _angular_core.Signal<boolean>;
+    readonly showFilter: _angular_core.Signal<boolean>;
+    readonly isFiltered: _angular_core.Signal<boolean>;
+    /** Only comparators run in-process; `true` means the server sorts. */
+    get clientSortFn(): ((a: any, b: any, order: BkSortOrder) => number) | null;
+    get clientFilterFn(): ((selected: any[], item: any) => boolean) | null;
+    get sortPriority(): number | null;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Advances to the next order in `sortDirections`, wrapping at the end. */
+    onSortClick(): void;
+    clearSort(): void;
+    isPending(value: any): boolean;
+    /**
+     * Single-select view of the pending selection, for the radio list. The
+     * underlying state stays an array in both modes so the filter predicate has
+     * one shape to handle.
+     */
+    get singleFilter(): any;
+    set singleFilter(value: any);
+    toggleFilterOption(value: any, selected: boolean): void;
+    applyFilter(popover?: BkPopover): void;
+    resetFilter(popover?: BkPopover): void;
+    clearFilter(): void;
+    /** Re-syncs the menu to the applied state so a cancelled edit doesn't stick. */
+    onFilterMenuOpen(): void;
+    onCheckedChange(value: boolean): void;
+    runSelection(selection: BkTableSelection, popover?: BkPopover): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTh, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkTh, "th[bk-th]", never, { "columnKeyInput": { "alias": "columnKey"; "required": false; "isSignal": true; }; "widthInput": { "alias": "width"; "required": false; "isSignal": true; }; "sortFn": { "alias": "sortFn"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "sortDirections": { "alias": "sortDirections"; "required": false; "isSignal": true; }; "sortPriorityInput": { "alias": "sortPriority"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "filterMultiple": { "alias": "filterMultiple"; "required": false; "isSignal": true; }; "checkbox": { "alias": "checkbox"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; }, { "sortOrder": "sortOrderChange"; "checked": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Body cell.
+ *
+ * Handles the parts of a cell the consumer shouldn't have to rebuild each
+ * time — row checkbox, expand toggle, tree indentation, sticky positioning —
+ * and projects everything else through untouched:
+ *
+ *   <td bk-td [(checked)]="row.checked"></td>
+ *   <td bk-td [showExpand]="row.hasChildren" [(expand)]="row.expand"
+ *             [indentLevel]="row.level" [indentSize]="20">{{ row.name }}</td>
+ *
+ * Use the native `colspan` / `rowspan` attributes for spanning cells.
+ */
+declare class BkTd extends BkCellBase implements AfterViewInit, OnDestroy {
+    private readonly ngZone;
+    private ellipsisResizeObserver?;
+    /**
+     * The tooltip's content, and the switch for whether it shows at all — see
+     * `observeEllipsisTruncation()`. Bound in the template onto the innermost
+     * `.bk-td-ellipsis-text` span wrapping the projected content, not the `td`
+     * or `.bk-td-content`: both of those are wider than the actual (possibly
+     * truncated) text, and the tooltip should point at what's actually there.
+     */
+    protected readonly truncatedTooltip: _angular_core.WritableSignal<string>;
+    /** Forwarded to the content wrapper's `bkTooltip`. Override on a column whose default 'right' would run into its neighbour. */
+    tooltipPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    /** Only present when `ellipsis()` is true — see the `@else` branch in the template. */
+    private ellipsisTextRef?;
+    checkbox: _angular_core.InputSignal<boolean>;
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    indeterminate: _angular_core.InputSignal<boolean>;
+    /**
+     * Renders the expand toggle. Set it false on leaf rows in a tree — the cell
+     * still reserves the icon's width so labels stay aligned down the column.
+     */
+    showExpand: _angular_core.InputSignal<boolean>;
+    expand: _angular_core.ModelSignal<boolean>;
+    /**
+     * Custom expand icon. The template receives the open state as `$implicit`:
+     *
+     *   <ng-template #icon let-expanded>{{ expanded ? '−' : '+' }}</ng-template>
+     */
+    expandIcon: _angular_core.InputSignal<TemplateRef<{
+        $implicit: boolean;
+    }> | null>;
+    /** Depth of this row in the tree. Multiplied by `indentSize`. */
+    indentLevel: _angular_core.InputSignal<number>;
+    /** Pixels of indent per level. */
+    indentSize: _angular_core.InputSignal<number>;
+    /**
+     * Marks the column that carries the tree. Leaf rows in such a column get a
+     * blank spacer where the toggle would be, so their labels line up with the
+     * labels of siblings that do have children — including at depth 0, where
+     * indentation alone gives nothing to align against.
+     */
+    treeCell: _angular_core.InputSignal<boolean>;
+    /**
+     * The projected content is block-level and should fill the cell — a nested
+     * `bk-table`, most commonly — rather than the default shrink-to-fit inline
+     * box that lets ordinary text/icon content size to itself and still honour
+     * `align` via `text-align`. Turning this on trades that `align` behaviour
+     * away for whatever the block content does with the full width itself.
+     */
+    block: _angular_core.InputSignal<boolean>;
+    readonly indentPx: _angular_core.Signal<number>;
+    /** A tree cell with no toggle of its own still reserves the toggle's width. */
+    readonly isLeafSpacer: _angular_core.Signal<boolean>;
+    onExpandClick(): void;
+    onCheckedChange(value: boolean): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Drives `truncatedTooltip` from measured truncation rather than the
+     * content being present unconditionally: `bkTooltip`'s own emptiness check
+     * already suppresses the tooltip when there's nothing to show, so setting
+     * it only when the cell is genuinely clipped (`scrollWidth > clientWidth`)
+     * is what makes it show "for the truncated item only" — an `ellipsis` cell
+     * whose text happens to fit never gets a tooltip at all.
+     *
+     * Measures the inner `.bk-td-ellipsis-text` span, not the `td` — that span
+     * is now the element that actually owns `overflow: hidden` (see
+     * `.bk-td-ellipsis-text` in table.css, and why: the ellipsis marker needs
+     * a plain, non-flex element to render on at all). Because it clips its own
+     * overflow, that overflow never reaches the `td`'s own `scrollWidth`
+     * anymore — measuring the `td` here would read `scrollWidth ===
+     * clientWidth` even when the text is visibly cut off, since the span
+     * absorbs it first.
+     *
+     * Measured on resize, not on hover: `bkTooltip`'s own `mouseenter` listener
+     * fires independently of this, so content has to already be correct
+     * *before* any hover — computing it reactively to the hover would risk
+     * showing whatever was last set instead of what's true at that moment.
+     */
+    private observeEllipsisTruncation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkTd, "td[bk-td]", never, { "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "checkbox": { "alias": "checkbox"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; "expand": { "alias": "expand"; "required": false; "isSignal": true; }; "expandIcon": { "alias": "expandIcon"; "required": false; "isSignal": true; }; "indentLevel": { "alias": "indentLevel"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "treeCell": { "alias": "treeCell"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "expand": "expandChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A detail row that appears beneath its parent when expanded.
+ *
+ *   <tr [bkExpand]="row.expand">
+ *     <td colspan="5">…anything…</td>
+ *   </tr>
+ *
+ * The row is hidden rather than destroyed, so state inside it (a scrolled
+ * nested table, a half-filled form) survives being collapsed and reopened.
+ * Wrap it in `@if` instead when the content is expensive enough that keeping
+ * it alive costs more than rebuilding it.
+ */
+declare class BkTrExpand {
+    bkExpand: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTrExpand, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTrExpand, "tr[bkExpand]", never, { "bkExpand": { "alias": "bkExpand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Summary / totals rows, placed in a `<tfoot>`.
+ *
+ *   <tfoot bkTableSummary [fixed]="true">
+ *     <tr><td bk-td>Total</td><td bk-td>{{ total }}</td></tr>
+ *   </tfoot>
+ *
+ * `fixed` pins the footer to the bottom of the scroll container so totals stay
+ * visible while the body scrolls — the counterpart to the fixed header.
+ */
+declare class BkTableSummary {
+    fixed: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTableSummary, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTableSummary, "tfoot[bkTableSummary]", never, { "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Makes CDK row dragging behave inside a `<table>`.
+ *
+ * Two problems the CDK doesn't solve on its own, both carried over from
+ * `bk-grid` where they were already working:
+ *
+ * 1. The drag preview is a detached copy of the `<tr>`, so it loses the column
+ *    widths the table gave it and collapses to its content. Widths are copied
+ *    across at drag start — from the *placeholder*, not the dragged row: by
+ *    the time `cdkDragStarted` fires, the CDK has already swapped the row out
+ *    for the placeholder and moved the row itself out to `<body>`, so the row
+ *    is no longer sitting inside the table and no longer reports the table's
+ *    widths. The placeholder is a clone left in the row's place, still inside
+ *    the table, so it's the one still telling the truth.
+ * 2. Dragging to the edge of a scrolling table doesn't scroll it, so rows below
+ *    the fold are unreachable. Nearing an edge scrolls proportionally to how
+ *    close the pointer is.
+ *
+ *   <div class="wrap" #d="bkTableDrag" bkTableDrag>
+ *     <bk-table>
+ *       <tbody cdkDropList (cdkDropListDropped)="drop($event)">
+ *         @for (row of rows; track row.id) {
+ *           <tr cdkDrag cdkDragLockAxis="y"
+ *               (cdkDragStarted)="d.onStart($event)"
+ *               (cdkDragMoved)="d.onMove($event)">
+ *
+ * The scroll container is resolved from the host, so put this on the element
+ * that actually scrolls (or any ancestor of it).
+ */
+declare class BkTableDrag {
+    private readonly el;
+    /** Distance from an edge, in px, at which auto-scroll kicks in. */
+    private readonly edgeThreshold;
+    /** Fastest scroll step per move event, in px. */
+    private readonly maxScrollSpeed;
+    onStart(event: CdkDragStart): void;
+    onMove(event: CdkDragMove): void;
+    /**
+     * The nearest descendant that actually scrolls. `bk-table` puts the overflow
+     * on an inner container, so the host itself usually isn't the scroller.
+     * Protected so `BkTreeDrag` can position its drop indicator inside it.
+     */
+    protected scrollContainer(): HTMLElement | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTableDrag, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTableDrag, "[bkTableDrag]", ["bkTableDrag"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The grip a row is dragged by — a reusable handle instead of a glyph copied
+ * into every drag-sort table.
+ *
+ * `hostDirectives: [CdkDragHandle]` puts `cdkDragHandle` on the component's
+ * own host element, so it registers as the drag origin the moment it appears
+ * anywhere inside a `cdkDrag` row — no need to add the CDK directive by hand,
+ * and no requirement about *where* in the row it sits:
+ *
+ *   <!-- its own column -->
+ *   <td bk-td><bk-drag-handle></bk-drag-handle></td>
+ *   <td bk-td>{{ row.name }}</td>
+ *
+ *   <!-- inline with the first column, no dedicated column at all -->
+ *   <td bk-td><bk-drag-handle></bk-drag-handle> {{ row.name }}</td>
+ *
+ * The icon is a default grip — swap it per table by passing a template:
+ *
+ *   <ng-template #bars><svg>…</svg></ng-template>
+ *   <bk-drag-handle [icon]="bars"></bk-drag-handle>
+ *
+ * Same shape as `expandIcon` on `td[bk-td]`: a `TemplateRef` input the
+ * component falls back from when it's `null`, rather than a projected slot —
+ * `<ng-content>` has no way to render a default only when nothing was
+ * projected into it.
+ */
+declare class BkDragHandle {
+    icon: _angular_core.InputSignal<TemplateRef<void> | null>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkDragHandle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkDragHandle, "bk-drag-handle", ["bkDragHandle"], { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$3.CdkDragHandle; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * How far a drag is allowed to travel through the tree.
+ *
+ * - `'anywhere'` — full re-parenting: before, after or inside any legal target
+ *   at any depth. Right for a generic outliner or file explorer, where the
+ *   levels carry no meaning of their own.
+ * - `'siblings'` — reorder only, among the dragged node's current siblings.
+ *   No re-parenting, no nesting. Right whenever the levels *do* mean
+ *   something — an org chart, a category tree, a fixed-depth menu — where an
+ *   unrestricted drag lets you build a tree that violates whatever the levels
+ *   were supposed to represent. The cycle guard stops a node from swallowing
+ *   itself either way, but nothing else stops a leaf from ending up three
+ *   levels deep under an unrelated parent unless this is set.
+ */
+type BkTreeDragScope = 'anywhere' | 'siblings';
+/**
+ * Tree-aware row dragging: before / after / inside.
+ *
+ * A table flattens the tree into one list of `<tr>` — every row is a sibling
+ * in the same `<tbody>` whatever its depth, so nested `cdkDropList`s have
+ * nothing to nest on. Instead the CDK is kept for what it is good at (the
+ * preview, the placeholder, returning the row on release) with its sorting
+ * turned off, and this directive does the targeting: the pointer's position
+ * within the row under it picks the relationship —
+ *
+ *   top third     insert BEFORE the target, as a sibling
+ *   middle third  drop INSIDE the target, as its child
+ *   bottom third  insert AFTER the target, as a sibling
+ *
+ * — drawn live as a line above, a line below, or a tinted row, so the drop
+ * never lands somewhere the indicator didn't say it would. Illegal targets
+ * (the dragged row itself, anything in its own subtree, anything the `canDrop`
+ * predicate vetoes) simply show no indicator.
+ *
+ * Set `scope="siblings"` to restrict dragging to reordering among the node's
+ * current siblings — no re-parenting, no nesting, and no `inside` zone at all
+ * (see `BkTreeDragScope`). That is the right default whenever the tree's
+ * levels mean something specific; `canDrop` covers anything more particular
+ * than the two built-in scopes.
+ *
+ * The directive never touches the tree. It resolves the drag into one event —
+ * `{ dragged, target, position }` — and the consumer applies it, usually with
+ * `moveBkTreeNode`. Hovering the middle of a row for `expandDelay` emits
+ * `treeExpand` so collapsed branches can be opened mid-drag; acting on it is
+ * likewise the consumer's call.
+ *
+ *   <div bkTreeDrag #td="bkTreeDrag" [treeRows]="t.renderData()"
+ *        (treeDrop)="onDrop($event)" (treeExpand)="open($event)">
+ *     <bk-table #t [data]="rows()">
+ *       <tbody cdkDropList [cdkDropListSortingDisabled]="true">
+ *         @for (row of t.renderData(); track row.data.id) {
+ *           <tr cdkDrag cdkDragLockAxis="y"
+ *               (cdkDragStarted)="td.onDragStart($event, row)"
+ *               (cdkDragMoved)="td.onDragMove($event)"
+ *               (cdkDragEnded)="td.onDragEnd()">
+ *
+ * Sorting stays disabled on the drop list deliberately: with rows shuffling
+ * under the pointer, an open branch's children sit still while their parent
+ * moves. With a static list and an indicator, nothing lies.
+ *
+ * Extends `BkTableDrag`, so the preview keeps its column widths and dragging
+ * near an edge still scrolls the table.
+ */
+declare class BkTreeDrag<T = any> extends BkTableDrag implements OnDestroy {
+    /**
+     * The flattened rows currently rendered, in render order — the same array
+     * the `<tbody>` iterates. Row *i* of the tbody is entry *i* here; that
+     * index mapping is the whole basis of the hit-testing.
+     */
+    treeRows: _angular_core.InputSignal<readonly BkTreeRow<T>[]>;
+    /** See `BkTreeDragScope`. Defaults to full re-parenting. */
+    scope: _angular_core.InputSignal<BkTreeDragScope>;
+    /**
+     * Consumer veto over and above the built-in guards — e.g. "a person cannot
+     * contain a team". Return false and the indicator never appears.
+     */
+    canDrop: _angular_core.InputSignal<((dragged: BkTreeRow<T>, target: BkTreeRow<T>, position: BkTreeDropPosition) => boolean) | null>;
+    /** How long the pointer rests on a row's middle before `treeExpand` fires. */
+    expandDelay: _angular_core.InputSignal<number>;
+    treeDrop: _angular_core.OutputEmitterRef<BkTreeDropEvent<T>>;
+    treeExpand: _angular_core.OutputEmitterRef<BkTreeRow<T>>;
+    private dragged;
+    private target;
+    private position;
+    private line;
+    private insideRow;
+    private expandTimer;
+    private expandFor;
+    onDragStart(event: CdkDragStart, row: BkTreeRow<T>): void;
+    onDragMove(event: CdkDragMove): void;
+    onDragEnd(): void;
+    ngOnDestroy(): void;
+    /**
+     * Structural legality, before the zone is even known. Dropping a node
+     * anywhere inside its own subtree would detach that branch from the tree
+     * with nothing left pointing at it — walking the parent chain is cheaper
+     * than searching the subtree, and `flattenBkTreeData` already carries it.
+     *
+     * In `'siblings'` scope, the only legal targets are the dragged node's
+     * current siblings — same `parent` reference, root-level nodes included
+     * (`undefined === undefined`). That alone also rules out every cycle: a
+     * node's siblings can never be its own ancestor.
+     */
+    private isLegal;
+    private canDropAt;
+    private setTarget;
+    private drawLine;
+    private clearIndicator;
+    /**
+     * One timer per hovered node: moving within the same row keeps it running,
+     * moving to another row restarts it. The directive only reports the dwell —
+     * whether the node has children to show is the consumer's knowledge.
+     */
+    private armExpandTimer;
+    private clearExpandTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkTreeDrag<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkTreeDrag<any>, "[bkTreeDrag]", ["bkTreeDrag"], { "treeRows": { "alias": "treeRows"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": false; "isSignal": true; }; "canDrop": { "alias": "canDrop"; "required": false; "isSignal": true; }; "expandDelay": { "alias": "expandDelay"; "required": false; "isSignal": true; }; }, { "treeDrop": "treeDrop"; "treeExpand": "treeExpand"; }, never, never, true, never>;
+}
+
+/**
+ * bk-table public surface.
+ *
+ * `BK_TABLE` is the convenience bundle — spread it into a standalone
+ * component's `imports` rather than listing eight symbols by hand:
+ *
+ *   imports: [...BK_TABLE]
+ */
+
+declare const BK_TABLE: readonly [typeof BkTable, typeof BkTableTitle, typeof BkTableFooter, typeof BkVirtualScroll, typeof BkTh, typeof BkTd, typeof BkTrExpand, typeof BkTableSummary, typeof BkTableDrag, typeof BkDragHandle, typeof BkTreeDrag];
+
+export { BKTooltipDirective, BK_DEFAULT_DIALOG_CONFIG, BK_DIALOG_DATA, BK_DIALOG_GLOBAL_CONFIG, BK_TABLE, BkAvatar, BkAvatarGroup, BkAvatarUploader, BkBadge, BkButton, BkButtonGroup, BkCalendarManagerService, BkCheckbox, BkColumnFilterService, BkColumnSelect, BkCustomCalendar, BkDialogActions, BkDialogClose, BkDialogContent, BkDialogModule, BkDialogRef, BkDialogService, BkDialogTitle, BkDragHandle, BkDropdown, BkFileCard, BkFilePicker, BkGrid, BkHierarchicalSelect, BkIconButton, BkInput, BkInputChips, BkLoader, BkMenu, BkPagination, BkPill, BkPopover, BkRadioButton, BkScheduledDatePicker, BkSelect, BkSpinner, BkTable, BkTableDrag, BkTableFooter, BkTableSummary, BkTableTitle, BkTabs, BkTd, BkTextarea, BkTh, BkTimePicker, BkToastr, BkToastrService, BkToggle, BkTrExpand, BkTreeDrag, BkValidator, BkVirtualScroll, BrickclayIcons, BrickclayLib, CalendarModule, CalendarSelection, ColumnFilterOption, NEUTRAL_APPEARANCE, POPOVER_PLACEMENTS, computePopoverPosition, containsBkTreeNode, deriveAppearance, flattenBkTreeData, getDialogBackdropAnimation, getDialogPanelAnimation, joinPlacement, moveBkTreeNode, normalizeBkTableSize, parseColor, splitPlacement };
+export type { AvatarFallback, AvatarGroupItem, AvatarSize, AvatarVariant, BadgeColor, BadgeSize, BadgeVariant, BkAnimationKeyframes, BkAvatarFallback, BkAvatarSize, BkCellAlign, BkColumnRef, BkColumnSelectPosition, BkDialogAnimation, BkDialogConfig, BkDialogPosition, BkFilterFn, BkFilterOption, BkInputAutoCapitalize, BkInputAutoComplete, BkInputMode, BkInputSize, BkInputType, BkLoaderVariant, BkPageSize, BkSortDirection, BkSortFn, BkSortOrder, BkTableQueryParams, BkTableScroll, BkTableSelection, BkTableSize, BkTableSizeToken, BkTextAreaAutoCapitalize, BkTextAreaAutoComplete, BkTextAreaInputMode, BkTreeDragScope, BkTreeDropEvent, BkTreeDropPosition, BkTreeRow, ButtonSize, ButtonVariant, CalendarRange, ColorAppearance, ColorFill, CountryOption, CustomRangesConfig, DotPosition, DotStatus, DropdownItem, DropdownPlacement, DropdownSize, DropdownTrigger, DropdownVariant, FileState, GroupItem, GroupMode, HierarchicalNode, IconButtonSize, IconButtonVariant, IconOrientation, MenuItem, MenuOrientation, MenuPopupSide, MenuSize, MenuSubmenuMode, MenuTrigger, PillColor, PillSize, PillVariant, PopoverAlign, PopoverPlacement, PopoverPosition, PopoverPositionOptions, PopoverSide, Rect, ScheduledDateSelection, Size, SortDirection, SpinnerSize, TabIconDirection, TabItem, TableAction, TableBadge, TableColumn, TableIcon, TabsColors, TabsOrientation, TabsVariant, TimeConfiguration, ToastConfig, ToastMessage, ToastMethodOptions, ToastPosition, ToastSeverity };