@mintplayer/ng-bootstrap 21.29.0 → 21.31.0

package/types/mintplayer-ng-bootstrap-color-picker.d.ts

@@ -81,12 +81,14 @@ declare class BsColorWheelComponent {
     hs: _angular_core.ModelSignal<HS>;
     hsChange: _angular_core.OutputEmitterRef<HS>;
     disabled: _angular_core.InputSignal<boolean>;
+    ariaLabel: _angular_core.InputSignal<string>;
     private readonly isPointerDown;
     squareSize: _angular_core.Signal<number>;
     shiftX: _angular_core.Signal<number>;
     shiftY: _angular_core.Signal<number>;
     outerRadius: _angular_core.Signal<number>;
     overlayOpacity: _angular_core.Signal<number>;
+    ariaValueText: _angular_core.Signal<string>;
     markerPosition: _angular_core.Signal<{
         x: number;
         y: number;
@@ -95,9 +97,22 @@ declare class BsColorWheelComponent {
     onPointerDown(ev: MouseEvent | TouchEvent): void;
     onPointerMove(ev: MouseEvent | TouchEvent): void;
     onPointerUp(_ev: MouseEvent | TouchEvent): void;
+    /**
+     * Keyboard model for the 2-D wheel:
+     *  ArrowLeft  / ArrowRight  → -1° / +1° hue          (Shift: stays 1° for "fine")
+     *  ArrowDown / ArrowUp      → -1% / +1% saturation   (Shift: stays 1% for "fine")
+     *  PageDown / PageUp        → -30° / +30° hue
+     *  Home / End               → saturation 100% / 0%
+     *
+     * Hue wraps around; saturation clamps. Sighted-keyboard users get the same
+     * wheel as mouse users; blind users typically prefer the channel sliders
+     * (toggleable in bs-color-picker), since aria-valuetext on a 2-D widget is
+     * harder to spatialise than two 1-D sliders.
+     */
+    onKeydown(ev: KeyboardEvent): void;
     private updateColor;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsColorWheelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsColorWheelComponent, "bs-color-wheel", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "brightness": { "alias": "brightness"; "required": false; "isSignal": true; }; "hs": { "alias": "hs"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "width": "widthChange"; "height": "heightChange"; "brightness": "brightnessChange"; "hs": "hsChange"; "hsChange": "hsChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsColorWheelComponent, "bs-color-wheel", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "brightness": { "alias": "brightness"; "required": false; "isSignal": true; }; "hs": { "alias": "hs"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "width": "widthChange"; "height": "heightChange"; "brightness": "brightnessChange"; "hs": "hsChange"; "hsChange": "hsChange"; }, never, never, true, never>;
 }
 
 declare class BsColorPickerValueAccessor implements ControlValueAccessor {
@@ -119,6 +134,17 @@ declare class BsColorPickerComponent {
     size: _angular_core.InputSignal<number>;
     disabled: _angular_core.WritableSignal<boolean>;
     allowAlpha: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), a "Show hue + saturation sliders" toggle is rendered
+     * below the picker. Toggling it reveals dedicated 1-D sliders for hue and
+     * saturation alongside the existing brightness/alpha strips, giving keyboard
+     * and screen-reader users a 1-D path for every channel without having to
+     * spatialise the 2-D wheel. Set to false to hide both the toggle and the
+     * channel sliders entirely (e.g. when the consuming app provides its own
+     * accessibility settings UI).
+     */
+    showAccessibilityToggle: _angular_core.InputSignal<boolean>;
+    channelSlidersVisible: _angular_core.ModelSignal<boolean>;
     hs: _angular_core.WritableSignal<HS>;
     brightness: _angular_core.WritableSignal<number>;
     alpha: _angular_core.ModelSignal<number>;
@@ -132,7 +158,41 @@ declare class BsColorPickerComponent {
     onUserBrightnessChange(brightness: number): void;
     onUserAlphaChange(alpha: number): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsColorPickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsColorPickerComponent, "bs-color-picker", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "allowAlpha": { "alias": "allowAlpha"; "required": false; "isSignal": true; }; "alpha": { "alias": "alpha"; "required": false; "isSignal": true; }; }, { "alpha": "alphaChange"; }, never, never, true, [{ directive: typeof BsColorPickerValueAccessor; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsColorPickerComponent, "bs-color-picker", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "allowAlpha": { "alias": "allowAlpha"; "required": false; "isSignal": true; }; "showAccessibilityToggle": { "alias": "showAccessibilityToggle"; "required": false; "isSignal": true; }; "channelSlidersVisible": { "alias": "channelSlidersVisible"; "required": false; "isSignal": true; }; "alpha": { "alias": "alpha"; "required": false; "isSignal": true; }; }, { "channelSlidersVisible": "channelSlidersVisibleChange"; "alpha": "alphaChange"; }, never, never, true, [{ directive: typeof BsColorPickerValueAccessor; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Hue picker — a horizontal rainbow strip backed by `bs-slider`. Two-way
+ * `[(hs)]` keeps the saturation untouched; only `hs.hue` (0–360°) changes.
+ * Inherits the slider's APG keyboard model (Arrow keys, Home/End, PageUp/Down).
+ */
+declare class BsHueStripComponent {
+    disabled: _angular_core.InputSignal<boolean>;
+    hs: _angular_core.ModelSignal<HS>;
+    /** Hue normalized to 0..1 for the underlying bs-slider (which works in 0..1). */
+    normalizedHue: _angular_core.Signal<number>;
+    /** Rainbow gradient — every hue at full saturation/lightness. */
+    readonly trackGradient: string;
+    thumbBackground: _angular_core.Signal<string>;
+    onValueChange(v: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsHueStripComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsHueStripComponent, "bs-hue-strip", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hs": { "alias": "hs"; "required": false; "isSignal": true; }; }, { "hs": "hsChange"; }, never, never, true, never>;
+}
+
+/**
+ * Saturation picker — a horizontal grey-to-pure-colour strip backed by
+ * `bs-slider`. Two-way `[(hs)]` keeps the hue untouched; only `hs.saturation`
+ * (0–1) changes. The track gradient re-derives from the current hue so the
+ * preview always matches what the user is about to pick.
+ */
+declare class BsSaturationStripComponent {
+    disabled: _angular_core.InputSignal<boolean>;
+    hs: _angular_core.ModelSignal<HS>;
+    trackGradient: _angular_core.Signal<string>;
+    thumbBackground: _angular_core.Signal<string>;
+    onValueChange(v: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSaturationStripComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSaturationStripComponent, "bs-saturation-strip", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hs": { "alias": "hs"; "required": false; "isSignal": true; }; }, { "hs": "hsChange"; }, never, never, true, never>;
 }
 
 declare class BsSliderComponent {
@@ -140,15 +200,26 @@ declare class BsSliderComponent {
     readonly thumb: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     disabled: _angular_core.InputSignal<boolean>;
     value: _angular_core.ModelSignal<number>;
+    /** Accessible name for SR users. e.g. "Brightness", "Alpha", "Hue". */
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Multiplier applied to the 0..1 value when reporting it through aria-valuenow / aria-valuemax / aria-valuetext. 100 = percent (default); 360 = degrees; 255 = byte; etc. */
+    valueScale: _angular_core.InputSignal<number>;
+    /** Suffix appended to aria-valuetext after the scaled number. Defaults to "%". Use "°" for hue, "" for unitless. */
+    valueUnit: _angular_core.InputSignal<string>;
     private isPointerDown;
     thumbLeft: _angular_core.Signal<string>;
     cursorClass: _angular_core.Signal<string>;
+    /** Scaled current value for aria-valuenow (e.g. 0..100 for percent, 0..360 for hue). */
+    ariaValueNow: _angular_core.Signal<number>;
+    /** Human-readable value for SR with the configured unit. */
+    ariaValueText: _angular_core.Signal<string>;
     onPointerDown(ev: MouseEvent | TouchEvent): void;
     onPointerMove(ev: MouseEvent | TouchEvent): void;
     onPointerUp(_ev: MouseEvent | TouchEvent): void;
+    onKeydown(ev: KeyboardEvent): void;
     private updateColor;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSliderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSliderComponent, "bs-slider", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[bsTrack]", "[bsThumb]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSliderComponent, "bs-slider", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "valueScale": { "alias": "valueScale"; "required": false; "isSignal": true; }; "valueUnit": { "alias": "valueUnit"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[bsTrack]", "[bsThumb]"], true, never>;
 }
 declare class BsThumbDirective {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsThumbDirective, never>;
@@ -161,5 +232,5 @@ declare class BsTrackDirective {
 
 type HtmlColor = `#${string}`;
 
-export { BsAlphaStripComponent, BsBrightnessStripComponent, BsColorPickerComponent, BsColorPickerValueAccessor, BsColorWheelComponent, BsSliderComponent, BsThumbDirective, BsTrackDirective, hex2hsv, hex2rgb, hs2polar, hsl2hsv, hsl2rgb, hsv2hex, hsv2hsl, hsv2rgb, polar2hs, rgb2hex, rgb2hsl, rgb2hsv };
+export { BsAlphaStripComponent, BsBrightnessStripComponent, BsColorPickerComponent, BsColorPickerValueAccessor, BsColorWheelComponent, BsHueStripComponent, BsSaturationStripComponent, BsSliderComponent, BsThumbDirective, BsTrackDirective, hex2hsv, hex2rgb, hs2polar, hsl2hsv, hsl2rgb, hsv2hex, hsv2hsl, hsv2rgb, polar2hs, rgb2hex, rgb2hsl, rgb2hsv };
 export type { HS, HslColor, HsvColor, HtmlColor, RgbColor };

package/types/mintplayer-ng-bootstrap-datatable.d.ts

@@ -32,7 +32,7 @@ declare abstract class DatatableSortBase {
     getSortIndex(columnName: string): number;
     getSortDirection(columnName: string): 'ascending' | 'descending' | null;
     onHeaderMouseDown(event: MouseEvent): void;
-    columnHeaderClicked(column: BsDatatableColumnDirective, event: MouseEvent): void;
+    columnHeaderClicked(column: BsDatatableColumnDirective, event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatatableSortBase, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatatableSortBase, never, never, { "settings": { "alias": "settings"; "required": false; "isSignal": true; }; }, { "settings": "settingsChange"; }, ["columns"], never, true, never>;
 }

package/types/mintplayer-ng-bootstrap-dock.d.ts

@@ -96,6 +96,14 @@ declare class MintDockManagerElement extends LitElement {
     private dropJoystick;
     private dropJoystickButtons;
     private readonly instanceId;
+    private readonly liveAnnouncer;
+    /**
+     * Active keyboard-driven pane move (Phase 7 of WC ARIA PRD). The user
+     * pressed M on a focused tab; until they pick a destination key (T/R/B/L
+     * to dock to a side, F to float) or Escape, we intercept letter keys and
+     * route them to the synthetic-drop pipeline.
+     */
+    private paneMoveMode;
     private dropJoystickTarget;
     private rootLayout;
     private floatingLayouts;
@@ -146,6 +154,18 @@ declare class MintDockManagerElement extends LitElement {
     private onSplitterResize;
     private scheduleRenderIntersectionHandles;
     private renderIntersectionHandles;
+    /**
+     * Keyboard resize on a focused intersection handle. ArrowLeft/Right resize
+     * the vertical divider the handle sits on; ArrowUp/Down resize the
+     * horizontal divider. Home/End shrink/grow the leading panel of whichever
+     * axis is implied by the key. Shift = fine 1% step.
+     *
+     * Internally delegates to mp-splitter.resizeDividerBy() so the percent-step
+     * + clamp math lives in one place. If a 2D handle straddles multiple split
+     * pairs (sibling splitters whose dividers happen to overlap), the first
+     * pair drives — same precedence as the pointer drag path.
+     */
+    private onIntersectionKeyDown;
     private beginCornerResize;
     private handleCornerResizeMove;
     private endCornerResize;
@@ -295,6 +315,37 @@ declare class MintDockManagerElement extends LitElement {
     private setActivePaneForLocation;
     private reorderPaneInLocation;
     private removeFloatingAt;
+    /**
+     * Keyboard handler on the dock root, registered in capture phase so it
+     * runs before mp-tab-control's shadow-internal handlers swallow Arrow /
+     * Home / End / Enter. M opens move mode on a focused tab; subsequent
+     * letter keys (T/R/B/L/F) commit the move; Escape cancels.
+     */
+    private onRootKeyDown;
+    private handlePaneMoveModeKey;
+    /**
+     * Walk the focused element through nested shadow roots to find a focused
+     * tab button, then map it back to the dock's pane name + source path via
+     * the data attributes on the slotted .dock-tab span.
+     */
+    private findFocusedPaneOrigin;
+    /**
+     * Synthesise a minimal dragState so handleDrop's existing pipeline can
+     * commit the keyboard-driven move. handleDrop reads {pane, sourcePath,
+     * dropHandled} — the rest of dragState is pointer-drag bookkeeping that
+     * doesn't apply here.
+     */
+    private synthesiseDragStateForKeyboardMove;
+    private commitPaneMoveToZone;
+    private commitPaneMoveAsFloat;
+    /**
+     * Close a floating pane via the chrome's close button (or any external
+     * caller). Announces the close to SR users, redraws the dock, and emits a
+     * layout-changed event. Phase 4 of the WC ARIA PRD — the floating chrome
+     * had no close affordance before this; users had to programmatically pop
+     * the pane out of `floatingLayouts`.
+     */
+    private closeFloatingPane;
     private removePaneFromFloating;
     private normalizeSizesArray;
     private normalizeSplitNode;

package/types/mintplayer-ng-bootstrap-dropdown-menu.d.ts

@@ -1,21 +1,66 @@
+import * as _mintplayer_ng_bootstrap_dropdown from '@mintplayer/ng-bootstrap/dropdown';
 import * as _angular_core from '@angular/core';
-import { AfterViewInit } from '@angular/core';
+import { ElementRef, AfterViewInit } from '@angular/core';
+
+declare class BsDropdownItemComponent {
+    private parent;
+    private menu;
+    /** Public so BsDropdownMenuComponent can imperatively focus this item during keyboard nav. */
+    readonly elementRef: ElementRef<HTMLElement>;
+    private ids;
+    readonly isSelected: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly itemRole: _angular_core.Signal<"option" | "menuitem">;
+    readonly ariaSelected: _angular_core.Signal<"true" | "false" | null>;
+    /**
+     * Roving tabindex in menu mode: the focused item is 0, others -1.
+     * In listbox mode (typeahead/select2/etc.), the consumer applies bsRovingFocusItem
+     * externally for activedescendant management; this binding stays null so it
+     * doesn't fight that directive.
+     */
+    readonly tabindex: _angular_core.Signal<number | null>;
+    /**
+     * Resolved after first render so static `id="…"` attributes set by the consumer
+     * and any sibling host bindings have applied first. Read-only access for any
+     * other directive on the same element (e.g. BsRovingFocusItem) that needs a
+     * stable target id for aria-activedescendant.
+     */
+    get itemId(): string;
+    constructor();
+    onFocus(): void;
+    onActivate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownItemComponent, "bs-dropdown-item", never, { "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
 
 declare class BsDropdownMenuComponent implements AfterViewInit {
     private bsDropdown;
     readonly maxHeight: _angular_core.InputSignal<number | null>;
     dropdownWith: _angular_core.WritableSignal<string | null>;
+    readonly menuRole: _angular_core.Signal<_mintplayer_ng_bootstrap_dropdown.BsDropdownPopupRole | null>;
+    readonly menuId: _angular_core.Signal<string | null>;
+    /**
+     * Items projected into this menu. Used in menu mode (popupRole='menu') to
+     * implement roving-tabindex keyboard navigation. In listbox mode, callers
+     * (typeahead/select2/etc.) typically apply their own bsRovingFocus directly,
+     * so this menu's keyboard handler is a no-op.
+     */
+    readonly dropdownItems: _angular_core.Signal<readonly BsDropdownItemComponent[]>;
+    /** True when this is a plain menu (default), false when used as a combobox listbox. */
+    readonly isMenuMode: _angular_core.Signal<boolean>;
+    /** Index into dropdownItems() of the item that currently holds the roving tabindex (menu mode). */
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    isItemFocused(item: BsDropdownItemComponent): boolean;
+    setFocusedItem(item: BsDropdownItemComponent): void;
     onResize(): void;
     ngAfterViewInit(): void;
+    onKeydown(event: KeyboardEvent): void;
+    private moveFocus;
+    private firstEnabledIndex;
+    private lastEnabledIndex;
+    private moveTo;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownMenuComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownMenuComponent, "bs-dropdown-menu", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
-}
-
-declare class BsDropdownItemComponent {
-    readonly isSelected: _angular_core.InputSignal<boolean>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownItemComponent, "bs-dropdown-item", never, { "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownMenuComponent, "bs-dropdown-menu", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, ["dropdownItems"], ["*"], true, never>;
 }
 
 export { BsDropdownItemComponent, BsDropdownMenuComponent };

package/types/mintplayer-ng-bootstrap-dropdown.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
+import { BsRovingFocusDirective } from '@mintplayer/ng-bootstrap/a11y';
 import { ClickOutsideDirective } from '@mintplayer/ng-click-outside';
 
 declare class BsDropdownMenuDirective extends ClickOutsideDirective {
@@ -9,9 +10,11 @@ declare class BsDropdownMenuDirective extends ClickOutsideDirective {
     private overlay;
     private destroy;
     private bsDevelopment;
+    private overlayStack;
     private wait;
     private overlayRef;
     private templatePortal;
+    private stackToken;
     constructor();
     clickedOutside(event: Event): void;
     onEscape(event: Event): void;
@@ -29,19 +32,71 @@ declare class BsDropdownToggleDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownToggleDirective, "[bsDropdownToggle]", never, {}, {}, never, never, true, never>;
 }
 
+type BsDropdownPopupRole = 'menu' | 'listbox';
 declare class BsDropdownDirective {
     elementRef: ElementRef<HTMLElement>;
     private bsDevelopment;
+    private ids;
     readonly menu: _angular_core.Signal<BsDropdownMenuDirective>;
     readonly toggle: _angular_core.Signal<BsDropdownToggleDirective | undefined>;
+    readonly rovingFocus: _angular_core.Signal<BsRovingFocusDirective | undefined>;
     hasBackdrop: _angular_core.InputSignal<boolean>;
     sameWidth: _angular_core.InputSignal<boolean>;
     closeOnClickOutside: _angular_core.InputSignal<boolean>;
     sameDropdownWidth: _angular_core.InputSignal<boolean>;
     isOpen: _angular_core.ModelSignal<boolean>;
+    readonly popupRole: _angular_core.InputSignal<BsDropdownPopupRole>;
+    /** Reactive id used for the menu's host id and for the toggle's aria-controls. Empty until afterNextRender resolves the host's static id (or generates one), so sibling host bindings on the wrapper element get a chance to land first. */
+    private _menuId;
+    readonly menuId: _angular_core.Signal<string>;
+    constructor();
     onBlur(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownDirective, "[bsDropdown]", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "sameWidth": { "alias": "sameWidth"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "sameDropdownWidth": { "alias": "sameDropdownWidth"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, ["menu", "toggle"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownDirective, "[bsDropdown]", ["bsDropdown"], { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "sameWidth": { "alias": "sameWidth"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "sameDropdownWidth": { "alias": "sameDropdownWidth"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "popupRole": { "alias": "popupRole"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, ["menu", "toggle", "rovingFocus"], never, true, never>;
+}
+
+type BsComboboxAutocomplete = 'none' | 'list' | 'inline' | 'both';
+type BsComboboxNavigateDirection = 'next' | 'prev' | 'first' | 'last';
+/**
+ * APG Combobox pattern — turns a plain `<input>` into a combobox that drives
+ * an adjacent `bsDropdown` popup (typeahead, select2, multiselect, searchbox).
+ *
+ * The directive owns the input-side ARIA wiring:
+ * - `role="combobox"` on the host
+ * - `aria-expanded` / `aria-controls` derived from the parent dropdown
+ * - `aria-activedescendant` mirroring the dropdown's `bsRovingFocus` active id
+ * - `aria-autocomplete` (defaults to `"list"`)
+ *
+ * Keyboard model:
+ * - **ArrowUp/Down/Home/End** — opens the popup if closed; once open,
+ *   forwards to the dropdown's `bsRovingFocus` (or emits a `navigate` event
+ *   if no roving-focus is found, so consumers can manage navigation manually).
+ * - **Enter** — fires `activate` so the consumer can commit the highlighted
+ *   option. `stopImmediatePropagation` is called to keep sibling
+ *   `(keydown.enter)` listeners on the same input (e.g. "submit free-text
+ *   search") from also firing on the same Enter.
+ * - **Escape** — closes the popup and fires `cancel`.
+ * - **Tab** — hybrid behaviour: while the popup is open and a roving-focus
+ *   is present, Tab advances the active descendant; at the boundary, Tab
+ *   closes the popup and falls through to the browser's default tab order.
+ */
+declare class BsComboboxDirective {
+    private dropdown;
+    /** Aliased to bsComboboxAutocomplete to avoid colliding with the host input's native HTML autocomplete attribute. */
+    readonly autocomplete: _angular_core.InputSignal<BsComboboxAutocomplete>;
+    /** Override the auto-derived activeDescendant. Defaults to dropdown.rovingFocus()'s id when present. */
+    readonly activeDescendant: _angular_core.InputSignal<string | null>;
+    readonly expanded: _angular_core.Signal<boolean>;
+    readonly controls: _angular_core.Signal<string | null>;
+    readonly resolvedActiveDescendant: _angular_core.Signal<string | null>;
+    /** Fires only when no BsRovingFocus is found inside the parent dropdown — otherwise arrow keys are forwarded automatically. */
+    readonly navigate: _angular_core.OutputEmitterRef<BsComboboxNavigateDirection>;
+    readonly activate: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly cancel: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsComboboxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsComboboxDirective, "input[bsCombobox]", ["bsCombobox"], { "autocomplete": { "alias": "bsComboboxAutocomplete"; "required": false; "isSignal": true; }; "activeDescendant": { "alias": "activeDescendant"; "required": false; "isSignal": true; }; }, { "navigate": "navigate"; "activate": "activate"; "cancel": "cancel"; }, never, never, true, never>;
 }
 
-export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective };
+export { BsComboboxDirective, BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective };
+export type { BsComboboxAutocomplete, BsComboboxNavigateDirection, BsDropdownPopupRole };

package/types/mintplayer-ng-bootstrap-file-upload.d.ts

@@ -9,9 +9,12 @@ interface FileUpload {
 }
 
 declare class BsFileUploadComponent {
+    private announcer;
     readonly dropFilesCaption: _angular_core.InputSignal<string>;
     readonly browseFilesCaption: _angular_core.InputSignal<string>;
     readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly inputAriaLabel: _angular_core.InputSignal<string>;
     readonly colors: typeof Color;
     isDraggingFile: _angular_core.WritableSignal<boolean>;
     readonly fileTemplate: _angular_core.WritableSignal<TemplateRef<FileUpload> | undefined>;
@@ -23,7 +26,7 @@ declare class BsFileUploadComponent {
     onDrop(event: DragEvent): void;
     private processDroppedFiles;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsFileUploadComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsFileUploadComponent, "bs-file-upload", never, { "dropFilesCaption": { "alias": "dropFilesCaption"; "required": false; "isSignal": true; }; "browseFilesCaption": { "alias": "browseFilesCaption"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "filesDropped": "filesDropped"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsFileUploadComponent, "bs-file-upload", never, { "dropFilesCaption": { "alias": "dropFilesCaption"; "required": false; "isSignal": true; }; "browseFilesCaption": { "alias": "browseFilesCaption"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "inputAriaLabel": { "alias": "inputAriaLabel"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "filesDropped": "filesDropped"; }, never, never, true, never>;
 }
 
 declare class BsFileUploadTemplateDirective {

package/types/mintplayer-ng-bootstrap-has-overlay.d.ts

@@ -1,5 +1,19 @@
 import * as i0 from '@angular/core';
 
+/**
+ * Marker component whose only job is to pull in @angular/cdk/overlay-prebuilt
+ * CSS via its SCSS (::ng-deep import). The template is intentionally empty;
+ * placing <bs-has-overlay></bs-has-overlay> inside any component that opens a
+ * CDK overlay (modal, offcanvas, popover, dropdown-based pickers, etc.)
+ * guarantees the overlay container's positioning styles ship with the component
+ * bundle, regardless of whether the host app pulled them in globally.
+ *
+ * The audit (docs/prd/aria-accessibility-audit.md §5.1) flagged this as
+ * "empty, purpose unclear" and suggested it should hide background content
+ * via aria-hidden/inert when an overlay is open. That responsibility lives in
+ * BsOverlayFocus + each per-component overlay logic (modal hides app-root,
+ * popover doesn't), not here. has-overlay is and remains a CSS-injection marker.
+ */
 declare class BsHasOverlayComponent {
     static ɵfac: i0.ɵɵFactoryDeclaration<BsHasOverlayComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsHasOverlayComponent, "bs-has-overlay", never, {}, {}, never, never, true, never>;

package/types/mintplayer-ng-bootstrap-marquee.d.ts

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
 
 declare class BsMarqueeComponent {
+    readonly ariaLabel: i0.InputSignal<string | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsMarqueeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsMarqueeComponent, "bs-marquee", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsMarqueeComponent, "bs-marquee", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 export { BsMarqueeComponent };

package/types/mintplayer-ng-bootstrap-modal.d.ts

@@ -1,10 +1,24 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
+import { TemplateRef, Injector, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
 import { OverlayRef } from '@angular/cdk/overlay';
 
+/**
+ * Component-scoped state shared between BsModalComponent (the dialog renderer)
+ * and the bsModalHeader / bsModalBody directives applied to the user's template.
+ * Provides the ids for aria-labelledby and aria-describedby.
+ */
+declare class BsModalContextService {
+    readonly headerId: i0.WritableSignal<string | null>;
+    readonly bodyId: i0.WritableSignal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsModalContextService>;
+}
+
 declare class BsModalComponent {
     template: TemplateRef<any>;
     isOpen: i0.WritableSignal<boolean>;
+    context: BsModalContextService;
+    injector: Injector;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsModalComponent, "bs-modal-content", never, {}, {}, never, never, true, never>;
 }
@@ -14,6 +28,8 @@ declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
     private parentInjector;
     private portalFactory;
     private componentFactoryResolver;
+    private overlayStack;
+    private stackToken;
     overlayRef: OverlayRef;
     componentInstance?: ComponentRef<BsModalComponent>;
     template: TemplateRef<any>;
@@ -34,11 +50,19 @@ declare class BsModalDirective {
 }
 
 declare class BsModalHeaderDirective {
+    private el;
+    private ids;
+    private context;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHeaderDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalHeaderDirective, "[bsModalHeader]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalBodyDirective {
+    private el;
+    private ids;
+    private context;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalBodyDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalBodyDirective, "[bsModalBody]", never, {}, {}, never, never, true, never>;
 }