@mintplayer/ng-bootstrap 21.29.0 → 21.31.0

package/types/mintplayer-ng-bootstrap-multi-range.d.ts

@@ -0,0 +1,170 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as lit from 'lit';
+import { LitElement, TemplateResult } from 'lit';
+import { ControlValueAccessor } from '@angular/forms';
+
+type MultiRangeOrientation = 'horizontal' | 'vertical';
+
+/**
+ * Bootstrap-flavoured multi-thumb range slider.
+ *
+ * Block-crossing: thumbs cannot pass their neighbours. Identity is by index —
+ * value[0] is always the lowest thumb. The value setter normalises input by
+ * sorting ascending and clamping each entry to [min, max]; minDistance is
+ * enforced only at user-interaction entry points (pointer + keyboard), not on
+ * programmatic writes — callers' arrays are preserved verbatim within bounds.
+ *
+ * Events:
+ *  - `value-input`  fires continuously during drag and on every keyboard step.
+ *  - `value-change` fires on commit (pointerup) and after every keyboard step.
+ *
+ * Both bubble and compose so the Angular wrapper's host listeners pick them up.
+ */
+declare class MintMultiRangeElement extends LitElement {
+    static styles: lit.CSSResult[];
+    static get observedAttributes(): string[];
+    static properties: {
+        value: {
+            attribute: boolean;
+        };
+        min: {
+            attribute: string;
+            type: NumberConstructor;
+            reflect: boolean;
+        };
+        max: {
+            attribute: string;
+            type: NumberConstructor;
+            reflect: boolean;
+        };
+        step: {
+            attribute: string;
+            type: NumberConstructor;
+            reflect: boolean;
+        };
+        minDistance: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        orientation: {
+            attribute: string;
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        disabled: {
+            attribute: string;
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        formatValue: {
+            attribute: boolean;
+        };
+    };
+    min: number;
+    max: number;
+    step: number;
+    minDistance: number;
+    orientation: MultiRangeOrientation;
+    disabled: boolean;
+    formatValue: ((value: number) => string) | null;
+    private _value;
+    private dragState;
+    private trackEl;
+    private rtlDuringGesture;
+    connectedCallback(): void;
+    protected firstUpdated(): void;
+    get value(): number[];
+    set value(next: number[] | null | undefined);
+    private arraysEqual;
+    private normalise;
+    private clampToBounds;
+    private snapToStep;
+    private percent;
+    private formatThumb;
+    private isVertical;
+    /**
+     * Returns whether the host renders in RTL. Uses the cached value if a gesture
+     * is active (set in startDrag / onTrackPointerDown), otherwise reads
+     * getComputedStyle fresh — direction can come from any ancestor's `dir`,
+     * so document.dir or our own attribute aren't sufficient.
+     */
+    private isRtl;
+    /**
+     * Apply the Block + minDistance constraint to a candidate value for thumb i.
+     * Returns the candidate clamped between its (already-respected) neighbours.
+     */
+    private constrainThumb;
+    /** Map a pointer coordinate inside the track rect to a value in [min, max]. */
+    private valueFromPointer;
+    /** Update one thumb in-place; emit `value-input`. Returns true if value changed. */
+    private moveThumb;
+    private dispatchValueChange;
+    private startDrag;
+    private onThumbPointerDown;
+    private onTrackPointerDown;
+    /**
+     * Returns the index of the thumb closest to `target`. Ties (multiple thumbs
+     * stacked at the same value) are broken by direction: clicks to the right of
+     * the stack pick the highest-index thumb, clicks to the left pick the
+     * lowest. Without this, a stack would always select the lowest-index thumb,
+     * which is blocked by its higher-indexed neighbours and can't move toward
+     * the click — the user would see no response.
+     */
+    private nearestThumbIndex;
+    private onPointerMove;
+    private onPointerUp;
+    private onThumbKeyDown;
+    /** Return the target value for a key press, or null if the key isn't bound. */
+    private keyboardTarget;
+    protected render(): TemplateResult;
+    private renderFill;
+    private renderThumb;
+    /** Returns a copy of the current values. */
+    getValues(): number[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mp-multi-range': MintMultiRangeElement;
+    }
+}
+
+declare class BsMultiRangeValueAccessor implements ControlValueAccessor {
+    private host;
+    private onValueChange?;
+    private onTouched?;
+    protected onInputEvent(ev: Event): void;
+    protected onTouchEvent(): void;
+    registerOnChange(fn: (value: number[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value: number[] | null | undefined): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsMultiRangeValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsMultiRangeValueAccessor, "bs-multi-range", never, {}, {}, never, never, true, never>;
+}
+
+declare class BsMultiRangeComponent {
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly minDistance: _angular_core.InputSignal<number>;
+    readonly orientation: _angular_core.InputSignal<MultiRangeOrientation>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly formatValue: _angular_core.InputSignal<((value: number) => string) | null>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly value: _angular_core.ModelSignal<number[] | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<number[]>;
+    readonly valueInput: _angular_core.OutputEmitterRef<number[]>;
+    readonly elementRef: _angular_core.Signal<ElementRef<MintMultiRangeElement>>;
+    protected readonly disabledAttr: _angular_core.Signal<"" | null>;
+    constructor();
+    protected onValueInput(event: Event): void;
+    protected onValueChange(event: Event): void;
+    /** Imperatively read the currently-rendered values from the WC. */
+    getValues(): number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsMultiRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsMultiRangeComponent, "bs-multi-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minDistance": { "alias": "minDistance"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "formatValue": { "alias": "formatValue"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "valueInput": "valueInput"; }, never, never, true, [{ directive: typeof BsMultiRangeValueAccessor; inputs: {}; outputs: {}; }]>;
+}
+
+export { BsMultiRangeComponent, BsMultiRangeValueAccessor, MintMultiRangeElement };
+export type { MultiRangeOrientation };

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

@@ -10,13 +10,14 @@ declare class BsMultiselectComponent<T> {
     readonly colors: typeof Color;
     readonly items: _angular_core.ModelSignal<T[]>;
     readonly selectedItems: _angular_core.ModelSignal<T[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     readonly defaultButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
     readonly defaultItemTemplate: _angular_core.Signal<TemplateRef<any>>;
     readonly resolvedButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
     readonly resolvedItemTemplate: _angular_core.Signal<TemplateRef<any>>;
     itemChange(item: T, value: boolean | null): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsMultiselectComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsMultiselectComponent<any>, "bs-multiselect", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "selectedItems": "selectedItemsChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsMultiselectComponent<any>, "bs-multiselect", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "selectedItems": "selectedItemsChange"; }, never, never, true, never>;
 }
 
 declare class BsHeaderTemplateDirective<T> {

package/types/mintplayer-ng-bootstrap-navbar-toggler.d.ts

@@ -3,9 +3,11 @@ import * as _angular_core from '@angular/core';
 declare class BsNavbarTogglerComponent {
     state: _angular_core.ModelSignal<boolean>;
     toggleOnClick: _angular_core.InputSignal<boolean>;
-    toggleState(ev: MouseEvent): void;
+    ariaLabel: _angular_core.InputSignal<string>;
+    controls: _angular_core.InputSignal<string | null>;
+    toggleState(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarTogglerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarTogglerComponent, "bs-navbar-toggler", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarTogglerComponent, "bs-navbar-toggler", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
 }
 
 export { BsNavbarTogglerComponent };

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

@@ -4,10 +4,21 @@ import { Color, Breakpoint } from '@mintplayer/ng-bootstrap';
 
 declare class BsNavbarComponent {
     private resizeTimeout;
+    private ids;
+    private platformId;
+    /** True only during SSR — drives the noscript-friendly checkbox+label
+     *  toggler in the template. In the browser, even during hydration, this is
+     *  false so the original <button> renders.
+     */
+    readonly isServerSide: boolean;
     constructor();
     onWindowResize(): void;
     readonly nav: _angular_core.Signal<ElementRef<any>>;
     autoclose: _angular_core.InputSignal<boolean>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    collapseId: _angular_core.InputSignal<string>;
+    /** Stable id for the noscript-friendly toggler-checkbox (label[for] target). */
+    readonly togglerCheckboxId: string;
     expandButtonTemplate: _angular_core.WritableSignal<TemplateRef<any> | null>;
     isExpanded: _angular_core.WritableSignal<boolean>;
     windowWidth: _angular_core.WritableSignal<number | null>;
@@ -23,7 +34,7 @@ declare class BsNavbarComponent {
     navClassList: _angular_core.Signal<string[]>;
     toggleExpanded(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["bs-navbar-brand", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "collapseId": { "alias": "collapseId"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["bs-navbar-brand", "*"], true, never>;
 }
 
 declare class BsNavbarBrandComponent implements AfterContentChecked {
@@ -65,6 +76,19 @@ declare class BsNavbarDropdownComponent implements OnDestroy {
     isBrowser: boolean;
     isVisible: _angular_core.WritableSignal<boolean>;
     topPos: _angular_core.WritableSignal<number | null>;
+    /**
+     * Top-level dropdowns render in-place; only nested submenus go through the
+     * CDK overlay. The visible-flash bug only affects the overlay path.
+     */
+    private readonly isOverlayMounted;
+    /**
+     * `.show` is gated on this for overlay-mounted submenus so the user never
+     * sees the menu at its stale top-left position. False until updatePosition
+     * has run at least once for the current open cycle; reset on close.
+     */
+    private readonly isPositioned;
+    /** What `[class.show]` actually binds to. */
+    readonly showClass: _angular_core.Signal<boolean>;
     maxHeight: _angular_core.Signal<string | null>;
     maxHeightOrNull: _angular_core.Signal<string | null>;
     constructor();

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

@@ -1,11 +1,25 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
+import { TemplateRef, Injector, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
 import { Position } from '@mintplayer/ng-bootstrap';
 import { OverlayRef } from '@angular/cdk/overlay';
 
+/**
+ * Component-scoped state shared between BsOffcanvasComponent (the dialog renderer)
+ * and the bs-offcanvas-header / bs-offcanvas-body components inside the user's
+ * template. Provides the ids for aria-labelledby and aria-describedby.
+ */
+declare class BsOffcanvasContextService {
+    readonly headerId: _angular_core.WritableSignal<string | null>;
+    readonly bodyId: _angular_core.WritableSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BsOffcanvasContextService>;
+}
+
 declare class BsOffcanvasComponent {
     contentTemplate: TemplateRef<any>;
     private platformId;
+    context: BsOffcanvasContextService;
+    injector: Injector;
     constructor();
     position: _angular_core.WritableSignal<Position>;
     size: _angular_core.WritableSignal<number | null>;
@@ -27,12 +41,20 @@ declare class BsOffcanvasComponent {
 }
 
 declare class OffcanvasHeaderComponent {
+    private el;
+    private ids;
+    private context;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasHeaderComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasHeaderComponent, "bs-offcanvas-header", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class OffcanvasBodyComponent {
+    private el;
+    private ids;
+    private context;
     readonly noPadding: _angular_core.InputSignal<boolean>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasBodyComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasBodyComponent, "bs-offcanvas-body", never, { "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -19,6 +19,8 @@ declare class BsPaginationComponent {
     showArrows: _angular_core.InputSignal<boolean>;
     /** Page number size. */
     size: _angular_core.InputSignal<Size>;
+    /** Accessible name on the surrounding `<nav>` landmark. */
+    ariaLabel: _angular_core.InputSignal<string>;
     /** The number of boxes (excluding arrows) that's being shown on the pagination component. */
     visibleNumberOfNumberBoxes: _angular_core.Signal<number>;
     /** Page numbers to be displayed to the user, with ellipsis entries where pages are omitted. */
@@ -31,7 +33,7 @@ declare class BsPaginationComponent {
     onPrevious(): boolean;
     onNext(): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPaginationComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPaginationComponent, "bs-pagination", never, { "pageNumbers": { "alias": "pageNumbers"; "required": false; "isSignal": true; }; "selectedPageNumber": { "alias": "selectedPageNumber"; "required": false; "isSignal": true; }; "numberOfBoxes": { "alias": "numberOfBoxes"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "selectedPageNumber": "selectedPageNumberChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPaginationComponent, "bs-pagination", never, { "pageNumbers": { "alias": "pageNumbers"; "required": false; "isSignal": true; }; "selectedPageNumber": { "alias": "selectedPageNumber"; "required": false; "isSignal": true; }; "numberOfBoxes": { "alias": "numberOfBoxes"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "selectedPageNumber": "selectedPageNumberChange"; }, never, never, true, never>;
 }
 
 export { BsPaginationComponent };

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

@@ -1,9 +1,13 @@
 import * as i0 from '@angular/core';
 
 declare class BsPlaceholderComponent {
+    private announcer;
     isLoading: i0.ModelSignal<boolean>;
+    loadingCompleteText: i0.InputSignal<string>;
+    private wasLoading;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaceholderComponent, "bs-placeholder", never, { "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "isLoading": "isLoadingChange"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaceholderComponent, "bs-placeholder", never, { "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "loadingCompleteText": { "alias": "loadingCompleteText"; "required": false; "isSignal": true; }; }, { "isLoading": "isLoadingChange"; }, never, ["*"], true, never>;
 }
 
 declare class BsPlaceholderFieldDirective {

package/types/mintplayer-ng-bootstrap-playlist-toggler.d.ts

@@ -3,9 +3,11 @@ import * as _angular_core from '@angular/core';
 declare class BsPlaylistTogglerComponent {
     state: _angular_core.ModelSignal<boolean>;
     toggleOnClick: _angular_core.InputSignal<boolean>;
-    toggleState(ev: MouseEvent): void;
+    ariaLabel: _angular_core.InputSignal<string>;
+    controls: _angular_core.InputSignal<string | null>;
+    toggleState(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPlaylistTogglerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPlaylistTogglerComponent, "bs-playlist-toggler", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPlaylistTogglerComponent, "bs-playlist-toggler", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
 }
 
 export { BsPlaylistTogglerComponent };

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

@@ -1,10 +1,25 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, AfterViewInit, OnDestroy } from '@angular/core';
+import { TemplateRef, Injector, AfterViewInit, OnDestroy } from '@angular/core';
 import { Position } from '@mintplayer/ng-bootstrap';
 import { ConnectedPosition } from '@angular/cdk/overlay';
 
+/**
+ * Component-scoped state shared between BsPopoverComponent (the dialog renderer)
+ * and the bsPopoverHeader / bsPopoverBody directives applied to the user's
+ * template. Provides the ids for aria-labelledby and aria-describedby.
+ */
+declare class BsPopoverContextService {
+    readonly headerId: _angular_core.WritableSignal<string | null>;
+    readonly bodyId: _angular_core.WritableSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BsPopoverContextService>;
+}
+
 declare class BsPopoverComponent {
     template: TemplateRef<any>;
+    popoverId: string;
+    context: BsPopoverContextService;
+    injector: Injector;
     position: _angular_core.InputSignal<Position>;
     isVisible: _angular_core.InputSignal<boolean>;
     marginClass: _angular_core.Signal<"mb-2" | "me-2" | "ms-2" | "mt-2">;
@@ -19,6 +34,10 @@ declare class BsPopoverDirective implements AfterViewInit, OnDestroy {
     private parentInjector;
     private portalFactory;
     private parent;
+    private ids;
+    private overlayStack;
+    private readonly popoverId;
+    private stackToken;
     bsPopover: _angular_core.InputSignal<Position>;
     updatePosition: _angular_core.InputSignal<boolean>;
     private localInjector;
@@ -29,6 +48,7 @@ declare class BsPopoverDirective implements AfterViewInit, OnDestroy {
     connectedPosition: _angular_core.Signal<ConnectedPosition>;
     constructor();
     ngAfterViewInit(): void;
+    onEscape(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsPopoverDirective, "*[bsPopover]", never, { "bsPopover": { "alias": "bsPopover"; "required": false; "isSignal": true; }; "updatePosition": { "alias": "updatePosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;

package/types/mintplayer-ng-bootstrap-priority-nav.d.ts

@@ -16,6 +16,8 @@ declare class BsPriorityNavItemDirective {
 declare class BsPriorityNavComponent {
     private platformId;
     private element;
+    private overlayStack;
+    private stackToken;
     isServerSide: boolean;
     private static counter;
     uid: string;
@@ -26,6 +28,7 @@ declare class BsPriorityNavComponent {
     collapseAt: _angular_core.InputSignal<Breakpoint | null>;
     overflowFrom: _angular_core.InputSignal<"start" | "end">;
     hideEmptyMore: _angular_core.InputSignal<boolean>;
+    ariaLabel: _angular_core.InputSignal<string>;
     overflowChange: _angular_core.OutputEmitterRef<BsPriorityNavItemDirective[]>;
     readonly items: _angular_core.Signal<readonly BsPriorityNavItemDirective[]>;
     private measureSizers;
@@ -55,7 +58,7 @@ declare class BsPriorityNavComponent {
     onEscape(): void;
     onDocumentClick(event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPriorityNavComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPriorityNavComponent, "bs-priority-nav", never, { "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "moreLabelTemplate": { "alias": "moreLabelTemplate"; "required": false; "isSignal": true; }; "collapseAt": { "alias": "collapseAt"; "required": false; "isSignal": true; }; "overflowFrom": { "alias": "overflowFrom"; "required": false; "isSignal": true; }; "hideEmptyMore": { "alias": "hideEmptyMore"; "required": false; "isSignal": true; }; }, { "overflowChange": "overflowChange"; }, ["items"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPriorityNavComponent, "bs-priority-nav", never, { "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "moreLabelTemplate": { "alias": "moreLabelTemplate"; "required": false; "isSignal": true; }; "collapseAt": { "alias": "collapseAt"; "required": false; "isSignal": true; }; "overflowFrom": { "alias": "overflowFrom"; "required": false; "isSignal": true; }; "hideEmptyMore": { "alias": "hideEmptyMore"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "overflowChange": "overflowChange"; }, ["items"], never, true, never>;
 }
 
 export { BsPriorityNavComponent, BsPriorityNavItemDirective };

package/types/mintplayer-ng-bootstrap-progress-bar.d.ts

@@ -4,8 +4,9 @@ import { Color } from '@mintplayer/ng-bootstrap';
 declare class BsProgressComponent {
     readonly height: _angular_core.InputSignal<number | null>;
     readonly isIndeterminate: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsProgressComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsProgressComponent, "bs-progress", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "isIndeterminate": { "alias": "isIndeterminate"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsProgressComponent, "bs-progress", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "isIndeterminate": { "alias": "isIndeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsProgressBarComponent {
@@ -15,11 +16,12 @@ declare class BsProgressBarComponent {
     color: _angular_core.InputSignal<Color>;
     striped: _angular_core.InputSignal<boolean>;
     animated: _angular_core.InputSignal<boolean>;
+    ariaLabel: _angular_core.InputSignal<string | null>;
     percentage: _angular_core.Signal<number>;
     width: _angular_core.Signal<string>;
     colorClassComputed: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsProgressBarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsProgressBarComponent, "bs-progress-bar", never, { "minimum": { "alias": "minimum"; "required": false; "isSignal": true; }; "maximum": { "alias": "maximum"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsProgressBarComponent, "bs-progress-bar", never, { "minimum": { "alias": "minimum"; "required": false; "isSignal": true; }; "maximum": { "alias": "maximum"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { BsProgressBarComponent, BsProgressComponent };

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

@@ -20,8 +20,9 @@ declare class BsRangeComponent {
     readonly min: _angular_core.InputSignal<number>;
     readonly max: _angular_core.InputSignal<number>;
     readonly step: _angular_core.InputSignal<number>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsRangeComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsRangeComponent, "bs-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof BsRangeValueAccessor; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsRangeComponent, "bs-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof BsRangeValueAccessor; inputs: {}; outputs: {}; }]>;
 }
 
 export { BsRangeComponent, BsRangeValueAccessor };

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

@@ -1,4 +1,5 @@
 import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
 
 declare class BsRatingComponent {
     constructor();
@@ -6,10 +7,12 @@ declare class BsRatingComponent {
     value: _angular_core.ModelSignal<number>;
     previewValue: _angular_core.WritableSignal<number | null>;
     starsChange: _angular_core.OutputEmitterRef<number>;
+    readonly starButtons: _angular_core.Signal<readonly ElementRef<HTMLButtonElement>[]>;
     stars: _angular_core.Signal<boolean[]>;
     hoverValue(index: number): void;
     selectValue(index: number): void;
     onMouseLeave(): void;
+    onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsRatingComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsRatingComponent, "bs-rating", never, { "maximum": { "alias": "maximum"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "starsChange": "starsChange"; }, never, never, true, never>;
 }

package/types/mintplayer-ng-bootstrap-reduced-motion.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+/**
+ * Tracks `(prefers-reduced-motion: reduce)` live and exposes the result as a
+ * signal. Designed to be composed onto a host component via `hostDirectives`
+ * so the host can `inject(BsReducedMotionDirective)` and read `matches()` to
+ * gate animations / auto-advance / non-essential motion. SSR-safe — on the
+ * server (or in environments without `matchMedia`) the signal stays `false`.
+ *
+ * Usage:
+ *   @Component({
+ *     // ...
+ *     hostDirectives: [BsReducedMotionDirective],
+ *   })
+ *   export class MyComponent {
+ *     private readonly reducedMotion = inject(BsReducedMotionDirective);
+ *     readonly animationsDisabled = computed(() => this.reducedMotion.matches());
+ *   }
+ *
+ * Or attach as a template attribute and read via a template reference:
+ *   <div bsReducedMotion #rm="bsReducedMotion">
+ *     <span *ngIf="!rm.matches()">animated content</span>
+ *   </div>
+ */
+declare class BsReducedMotionDirective {
+    private readonly platformId;
+    private readonly destroyRef;
+    private readonly _matches;
+    readonly matches: Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsReducedMotionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsReducedMotionDirective, "[bsReducedMotion]", ["bsReducedMotion"], {}, {}, never, never, true, never>;
+}
+
+export { BsReducedMotionDirective };

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

@@ -65,6 +65,8 @@ declare class BsResizeGlyphDirective {
     positions: _angular_core.WritableSignal<string>;
     activeClass: _angular_core.WritableSignal<boolean>;
     readonly bsResizeGlyph: _angular_core.InputSignal<Position[]>;
+    readonly ariaOrientation: _angular_core.Signal<"horizontal" | "vertical" | null>;
+    readonly ariaLabel: _angular_core.Signal<"Resize from top edge" | "Resize from bottom edge" | "Resize from left edge" | "Resize from right edge" | "Resize from top-left corner" | "Resize from top-right corner" | "Resize from bottom-left corner" | "Resize from bottom-right corner" | "Resize">;
     onMouseDown(ev: MouseEvent): void;
     onTouchStart(ev: TouchEvent): void;
     onMouseMove(ev: MouseEvent): void;
@@ -75,6 +77,8 @@ declare class BsResizeGlyphDirective {
     private isBusy;
     onPointerMove(ev: PointerData): void;
     onPointerUp(): void;
+    /** Keyboard alternative to drag. Arrow keys resize by 10px from the corresponding edge. */
+    onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsResizeGlyphDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsResizeGlyphDirective, "[bsResizeGlyph]", never, { "bsResizeGlyph": { "alias": "bsResizeGlyph"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }