@brickclay-org/ui 0.1.90 → 0.1.92

package/index.d.ts

@@ -7,7 +7,7 @@ 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 { CdkDragDrop, CdkDragMove, CdkDragStart, CdkDragEnter } from '@angular/cdk/drag-drop';
 import { NgxMaskDirective } from 'ngx-mask';
 import * as i1$2 from '@angular/cdk/dialog';
 import { CdkDialogContainer, DialogRef } from '@angular/cdk/dialog';
@@ -1868,6 +1868,19 @@ declare class BkInput implements OnInit, OnDestroy, AfterViewInit, ControlValueA
     phoneOverlay?: CdkConnectedOverlay;
     isFocused: boolean;
     inputValue: string;
+    /**
+     * What the template's `[value]` binding actually renders. Deliberately a separate property
+     * from `inputValue` (which still mirrors the live text for `isFilled`/bookkeeping on every
+     * keystroke): re-applying `[value]` to an element that already displays that exact text is a
+     * no-op on most inputs, but on `type="number"` it isn't - Chromium doesn't skip the write just
+     * because the string is unchanged, and since `type="number"` also refuses `setSelectionRange`
+     * (it throws), we have no way to put the caret back afterwards. So `displayValue` is only ever
+     * written by genuinely external changes (writeValue(), the phone country-prefix swap) - never
+     * from handleInput() or the "parent mutated the native value" resync, both of which are only
+     * echoing back text the DOM already has. That keeps every self-originated edit from re-touching
+     * `.value` at all, which is the only reliable fix here given number inputs can't be caret-restored.
+     */
+    displayValue: string;
     isDropdownOpen: boolean;
     private pendingMaskedValue;
     private isPropagatingViewValue;
@@ -3719,7 +3732,7 @@ declare class BkPopover implements OnDestroy {
      * anything interactive. `hover` opens on the way in and closes on the way
      * out, with a grace period so the pointer can travel into the panel.
      */
-    trigger: _angular_core.InputSignal<"hover" | "click">;
+    trigger: _angular_core.InputSignal<"click" | "hover">;
     /** Optional heading. Empty hides the header row entirely. */
     title: _angular_core.InputSignal<string>;
     /** Show the × in the header. Ignored without a `title` to put it in. */
@@ -4566,7 +4579,7 @@ declare class BkTd extends BkCellBase implements AfterViewInit, OnDestroy {
      */
     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<"right" | "left" | "top" | "bottom">;
+    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>;
@@ -4883,5 +4896,402 @@ declare class BkTreeDrag<T = any> extends BkTableDrag implements OnDestroy {
 
 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 { ARROW_CORNER_GAP, BKTooltipDirective, BK_DEFAULT_DIALOG_CONFIG, BK_DIALOG_DATA, BK_DIALOG_GLOBAL_CONFIG, BK_TABLE, BkAvatar, BkAvatarGroup, BkAvatarUploader, BkBadge, BkBreadcrumb, 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, BkTooltipInteractionService, BkTrExpand, BkTreeDrag, BkValidator, BkVirtualScroll, BrickclayIcons, BrickclayLib, CalendarModule, CalendarMonth, CalendarSelection, CalendarWeekday, ColumnFilterOption, DEFAULT_COUNTRY_OPTIONS, NEUTRAL_APPEARANCE, OPPOSITE_SIDE, POPOVER_PLACEMENTS, clamp, 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, BkPageSizeVisibility, BkSelectGridColumn, BkSortDirection, BkSortFn, BkSortOrder, BkTableNoResult, BkTableQueryParams, BkTableScroll, BkTableSelection, BkTableSize, BkTableSizeToken, BkTextAreaAutoCapitalize, BkTextAreaAutoComplete, BkTextAreaInputMode, BkTooltipDismissible, BkTreeDragScope, BkTreeDropEvent, BkTreeDropPosition, BkTreeRow, BreadcrumbItem, 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, PopoverSide, ScheduledDateSelection, SortDirection, SpinnerSize, TabIconDirection, TabItem, TableAction, TableBadge, TableColumn, TableIcon, TableRows, TabsColors, TabsOrientation, TabsVariant, TimeConfiguration, ToastConfig, ToastMessage, ToastMethodOptions, ToastPosition, ToastSeverity };
+/**
+ * Types for bk-kanban.
+ *
+ * The board is content-agnostic by design (see the component's own doc
+ * comment): it only ever moves opaque `T` values between columns and reports
+ * what happened. Every type here describes either a column, or one of the
+ * events the board reports — never anything about what a card renders as.
+ */
+/** One column/status definition. Any number of columns — no fixed status set
+ *  assumed; a workflow with two lanes and one with fifteen both just pass a
+ *  `columns` array of the size they need. */
+interface BkKanbanColumn {
+    id: string;
+    label: string;
+    /** Cap on cards in this column. Omit for no limit — see `wipLimitBehavior`. */
+    wipLimit?: number;
+    /**
+     * Extra class(es) appended to this column's header bar — the row holding
+     * the label, the count badge, and `columnHeaderActionsTemplate`, if any.
+     * Named `colHeaderClass` (not `headerClass`) so it reads unambiguously as
+     * "this column's header" once a column is nested inside `bk-kanban`. Same
+     * idea as `panelClass` on `bk-dialog`/`bk-popover`, or `headerClass` on
+     * `bk-grid`'s `TableColumn`: it only adds to the header's own classes,
+     * bk-kanban's own layout still stands, and nothing stops you passing
+     * whatever you'd pass any other element — a single class, several, a
+     * whole Tailwind utility stack.
+     *
+     * For properties the header doesn't already declare (a `border`,
+     * `box-shadow`, rounded corners) a plain class works exactly as you'd
+     * expect. For its **background** specifically, set the
+     * `--bk-kanban-header-bg` custom property instead of a `bg-*` utility —
+     * Angular injects this component's own stylesheet after the page's
+     * global one, so a same-specificity utility class can never outrank the
+     * header's own background declaration; the custom property exists
+     * precisely so `colHeaderClass` still has a reliable way to change it.
+     */
+    colHeaderClass?: string;
+    /**
+     * Extra class(es) appended to this column's own wrapper — the element
+     * `wipLimit` feedback (`bk-kanban-column-warn`/`bk-kanban-column-live-over`)
+     * already lands on, and the ancestor `colHeaderClass` reaches the header
+     * through. Same idea as `colHeaderClass` one level up: it only adds to the
+     * wrapper's own classes, nothing here replaces bk-kanban's own layout.
+     *
+     * Same background caveat as `colHeaderClass` too — set the
+     * `--bk-kanban-column-bg` custom property rather than a `bg-*` utility to
+     * change the wrapper's background reliably; see `colHeaderClass`'s doc
+     * comment for why.
+     */
+    columnClass?: string;
+    /**
+     * Placeholder text shown in this column's body when it holds no cards,
+     * overriding the board-wide `noDataText` input for this column alone.
+     * Ignored once `emptyStateTemplate` is supplied — a template is a bigger
+     * override than swapping in different words, so it wins outright rather
+     * than being handed a piece of text it may not even render.
+     */
+    noDataText?: string;
+}
+/**
+ * How far a drag is allowed to travel.
+ *
+ * `'same'` only reorders within a column (manual prioritization on a board
+ * whose statuses shouldn't change from a drag). `'cross'` only moves cards
+ * between columns, with no in-column reordering. `'both'` (the default)
+ * allows either.
+ */
+type BkKanbanDragScope = 'same' | 'cross' | 'both';
+/**
+ * What happens when a drop would push a column's card count past its
+ * `wipLimit`.
+ *
+ * `'block'` rejects the drop — nothing is mutated, so the card returns to
+ * its origin the same way any cancelled CDK drag does. `'warn'` lets the
+ * drop through but flags the column. `'none'` ignores limits at drop time
+ * entirely (they still show in the header, purely as information).
+ * `columnLimitExceeded` fires whenever a drop *would* exceed the limit,
+ * regardless of which of the three is active.
+ */
+type BkKanbanWipLimitBehavior = 'block' | 'warn' | 'none';
+/**
+ * When WIP-limit feedback appears relative to the drop.
+ *
+ * `'live'` (default) highlights the hovered column the moment it would go
+ * over, while the drag is still in progress. `'on-drop'` says nothing until
+ * release, when `wipLimitBehavior` takes over. See the component doc for why
+ * `'live'` is the recommended default.
+ */
+type BkKanbanDragPreviewMode = 'live' | 'on-drop';
+/**
+ * Where *vertical* scrolling lives once content outgrows the board's given
+ * height (see the doc comment on `.bk-kanban` in `kanban.css` for how that
+ * height is resolved from the host in the first place). Horizontal
+ * scrolling — across columns — always lives on the board itself
+ * (`.bk-kanban`'s own `overflow-x: auto`) regardless of this setting; only
+ * the vertical axis moves.
+ *
+ * `'body'` (default): each column is stretched to the board's height and
+ * scrolls *independently* — its own header stays fixed, only
+ * `.bk-kanban-column-body` (the card list beneath it) scrolls, so a long
+ * column never pushes its own header out of view, and every column can be
+ * at a different scroll position at once.
+ *
+ * `'wrapper'`: the board itself — `.bk-kanban`, the element containing every
+ * column — is what scrolls vertically, all columns together as a single
+ * region (headers included). Columns fall back to their own natural height
+ * here rather than being stretched, since nothing needs bounding
+ * individually any more once the board is the one doing the scrolling.
+ */
+type BkKanbanColumnScrollMode = 'body' | 'wrapper';
+/** Emitted once a drag-and-drop completes — a same-column reorder or a
+ *  cross-column move. `fromColumnId === toColumnId` for the former. */
+interface BkKanbanCardMovedEvent<T = any> {
+    card: T;
+    fromColumnId: string;
+    toColumnId: string;
+    newIndex: number;
+}
+/** Emitted once a column reorder completes — see `columnDragEnabled`. Unlike
+ *  `cardMoved`, there's only one axis to report: columns don't nest inside
+ *  one another, so a move is always "this column, from this index, to this
+ *  one" rather than needing a from/to pair of containers. */
+interface BkKanbanColumnMovedEvent {
+    columnId: string;
+    fromIndex: number;
+    toIndex: number;
+}
+/**
+ * Emitted when a card (or a region inside it) is clicked.
+ *
+ * `target` is `'card'` for a click anywhere on the card that isn't a more
+ * specific region, or whatever name was given to a
+ * `[bkKanbanClickTarget]="'…'"` element the click landed inside.
+ */
+interface BkKanbanCardClickedEvent<T = any> {
+    card: T;
+    target: string;
+}
+/** Emitted when a drop would put a column over its `wipLimit` — see
+ *  `BkKanbanWipLimitBehavior` for when the drop itself still succeeds. */
+interface BkKanbanColumnLimitExceededEvent {
+    columnId: string;
+    wipLimit: number;
+    attemptedCount: number;
+}
+/** Reserved: see `columnActionTriggered` on `BkKanban` and
+ *  `BkKanbanColumnActionsContext.trigger`. */
+interface BkKanbanColumnActionTriggeredEvent {
+    columnId: string;
+}
+/**
+ * Template context for `columnHeaderActionsTemplate`.
+ *
+ * `$implicit` and `column` are the same value — both are provided so the
+ * template can use either `let-column` or the more explicit
+ * `let-column="column"`. `trigger()` is there purely for
+ * `columnActionTriggered`; most consumers bind their own click handler on
+ * their own template instead and never call it.
+ */
+interface BkKanbanColumnActionsContext {
+    $implicit: BkKanbanColumn;
+    column: BkKanbanColumn;
+    trigger: () => void;
+}
+/** Template context for `emptyStateTemplate`. */
+interface BkKanbanEmptyStateContext {
+    $implicit: BkKanbanColumn;
+    column: BkKanbanColumn;
+}
+/** Template context for `cardTemplate`. */
+interface BkKanbanCardContext<T = any> {
+    $implicit: T;
+    card: T;
+    column: BkKanbanColumn;
+    index: number;
+}
+
+/**
+ * Content-agnostic kanban board: column layout, card positioning and
+ * drag-and-drop, and nothing about what a card contains or what a click on
+ * one should do.
+ *
+ * The board never renders a card's insides itself — `cardTemplate` does that,
+ * receiving the card and its column as context:
+ *
+ *   <bk-kanban
+ *     [columns]="columns"
+ *     [cards]="cards()"
+ *     [cardTemplate]="card"
+ *     (cardMoved)="onCardMoved($event)"
+ *     (cardClicked)="onCardClicked($event)"
+ *   ></bk-kanban>
+ *
+ *   <ng-template #card let-card let-column="column">
+ *     <div [bkKanbanClickTarget]="'hours'">{{ card.hours }}h</div>
+ *     {{ card.title }}
+ *   </ng-template>
+ *
+ * That is deliberate, not an oversight — see the package spec's Design
+ * Principles. Three consequences fall out of it directly:
+ *
+ * - **Data ownership stays with the caller.** A move is reported through
+ *   `cardMoved`, not applied to some copy of `cards` this component keeps to
+ *   itself. Internally it *does* mutate the card objects it was handed
+ *   (`columnIdField`'s field, and an `order` field used to remember position
+ *   within a column) so the board redraws in the right place immediately,
+ *   exactly the way `bk-grid`'s own row-drag mutates `result` in place and
+ *   renumbers `sortOrder` — but persistence, and reverting the view if a
+ *   save fails, are the host's job. Reverting is just handing back a
+ *   `cards` array (or updated objects) that reflect the pre-move state; nothing
+ *   further to undo on this end.
+ * - **Clicks are reported, never acted on.** `cardClicked` says which card and
+ *   which named region (see `[bkKanbanClickTarget]`); opening a popup or
+ *   doing nothing at all is entirely up to whoever is listening.
+ * - **A card's own shape is never inspected**, beyond the two fields above.
+ *   Tags, hours, avatars, due dates — the board doesn't know they exist.
+ */
+declare class BkKanban<T = any> {
+    /** Column/status definitions. Unlimited — the board renders whatever it's given. */
+    columns: _angular_core.InputSignal<BkKanbanColumn[]>;
+    /** Flat card list. Grouped into columns via `columnIdField`, ordered within
+     *  a column by an `order` field when the cards carry one, otherwise left in
+     *  the sequence they appear here. */
+    cards: _angular_core.InputSignal<readonly T[]>;
+    /** Renders a card's body. Receives `{ $implicit: card, card, column, index }`. */
+    cardTemplate: _angular_core.InputSignal<TemplateRef<BkKanbanCardContext<T>>>;
+    /** Field name, or a resolver function, that gives a card's column id.
+     *
+     *  A field name can be both read and written, so a cross-column drop
+     *  updates it directly. A resolver function is read-only — the board still
+     *  reports the move via `cardMoved`, but leaves updating the source data to
+     *  the host, since there's nowhere on a function to write the new value. */
+    columnIdField: _angular_core.InputSignal<string | ((card: T) => string)>;
+    dragEnabled: _angular_core.InputSignal<boolean>;
+    dragScope: _angular_core.InputSignal<BkKanbanDragScope>;
+    wipLimitBehavior: _angular_core.InputSignal<BkKanbanWipLimitBehavior>;
+    /** Lets columns themselves be dragged into a new order, via their header
+     *  (`.bk-kanban-column-header` is the drag handle — a card's own drag
+     *  keeps working independently, since it's a separate, unconnected drop
+     *  list one level down). Off by default: reordering the board's own
+     *  columns is a bigger commitment than reordering cards within it, and not
+     *  every consumer wants a "To do / In progress / Done" pipeline to be
+     *  rearrangeable. `columns` is mutated in place the same way `cards` is
+     *  (see the component doc) — persisting the new order, if it needs to be,
+     *  is the host's job, done from `columnMoved`. */
+    columnDragEnabled: _angular_core.InputSignal<boolean>;
+    /** See `BkKanbanColumnScrollMode`. */
+    columnScrollMode: _angular_core.InputSignal<BkKanbanColumnScrollMode>;
+    /** Extra class(es) appended to the board's own wrapper — `.bk-kanban-board`
+     *  in `kanban.html`, the element that directly contains the scrollable
+     *  region holding every column. Same idea as `columnClass`/`colHeaderClass`
+     *  one level down: it only adds classes, nothing here replaces bk-kanban's
+     *  own layout.
+     *
+     *  Deliberately kept off the *scrolling* element itself
+     *  (`.bk-kanban`, one level further in): a `padding` or `border` in here
+     *  would otherwise become part of what has to be scrolled past, and change
+     *  where the scrollbar itself ends up sitting relative to the columns —
+     *  this wrapper exists specifically so `boardClass` can decorate (a
+     *  background, a border, padding around the whole board) without ever
+     *  touching the box CDK and `columnScrollMode` are actually scrolling. */
+    boardClass: _angular_core.InputSignal<string>;
+    /** Identity for `@for`'s `track`. Defaults to position in the rendered column. */
+    trackBy: _angular_core.InputSignal<((card: T) => string | number) | null>;
+    /** Rendered in a fixed slot in every column's header — e.g. an "add card"
+     *  button. Receives `BkKanbanColumnActionsContext`. The board owns where it
+     *  sits; the consumer owns what it does. */
+    columnHeaderActionsTemplate: _angular_core.InputSignal<TemplateRef<BkKanbanColumnActionsContext> | null>;
+    /** Overrides the built-in "No cards" placeholder for an empty column.
+     *  Receives `BkKanbanEmptyStateContext`. Takes priority over both
+     *  `noDataText` and a column's own `noDataText` — see `emptyStateText`. */
+    emptyStateTemplate: _angular_core.InputSignal<TemplateRef<BkKanbanEmptyStateContext> | null>;
+    /** Board-wide placeholder text for an empty column, used whenever a column
+     *  doesn't set its own `noDataText`. Only read when `emptyStateTemplate`
+     *  isn't supplied — see `emptyStateText`. */
+    noDataText: _angular_core.InputSignal<string>;
+    /** Whether a column flags an over-limit drop while still dragging (`'live'`)
+     *  or only once the drop is attempted (`'on-drop'`). See the doc block on
+     *  `isLiveOverLimit` for how the two relate to `wipLimitBehavior`. */
+    dragPreviewMode: _angular_core.InputSignal<BkKanbanDragPreviewMode>;
+    cardMoved: _angular_core.OutputEmitterRef<BkKanbanCardMovedEvent<T>>;
+    cardClicked: _angular_core.OutputEmitterRef<BkKanbanCardClickedEvent<T>>;
+    columnLimitExceeded: _angular_core.OutputEmitterRef<BkKanbanColumnLimitExceededEvent>;
+    /** A column reorder completed — see `columnDragEnabled`. */
+    columnMoved: _angular_core.OutputEmitterRef<BkKanbanColumnMovedEvent>;
+    /** Reserved — see `BkKanbanColumnActionsContext.trigger`. Most consumers
+     *  bind a click handler directly on their own header-actions template and
+     *  never reach for this. */
+    columnActionTriggered: _angular_core.OutputEmitterRef<BkKanbanColumnActionTriggeredEvent>;
+    /**
+     * Bumped after every in-place mutation (`setColumnId`, `renumber`) so
+     * `grouped` re-runs even though neither `cards()`'s array identity nor any
+     * card's object identity changed — the same trick as the table demo's
+     * `pgSelectionTick`, needed for exactly the same reason: signals only
+     * notice a new reference, and mutating fields in place is what lets a drop
+     * redraw in the right place without waiting on the host to hand back a
+     * whole new array.
+     */
+    private readonly structureTick;
+    /** Cards grouped by column id, each group in `order` order when present
+     *  (falling back to their sequence in `cards()` otherwise). Cards whose
+     *  resolved column id matches no known column are dropped silently rather
+     *  than rendered nowhere. */
+    private readonly grouped;
+    /** The cards to render for one column, in display order. */
+    cardsFor(columnId: string): T[];
+    private resolveColumnId;
+    private cardOrder;
+    resolveTrackBy(card: T, index: number): string | number;
+    /** Column-header count badge, flagged once the column is over its limit —
+     *  only while `wipLimitBehavior` is `'warn'`; `'block'` should never let a
+     *  column get there and `'none'` treats the number as pure information. */
+    isColumnOverLimit(column: BkKanbanColumn): boolean;
+    /** "3" with no limit, "3 / 5" with one — the header count badge's label. */
+    columnCountLabel(column: BkKanbanColumn): string;
+    columnActionsContext(column: BkKanbanColumn): BkKanbanColumnActionsContext;
+    emptyStateContext(column: BkKanbanColumn): BkKanbanEmptyStateContext;
+    /** Text for the built-in empty-column placeholder: a column's own
+     *  `noDataText` when it sets one, else the board-wide `noDataText` input.
+     *  Only consulted when `emptyStateTemplate` isn't supplied — the template
+     *  wins outright once given, exactly like `emptyStateContext` itself. */
+    emptyStateText(column: BkKanbanColumn): string;
+    cardContext(card: T, column: BkKanbanColumn, index: number): BkKanbanCardContext<T>;
+    /** Which columns a column's drop list connects to, per `dragScope`. */
+    connectedListIds(columnId: string): string[];
+    /** `'cross'` means *only* moves between columns — reordering within one has
+     *  to be switched off at the list level, since a scoped-out `connectedTo`
+     *  alone still leaves the list free to sort itself. */
+    readonly sortingDisabled: _angular_core.Signal<boolean>;
+    /**
+     * `columns` is reordered in place — same trick as `cards` (see the
+     * component doc): the array reference the host handed in is mutated
+     * directly (`moveItemInArray`) rather than swapped for a new one, so the
+     * next render just reflects the new order. There's no `structureTick`-style
+     * signal to bump here the way card moves need one — nothing derives
+     * columns through a `computed()` the way `cardsFor` derives through
+     * `grouped`; the template reads `columns()` directly in its `@for`, so the
+     * drop event's own change detection pass is enough.
+     */
+    onColumnDrop(event: CdkDragDrop<BkKanbanColumn[]>): void;
+    private readonly dragSourceColumnId;
+    private readonly hoveredOverLimitColumnId;
+    onDragStarted(column: BkKanbanColumn): void;
+    onDragEnded(): void;
+    /**
+     * Live WIP-limit preview (§12 of the spec): as the dragged card enters a
+     * column, work out whether *landing* here would exceed its `wipLimit` and
+     * flag it immediately — before release, and independent of
+     * `wipLimitBehavior`, which only governs what happens once the card is
+     * actually dropped. A card re-entering its own source column doesn't grow
+     * that column's count, so only a genuine cross-column entry counts as +1.
+     */
+    onListEntered(event: CdkDragEnter<T[]>, column: BkKanbanColumn): void;
+    onListExited(column: BkKanbanColumn): void;
+    isLiveOverLimit(column: BkKanbanColumn): boolean;
+    onDrop(event: CdkDragDrop<T[]>, column: BkKanbanColumn): void;
+    private setColumnId;
+    private renumber;
+    /**
+     * One listener per card resolves both the whole-card click and every
+     * `[bkKanbanClickTarget]` region: `closest()` from the actual event target
+     * finds the nearest marked ancestor within this card, or there isn't one
+     * and it's a plain card click. Either way this fires exactly once — never
+     * once for the region and again for the card underneath it.
+     */
+    onCardClick(event: MouseEvent, card: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkKanban<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BkKanban<any>, "bk-kanban", ["bkKanban"], { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "cards": { "alias": "cards"; "required": true; "isSignal": true; }; "cardTemplate": { "alias": "cardTemplate"; "required": true; "isSignal": true; }; "columnIdField": { "alias": "columnIdField"; "required": false; "isSignal": true; }; "dragEnabled": { "alias": "dragEnabled"; "required": false; "isSignal": true; }; "dragScope": { "alias": "dragScope"; "required": false; "isSignal": true; }; "wipLimitBehavior": { "alias": "wipLimitBehavior"; "required": false; "isSignal": true; }; "columnDragEnabled": { "alias": "columnDragEnabled"; "required": false; "isSignal": true; }; "columnScrollMode": { "alias": "columnScrollMode"; "required": false; "isSignal": true; }; "boardClass": { "alias": "boardClass"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "columnHeaderActionsTemplate": { "alias": "columnHeaderActionsTemplate"; "required": false; "isSignal": true; }; "emptyStateTemplate": { "alias": "emptyStateTemplate"; "required": false; "isSignal": true; }; "noDataText": { "alias": "noDataText"; "required": false; "isSignal": true; }; "dragPreviewMode": { "alias": "dragPreviewMode"; "required": false; "isSignal": true; }; }, { "cardMoved": "cardMoved"; "cardClicked": "cardClicked"; "columnLimitExceeded": "columnLimitExceeded"; "columnMoved": "columnMoved"; "columnActionTriggered": "columnActionTriggered"; }, never, never, true, never>;
+}
+
+/**
+ * Marks an element inside a `cardTemplate` as its own click region.
+ *
+ * `bk-kanban` never attaches a listener to this element directly — it puts
+ * one listener on the whole card and, on click, walks up from
+ * `event.target` (`Element.closest`) looking for the nearest marked
+ * ancestor. That single-listener design is what makes a click on a marked
+ * region resolve to *just* that region's name, instead of firing once for
+ * the region and once more, as a duplicate, for the card underneath it.
+ * This directive's only job is to leave something that walk can find: a
+ * `data-bk-kanban-click-target` attribute carrying the name you gave it.
+ *
+ *   <div [bkKanbanClickTarget]="'hours'">{{ card.hours }}h</div>
+ *   <div [bkKanbanClickTarget]="'assignee'">
+ *     <bk-ui-avatar [name]="card.assignee"></bk-ui-avatar>
+ *   </div>
+ *
+ * A click on either fires `cardClicked` with `target: 'hours'` /
+ * `'assignee'`; a click anywhere else on the card falls back to the default
+ * `target: 'card'`. See `BkKanbanCardClickedEvent`.
+ */
+declare class BkKanbanClickTarget {
+    target: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BkKanbanClickTarget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BkKanbanClickTarget, "[bkKanbanClickTarget]", never, { "target": { "alias": "bkKanbanClickTarget"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ARROW_CORNER_GAP, BKTooltipDirective, BK_DEFAULT_DIALOG_CONFIG, BK_DIALOG_DATA, BK_DIALOG_GLOBAL_CONFIG, BK_TABLE, BkAvatar, BkAvatarGroup, BkAvatarUploader, BkBadge, BkBreadcrumb, BkButton, BkButtonGroup, BkCalendarManagerService, BkCheckbox, BkColumnFilterService, BkColumnSelect, BkCustomCalendar, BkDialogActions, BkDialogClose, BkDialogContent, BkDialogModule, BkDialogRef, BkDialogService, BkDialogTitle, BkDragHandle, BkDropdown, BkFileCard, BkFilePicker, BkGrid, BkHierarchicalSelect, BkIconButton, BkInput, BkInputChips, BkKanban, BkKanbanClickTarget, BkLoader, BkMenu, BkPagination, BkPill, BkPopover, BkRadioButton, BkScheduledDatePicker, BkSelect, BkSpinner, BkTable, BkTableDrag, BkTableFooter, BkTableSummary, BkTableTitle, BkTabs, BkTd, BkTextarea, BkTh, BkTimePicker, BkToastr, BkToastrService, BkToggle, BkTooltipInteractionService, BkTrExpand, BkTreeDrag, BkValidator, BkVirtualScroll, BrickclayIcons, BrickclayLib, CalendarModule, CalendarMonth, CalendarSelection, CalendarWeekday, ColumnFilterOption, DEFAULT_COUNTRY_OPTIONS, NEUTRAL_APPEARANCE, OPPOSITE_SIDE, POPOVER_PLACEMENTS, clamp, 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, BkKanbanCardClickedEvent, BkKanbanCardContext, BkKanbanCardMovedEvent, BkKanbanColumn, BkKanbanColumnActionTriggeredEvent, BkKanbanColumnActionsContext, BkKanbanColumnLimitExceededEvent, BkKanbanColumnMovedEvent, BkKanbanColumnScrollMode, BkKanbanDragPreviewMode, BkKanbanDragScope, BkKanbanEmptyStateContext, BkKanbanWipLimitBehavior, BkLoaderVariant, BkPageSize, BkPageSizeVisibility, BkSelectGridColumn, BkSortDirection, BkSortFn, BkSortOrder, BkTableNoResult, BkTableQueryParams, BkTableScroll, BkTableSelection, BkTableSize, BkTableSizeToken, BkTextAreaAutoCapitalize, BkTextAreaAutoComplete, BkTextAreaInputMode, BkTooltipDismissible, BkTreeDragScope, BkTreeDropEvent, BkTreeDropPosition, BkTreeRow, BreadcrumbItem, 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, PopoverSide, ScheduledDateSelection, SortDirection, SpinnerSize, TabIconDirection, TabItem, TableAction, TableBadge, TableColumn, TableIcon, TableRows, TabsColors, TabsOrientation, TabsVariant, TimeConfiguration, ToastConfig, ToastMessage, ToastMethodOptions, ToastPosition, ToastSeverity };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brickclay-org/ui",
-  "version": "0.1.90",
+  "version": "0.1.92",
   "schematics": "./schematics/collection.json",
   "ng-add": {
     "save": "dependencies"

package/src/lib/toastr/toastr.css

@@ -14,8 +14,10 @@
   pointer-events: none;
 }
 
-/* Guarantee toasts stack above dialogs/popovers/etc. that also use CDK overlays — CDK's own
-   z-index otherwise just reflects creation order. Targets the pane CDK wraps this panel in. */
+/* Belt-and-braces: pins the pane itself in case some future overlay ever nests a pane inside
+   this one's wrapper. The stacking fight against *other* overlays (dialogs, selects, popovers)
+   actually happens one level up, at the wrapper CDK puts around the pane — see the
+   `hostElement.style.zIndex` line in toastr.service.ts, which is the real fix for that. */
 .cdk-overlay-pane.bk-toastr-panel {
   z-index: 2147483647 !important;
 }

package/src/styles.css

@@ -44,6 +44,7 @@
 @import './lib/menu/menu.css';
 @import './lib/ui-avatar-group/ui-avatar-group.css';
 @import './lib/table/table.css';
+@import './lib/kanban/kanban.css';
 @import './lib/calender/components/custom-calendar/custom-calendar.component.css';
 @import './lib/calender/components/scheduled-date-picker/scheduled-date-picker.component.css';
 @import './lib/calender/components/time-picker/time-picker.component.css';