@mintplayer/ng-bootstrap 20.6.3 → 21.1.0

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

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, QueryList, ElementRef } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { BsSwipeContainerDirective } from '@mintplayer/ng-swiper/swiper';
+
+declare class BsCarouselImageDirective {
+    private templateRef;
+    private carousel;
+    private element;
+    itemTemplate: TemplateRef<any>;
+    id: number;
+    isFirst: boolean;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsCarouselImageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsCarouselImageDirective, "*[bsCarouselImage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BsCarouselComponent implements AfterViewInit, OnDestroy {
+    private platformId;
+    private destroyRef;
+    colors: typeof Color;
+    isServerSide: boolean;
+    currentImageIndex: _angular_core.WritableSignal<number>;
+    images: _angular_core.WritableSignal<QueryList<BsCarouselImageDirective> | null>;
+    resizeObserver?: ResizeObserver;
+    private intervalId?;
+    indicators: _angular_core.InputSignal<boolean>;
+    keyboardEvents: _angular_core.InputSignal<boolean>;
+    orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    animation: _angular_core.InputSignal<"fade" | "slide" | "none">;
+    interval: _angular_core.InputSignal<number | null>;
+    wrap: _angular_core.InputSignal<boolean>;
+    slideChange: _angular_core.OutputEmitterRef<number>;
+    animationStart: _angular_core.OutputEmitterRef<void>;
+    animationEnd: _angular_core.OutputEmitterRef<void>;
+    imageCount: _angular_core.Signal<number>;
+    firstImageTemplate: _angular_core.Signal<TemplateRef<any> | null>;
+    lastImageTemplate: _angular_core.Signal<TemplateRef<any> | null>;
+    innerElement: ElementRef<HTMLDivElement>;
+    swipeContainer: BsSwipeContainerDirective;
+    set imagesQuery(value: QueryList<BsCarouselImageDirective>);
+    animationsDisabled: boolean;
+    onKeyPress(event: Event): void;
+    constructor();
+    private clearAutoAdvance;
+    previous(): void;
+    next(): void;
+    goto(index: number): void;
+    imageCounter: number;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onContainerAnimationStart(): void;
+    onContainerAnimationEnd(): void;
+    onImageIndexChange(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsCarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsCarouselComponent, "bs-carousel", never, { "indicators": { "alias": "indicators"; "required": false; "isSignal": true; }; "keyboardEvents": { "alias": "keyboardEvents"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, { "slideChange": "slideChange"; "animationStart": "animationStart"; "animationEnd": "animationEnd"; }, ["imagesQuery"], never, true, never>;
+}
+
+declare class BsCarouselImgDirective {
+    private image;
+    fetchPriority: 'high' | 'low' | 'auto';
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsCarouselImgDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsCarouselImgDirective, "img", never, {}, {}, never, never, true, never>;
+}
+
+declare class BsCarouselModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsCarouselModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsCarouselModule, never, [typeof BsCarouselComponent, typeof BsCarouselImageDirective, typeof BsCarouselImgDirective], [typeof BsCarouselComponent, typeof BsCarouselImageDirective, typeof BsCarouselImgDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsCarouselModule>;
+}
+
+export { BsCarouselComponent, BsCarouselImageDirective, BsCarouselImgDirective, BsCarouselModule };

package/{close/index.d.ts → types/mintplayer-ng-bootstrap-close.d.ts}

@@ -1,8 +1,7 @@
 import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
 
 declare class BsCloseComponent {
-    click: EventEmitter<any>;
+    click: i0.OutputEmitterRef<void>;
     onClose(ev: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsCloseComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsCloseComponent, "bs-close", never, {}, { "click": "click"; }, never, never, true, never>;

package/{code-snippet/index.d.ts → types/mintplayer-ng-bootstrap-code-snippet.d.ts}

@@ -1,16 +1,15 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, EventEmitter } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { HighlightResult } from 'highlight.js';
-import { BehaviorSubject } from 'rxjs';
 
 declare class BsCodeSnippetComponent {
     constructor();
-    offcanvasVisible: boolean;
+    offcanvasVisible: _angular_core.WritableSignal<boolean>;
     codeToCopy: _angular_core.InputSignal<string>;
     language: _angular_core.InputSignal<string>;
     copiedTemplate: TemplateRef<any>;
-    detectedLanguage: EventEmitter<string>;
-    language$: BehaviorSubject<string>;
+    detectedLanguage: _angular_core.OutputEmitterRef<string>;
+    detectedLanguageValue: _angular_core.WritableSignal<string>;
     copiedHtml(): void;
     onHighlighted(result: HighlightResult | null): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsCodeSnippetComponent, never>;

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

@@ -0,0 +1,170 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i8 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i7 from '@angular/common';
+
+interface HS {
+    hue: number;
+    saturation: number;
+}
+
+declare class BsColorWheelComponent {
+    private element;
+    positionRelative: boolean;
+    canvas: ElementRef<HTMLCanvasElement>;
+    width: _angular_core.ModelSignal<number>;
+    height: _angular_core.ModelSignal<number>;
+    diameterRatio: _angular_core.ModelSignal<number>;
+    luminosity: _angular_core.ModelSignal<number>;
+    hs: _angular_core.ModelSignal<HS>;
+    hsChange: _angular_core.OutputEmitterRef<HS>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    viewInited: _angular_core.WritableSignal<boolean>;
+    private isPointerDown;
+    private canvasContext;
+    squareSize: _angular_core.Signal<number | null>;
+    shiftX: _angular_core.Signal<number | null>;
+    shiftY: _angular_core.Signal<number | null>;
+    innerRadius: _angular_core.Signal<number>;
+    outerRadius: _angular_core.Signal<number>;
+    markerPosition: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    constructor();
+    ngAfterViewInit(): void;
+    onPointerDown(ev: MouseEvent | TouchEvent): void;
+    onPointerMove(ev: MouseEvent | TouchEvent): void;
+    onMouseMove(ev: MouseEvent): void;
+    onPointerUp(ev: MouseEvent | TouchEvent): void;
+    private updateColor;
+    private isInsideCircle;
+    private position2color;
+    private color2position;
+    private rgb2Hsl;
+    /**
+     * Divide 1 to n, handling floating point errors.
+     * Ensures that the value is in between 0 and 1.
+     **/
+    private bound01;
+    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; }; "diameterRatio": { "alias": "diameterRatio"; "required": false; "isSignal": true; }; "luminosity": { "alias": "luminosity"; "required": false; "isSignal": true; }; "hs": { "alias": "hs"; "required": false; "isSignal": true; }; }, { "width": "widthChange"; "height": "heightChange"; "diameterRatio": "diameterRatioChange"; "luminosity": "luminosityChange"; "hs": "hsChange"; "hsChange": "hsChange"; }, never, never, false, never>;
+}
+
+declare class BsColorPickerComponent {
+    colorWheel: BsColorWheelComponent;
+    size: _angular_core.InputSignal<number>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    allowAlpha: _angular_core.InputSignal<boolean>;
+    hs: _angular_core.WritableSignal<HS>;
+    luminosity: _angular_core.WritableSignal<number>;
+    alpha: _angular_core.ModelSignal<number>;
+    alphaChange: _angular_core.OutputEmitterRef<number>;
+    constructor();
+    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"; "alphaChange": "alphaChange"; }, never, never, false, never>;
+}
+
+interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+
+declare class BsColorPickerValueAccessor implements ControlValueAccessor {
+    private host;
+    onValueChange?: (value: string) => void;
+    onTouched?: () => void;
+    constructor();
+    hsl2rgb(h: number, s: number, l: number): RgbColor;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value: string | null): void;
+    setDisabledState(isDisabled: boolean): void;
+    private rgb2hex;
+    private hex2rgb;
+    /**
+     * Divide 1 to n, handling floating point errors.
+     * Ensures that the value is in between 0 and 1.
+     **/
+    private bound01;
+    private rgb2Hsl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsColorPickerValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsColorPickerValueAccessor, "bs-color-picker", ["bsColorPicker"], {}, {}, never, never, false, never>;
+}
+
+declare class BsLuminosityStripComponent {
+    canvas: ElementRef<HTMLCanvasElement>;
+    hs: _angular_core.ModelSignal<HS>;
+    luminosity: _angular_core.ModelSignal<number>;
+    luminosityChange: _angular_core.OutputEmitterRef<number>;
+    private canvasContext;
+    resultBackground: _angular_core.Signal<string>;
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsLuminosityStripComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsLuminosityStripComponent, "bs-luminosity-strip", never, { "hs": { "alias": "hs"; "required": false; "isSignal": true; }; "luminosity": { "alias": "luminosity"; "required": false; "isSignal": true; }; }, { "hs": "hsChange"; "luminosity": "luminosityChange"; "luminosityChange": "luminosityChange"; }, never, never, false, never>;
+}
+
+declare class BsSliderComponent {
+    private element;
+    private zone;
+    dBlock: boolean;
+    positionRelative: boolean;
+    track: ElementRef<HTMLDivElement>;
+    thumb: ElementRef<HTMLDivElement>;
+    value: _angular_core.ModelSignal<number>;
+    valueChange: _angular_core.OutputEmitterRef<number>;
+    private isPointerDown;
+    thumbMarginLeft: _angular_core.Signal<number>;
+    cursorClass: _angular_core.Signal<"cursor-grabbing" | "cursor-grab">;
+    constructor();
+    onPointerDown(ev: MouseEvent | TouchEvent): void;
+    onPointerMove(ev: MouseEvent | TouchEvent): void;
+    onPointerUp(ev: MouseEvent | TouchEvent): void;
+    private updateColor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSliderComponent, "bs-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, ["[bsTrack]", "[bsThumb]"], false, never>;
+}
+declare class BsThumbDirective {
+    thumbClass: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsThumbDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsThumbDirective, "[bsThumb]", never, {}, {}, never, never, false, never>;
+}
+declare class BsTrackDirective {
+    trackClass: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTrackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsTrackDirective, "[bsTrack]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsAlphaStripComponent {
+    canvas: ElementRef<HTMLCanvasElement>;
+    hs: _angular_core.ModelSignal<HS>;
+    luminosity: _angular_core.ModelSignal<number>;
+    alpha: _angular_core.ModelSignal<number>;
+    alphaChange: _angular_core.OutputEmitterRef<number>;
+    private canvasContext;
+    resultBackground: _angular_core.Signal<string>;
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsAlphaStripComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsAlphaStripComponent, "bs-alpha-strip", never, { "hs": { "alias": "hs"; "required": false; "isSignal": true; }; "luminosity": { "alias": "luminosity"; "required": false; "isSignal": true; }; "alpha": { "alias": "alpha"; "required": false; "isSignal": true; }; }, { "hs": "hsChange"; "luminosity": "luminosityChange"; "alpha": "alphaChange"; "alphaChange": "alphaChange"; }, never, never, false, never>;
+}
+
+declare class BsColorPickerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsColorPickerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsColorPickerModule, [typeof BsColorPickerComponent, typeof BsColorPickerValueAccessor, typeof BsColorWheelComponent, typeof BsLuminosityStripComponent, typeof BsSliderComponent, typeof BsThumbDirective, typeof BsTrackDirective, typeof BsAlphaStripComponent], [typeof i7.AsyncPipe, typeof i8.FormsModule], [typeof BsColorPickerComponent, typeof BsColorPickerValueAccessor, typeof BsColorWheelComponent, typeof BsLuminosityStripComponent, typeof BsSliderComponent, typeof BsThumbDirective, typeof BsTrackDirective, typeof BsAlphaStripComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsColorPickerModule>;
+}
+
+interface HslColor {
+    hue: number;
+    saturation: number;
+    luminosity: number;
+}
+
+type HtmlColor = `#${string}`;
+
+export { BsAlphaStripComponent, BsColorPickerComponent, BsColorPickerModule, BsColorPickerValueAccessor, BsColorWheelComponent, BsLuminosityStripComponent, BsSliderComponent, BsThumbDirective, BsTrackDirective };
+export type { HS, HslColor, HtmlColor, RgbColor };

package/{context-menu/index.d.ts → types/mintplayer-ng-bootstrap-context-menu.d.ts}

@@ -14,7 +14,7 @@ declare class BsContextMenuDirective {
     private overlayRef;
     private templatePortal;
     clickAnywhere(ev: MouseEvent): void;
-    private onBlur;
+    onBlur(): void;
     private close;
     private checkAndCloseExisting;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsContextMenuDirective, [null, null, null, { host: true; skipSelf: true; }]>;

package/{datatable/index.d.ts → types/mintplayer-ng-bootstrap-datatable.d.ts}

@@ -1,6 +1,5 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, EventEmitter } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { TemplateRef } from '@angular/core';
 import { PaginationRequest, PaginationResponse } from '@mintplayer/pagination';
 import * as i4 from '@angular/common';
 import * as i5 from '@mintplayer/ng-bootstrap/grid';
@@ -23,7 +22,6 @@ declare class DatatableSettings {
 }
 
 declare class BsDatatableColumnDirective {
-    constructor(templateRef: TemplateRef<any>);
     templateRef: TemplateRef<any>;
     name: string;
     sortable: boolean;
@@ -33,7 +31,8 @@ declare class BsDatatableColumnDirective {
 
 declare class BsRowTemplateDirective<TData> {
     private datatableComponent;
-    constructor(datatableComponent: BsDatatableComponent<TData>, templateRef: TemplateRef<BsRowTemplateContext<TData>>);
+    private templateRef;
+    constructor();
     set bsRowTemplateOf(value: PaginationResponse<TData> | undefined);
     static ngTemplateContextGuard<TData>(dir: BsRowTemplateDirective<TData>, ctx: any): ctx is BsRowTemplateContext<Exclude<TData, false | 0 | '' | null | undefined>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsRowTemplateDirective<any>, never>;
@@ -44,17 +43,18 @@ declare class BsRowTemplateContext<TData = unknown> {
 }
 
 declare class BsDatatableComponent<TData> {
-    constructor();
-    columns$: BehaviorSubject<BsDatatableColumnDirective[]>;
-    numberOfColumns$: Observable<number>;
+    private _columns;
+    numberOfColumns: i0.Signal<number>;
     set columns(value: BsDatatableColumnDirective[]);
-    settings: DatatableSettings;
-    data?: PaginationResponse<TData>;
+    get columnsArray(): BsDatatableColumnDirective[];
+    settings: i0.ModelSignal<DatatableSettings>;
+    data: i0.ModelSignal<PaginationResponse<TData> | undefined>;
     rowTemplate?: TemplateRef<BsRowTemplateContext<TData>>;
-    settingsChange: EventEmitter<DatatableSettings>;
     columnHeaderClicked(column: BsDatatableColumnDirective): void;
+    onPerPageChange(perPage: number): void;
+    onPageChange(page: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsDatatableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsDatatableComponent<any>, "bs-datatable", never, { "settings": { "alias": "settings"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "settingsChange": "settingsChange"; }, ["columns"], never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsDatatableComponent<any>, "bs-datatable", never, { "settings": { "alias": "settings"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "settings": "settingsChange"; "data": "dataChange"; }, ["columns"], never, false, never>;
 }
 
 declare class BsDatatableModule {

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

@@ -0,0 +1,13 @@
+import * as _angular_core from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class BsDatepickerComponent {
+    colors: typeof Color;
+    selectedDate: _angular_core.ModelSignal<Date>;
+    currentMonth: _angular_core.ModelSignal<Date>;
+    disableDateFn: _angular_core.InputSignal<((date: Date) => boolean) | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDatepickerComponent, "bs-datepicker", never, { "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "currentMonth": { "alias": "currentMonth"; "required": false; "isSignal": true; }; "disableDateFn": { "alias": "disableDateFn"; "required": false; "isSignal": true; }; }, { "selectedDate": "selectedDateChange"; "currentMonth": "currentMonthChange"; }, never, never, true, never>;
+}
+
+export { BsDatepickerComponent };

package/{dropdown/index.d.ts → types/mintplayer-ng-bootstrap-dropdown.d.ts}

@@ -1,11 +1,9 @@
 import * as i0 from '@angular/core';
-import { ViewContainerRef, TemplateRef, DestroyRef, ElementRef, NgZone, EventEmitter } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-import * as i5 from '@angular/cdk/overlay';
-import { Overlay } from '@angular/cdk/overlay';
+import { ElementRef } from '@angular/core';
 import * as i7 from '@mintplayer/ng-click-outside';
 import { ClickOutsideDirective } from '@mintplayer/ng-click-outside';
 import * as i4 from '@angular/common';
+import * as i5 from '@angular/cdk/overlay';
 import * as i6 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsDropdownMenuDirective extends ClickOutsideDirective {
@@ -14,16 +12,16 @@ declare class BsDropdownMenuDirective extends ClickOutsideDirective {
     private templateRef;
     private overlay;
     private destroy;
-    private bsDevelopment?;
-    constructor(dropdown: BsDropdownDirective, viewContainerRef: ViewContainerRef, templateRef: TemplateRef<any>, overlay: Overlay, destroy: DestroyRef, elementRef: ElementRef<any>, zone: NgZone, platformId: any, bsDevelopment?: boolean | undefined);
+    private bsDevelopment;
     private wait;
     private overlayRef;
     private templatePortal;
-    get show(): boolean;
-    clickedOutside(ev: MouseEvent): void;
-    onEscape(ev: KeyboardEvent): void;
+    constructor();
+    get show(): any;
+    clickedOutside(event: Event): void;
+    onEscape(event: Event): void;
     private doClose;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownMenuDirective, [null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownMenuDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownMenuDirective, "[bsDropdownMenu]", never, {}, {}, never, never, false, never>;
 }
 
@@ -37,22 +35,18 @@ declare class BsDropdownToggleDirective {
 }
 
 declare class BsDropdownDirective {
-    private bsDevelopment?;
-    constructor(elementRef: ElementRef<any>, bsDevelopment?: boolean | undefined);
-    isOpen$: BehaviorSubject<boolean>;
     elementRef: ElementRef<HTMLElement>;
+    private bsDevelopment;
     menu: BsDropdownMenuDirective;
     toggle: BsDropdownToggleDirective | null;
-    hasBackdrop: boolean;
-    sameWidth: boolean;
-    closeOnClickOutside: boolean;
-    sameDropdownWidth: boolean;
-    get isOpen(): boolean;
-    isOpenChange: EventEmitter<boolean>;
-    set isOpen(value: boolean);
-    private onBlur;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownDirective, [null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownDirective, "[bsDropdown]", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "sameWidth": { "alias": "sameWidth"; "required": false; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; }; "sameDropdownWidth": { "alias": "sameDropdownWidth"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, ["menu", "toggle"], never, false, never>;
+    hasBackdrop: i0.InputSignal<boolean>;
+    sameWidth: i0.InputSignal<boolean>;
+    closeOnClickOutside: i0.InputSignal<boolean>;
+    sameDropdownWidth: i0.InputSignal<boolean>;
+    isOpen: i0.ModelSignal<boolean>;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownDirective, never>;
+    static ɵdir: i0.ɵɵ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, false, never>;
 }
 
 declare class BsDropdownModule {

package/{enhanced-paste/index.d.ts → types/mintplayer-ng-bootstrap-enhanced-paste.d.ts}

@@ -1,6 +1,5 @@
 import * as i0 from '@angular/core';
-import { ElementRef, EventEmitter } from '@angular/core';
-import { NgModel } from '@angular/forms';
+import { EventEmitter } from '@angular/core';
 
 interface NumberOverflow {
     boundary: 'min' | 'max' | 'invalid';
@@ -11,7 +10,6 @@ interface NumberOverflow {
 declare class EnhancedPasteDirective {
     private element;
     private model;
-    constructor(element: ElementRef<HTMLInputElement>, model: NgModel);
     numberOverflow: EventEmitter<NumberOverflow>;
     onPaste(event: ClipboardEvent): void;
     filterInput(value: any, min: number, max: number): NumberOverflow | null;

package/{file-upload/index.d.ts → types/mintplayer-ng-bootstrap-file-upload.d.ts}

@@ -33,7 +33,7 @@ declare class BsFileUploadComponent {
 
 declare class BsFileUploadTemplateDirective {
     private fileUploadComponent;
-    constructor(fileUploadComponent: BsFileUploadComponent, templateRef: TemplateRef<any>);
+    constructor();
     set bsFileUploadTemplateOf(value: FileUpload[]);
     static ngTemplateContextGuard(dir: BsFileUploadTemplateDirective, ctx: any): ctx is BsFileUploadTemplateContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsFileUploadTemplateDirective, never>;

package/{grid/index.d.ts → types/mintplayer-ng-bootstrap-grid.d.ts}

@@ -1,18 +1,13 @@
-import { Breakpoint } from '@mintplayer/ng-bootstrap';
-import { BehaviorSubject, Observable } from 'rxjs';
 import * as i0 from '@angular/core';
-import { DestroyRef } from '@angular/core';
+import { Breakpoint } from '@mintplayer/ng-bootstrap';
 import * as i5 from '@angular/common';
 import * as i6 from '@mintplayer/ng-bootstrap/container';
 
 declare class BsGridComponent {
-    constructor();
-    stopFullWidthAt$: BehaviorSubject<Breakpoint | "never">;
-    get stopFullWidthAt(): Breakpoint | "never";
-    set stopFullWidthAt(value: Breakpoint | 'never');
-    containerClass$: Observable<string>;
+    stopFullWidthAt: i0.InputSignal<Breakpoint | "never">;
+    containerClass: i0.Signal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsGridComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsGridComponent, "bs-grid", never, { "stopFullWidthAt": { "alias": "stopFullWidthAt"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsGridComponent, "bs-grid", never, { "stopFullWidthAt": { "alias": "stopFullWidthAt"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }
 
 declare class BsGridRowDirective {
@@ -22,24 +17,17 @@ declare class BsGridRowDirective {
 }
 
 declare class BsGridColumnDirective {
-    constructor(destroy: DestroyRef);
-    classList: string | null;
-    xxs$: BehaviorSubject<number | undefined>;
-    xs$: BehaviorSubject<number | undefined>;
-    sm$: BehaviorSubject<number | undefined>;
-    md$: BehaviorSubject<number | undefined>;
-    lg$: BehaviorSubject<number | undefined>;
-    xl$: BehaviorSubject<number | undefined>;
-    xxl$: BehaviorSubject<number | undefined>;
-    set xxs(value: number | undefined);
-    set xs(value: number | undefined);
-    set sm(value: number | undefined);
-    set md(value: number | undefined);
-    set lg(value: number | undefined);
-    set xl(value: number | undefined);
-    set xxl(value: number | undefined);
+    xxs: i0.InputSignal<number | undefined>;
+    xs: i0.InputSignal<number | undefined>;
+    sm: i0.InputSignal<number | undefined>;
+    md: i0.InputSignal<number | undefined>;
+    lg: i0.InputSignal<number | undefined>;
+    xl: i0.InputSignal<number | undefined>;
+    xxl: i0.InputSignal<number | undefined>;
+    classList: i0.Signal<string>;
+    get classBinding(): string | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsGridColumnDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColumnDirective, "[xxs],[xs],[sm],[md],[lg],[xl],[xxl]", never, { "xxs": { "alias": "xxs"; "required": false; }; "xs": { "alias": "xs"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; "md": { "alias": "md"; "required": false; }; "lg": { "alias": "lg"; "required": false; }; "xl": { "alias": "xl"; "required": false; }; "xxl": { "alias": "xxl"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColumnDirective, "[xxs],[xs],[sm],[md],[lg],[xl],[xxl]", never, { "xxs": { "alias": "xxs"; "required": false; "isSignal": true; }; "xs": { "alias": "xs"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "md": { "alias": "md"; "required": false; "isSignal": true; }; "lg": { "alias": "lg"; "required": false; "isSignal": true; }; "xl": { "alias": "xl"; "required": false; "isSignal": true; }; "xxl": { "alias": "xxl"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
 }
 declare class BsGridColDirective {
     colClass: boolean;

package/{let/index.d.ts → types/mintplayer-ng-bootstrap-let.d.ts}

@@ -1,5 +1,4 @@
 import * as i0 from '@angular/core';
-import { ViewContainerRef, TemplateRef } from '@angular/core';
 
 interface BsLetContext<T> {
     /**
@@ -17,7 +16,6 @@ declare class BsLetDirective<T> {
     private templateRef;
     private context;
     private hasView;
-    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsLetContext<T>>);
     set bsLet(value: T);
     /** @internal */
     static bsLetUseIfTypeGuard: void;

package/{markdown/index.d.ts → types/mintplayer-ng-bootstrap-markdown.d.ts}

@@ -1,10 +1,9 @@
 import * as i0 from '@angular/core';
 import { PipeTransform } from '@angular/core';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { SafeHtml } from '@angular/platform-browser';
 
 declare class BsBoldPipe implements PipeTransform {
     private domSanitizer;
-    constructor(domSanitizer: DomSanitizer);
     transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsBoldPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<BsBoldPipe, "bsBold", true>;
@@ -12,7 +11,6 @@ declare class BsBoldPipe implements PipeTransform {
 
 declare class BsItalicPipe implements PipeTransform {
     private domSanitizer;
-    constructor(domSanitizer: DomSanitizer);
     transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsItalicPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<BsItalicPipe, "bsItalic", true>;
@@ -20,7 +18,6 @@ declare class BsItalicPipe implements PipeTransform {
 
 declare class BsStrikethroughPipe implements PipeTransform {
     private domSanitizer;
-    constructor(domSanitizer: DomSanitizer);
     transform(value: string | SafeHtml | null, numberOfTildes?: number, classList?: string[]): SafeHtml | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsStrikethroughPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<BsStrikethroughPipe, "bsStrikethrough", true>;
@@ -28,7 +25,6 @@ declare class BsStrikethroughPipe implements PipeTransform {
 
 declare class BsUnderlinePipe implements PipeTransform {
     private domSanitizer;
-    constructor(domSanitizer: DomSanitizer);
     transform(value: string | SafeHtml | null, classList?: string[]): SafeHtml | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsUnderlinePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<BsUnderlinePipe, "bsUnderline", true>;

package/{modal/index.d.ts → types/mintplayer-ng-bootstrap-modal.d.ts}

@@ -1,8 +1,7 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, AfterViewInit, OnDestroy, Injector, ComponentFactoryResolver, ComponentRef, EventEmitter } from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef, EventEmitter } from '@angular/core';
 import * as i9 from '@angular/cdk/overlay';
-import { Overlay, OverlayRef } from '@angular/cdk/overlay';
-import { ComponentPortal } from '@angular/cdk/portal';
+import { OverlayRef } from '@angular/cdk/overlay';
 import * as i8 from '@angular/common';
 import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
 
@@ -19,7 +18,6 @@ declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
     private parentInjector;
     private portalFactory;
     private componentFactoryResolver;
-    constructor(overlay: Overlay, parentInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<BsModalComponent>, componentFactoryResolver: ComponentFactoryResolver);
     overlayRef: OverlayRef;
     componentInstance?: ComponentRef<BsModalComponent>;
     template: TemplateRef<any>;
@@ -30,13 +28,13 @@ declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
     closeOnEscape: boolean;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    private onKeyDown;
+    onKeyDown(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHostComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsModalHostComponent, "bs-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, never, false, never>;
 }
 
 declare class BsModalDirective {
-    constructor(template: TemplateRef<any>, host: BsModalHostComponent);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalDirective, "[bsModal]", never, {}, {}, never, never, false, never>;
 }
@@ -61,7 +59,6 @@ declare class BsModalFooterDirective {
 
 declare class BsModalCloseDirective {
     private host;
-    constructor(host: BsModalHostComponent);
     onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalCloseDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalCloseDirective, "[bsModalClose]", never, {}, {}, never, never, false, never>;