@mintplayer/ng-bootstrap 21.0.0 → 21.1.0

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

@@ -1,39 +1,29 @@
 import * as i0 from '@angular/core';
-import { OnInit, Renderer2, ElementRef, OnDestroy } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { ElementRef, OnDestroy } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import * as i3 from '@angular/common';
 
 type BsSelectSize = 'sm' | 'md' | 'lg';
 
-declare class BsSelectComponent implements OnInit {
+declare class BsSelectComponent {
     private renderer;
-    constructor(renderer: Renderer2);
-    identifier: number;
+    constructor();
+    identifier: i0.InputSignal<number>;
     selectBox: ElementRef<HTMLSelectElement>;
-    ngOnInit(): void;
-    size$: BehaviorSubject<BsSelectSize>;
-    get size(): BsSelectSize;
-    set size(value: BsSelectSize);
-    multiple$: BehaviorSubject<boolean>;
-    get multiple(): boolean;
-    set multiple(value: boolean);
-    numberVisible$: BehaviorSubject<number | null>;
-    get numberVisible(): number | null;
-    set numberVisible(value: number | null);
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    sizeClass$: Observable<string | null>;
-    multipleValue$: Observable<boolean | null>;
+    size: i0.InputSignal<BsSelectSize>;
+    multiple: i0.InputSignal<boolean>;
+    numberVisible: i0.InputSignal<number | null>;
+    disabled: i0.InputSignal<boolean>;
+    sizeClass: i0.Signal<string | null>;
+    multipleValue: i0.Signal<true | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelectComponent, "bs-select", never, { "identifier": { "alias": "identifier"; "required": false; }; "size": { "alias": "size"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "numberVisible": { "alias": "numberVisible"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelectComponent, "bs-select", never, { "identifier": { "alias": "identifier"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "numberVisible": { "alias": "numberVisible"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }
 
 declare class BsSelectValueAccessor implements ControlValueAccessor {
     private _renderer;
     private _elementRef;
     private selectBox;
-    constructor(_renderer: Renderer2, _elementRef: ElementRef, selectBox: BsSelectComponent);
     onChange: (_: any) => void;
     onTouched: () => void;
     registerOnTouched(fn: () => void): void;
@@ -60,13 +50,13 @@ declare class BsSelectOption implements OnDestroy {
     private element;
     private renderer;
     private select;
-    constructor(element: ElementRef, renderer: Renderer2, select: BsSelectValueAccessor);
+    constructor();
     id: string;
     set ngValue(value: any);
     set value(value: any);
     setElementValue(value: string): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectOption, [null, null, { optional: true; host: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectOption, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
 }
 

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

@@ -1,7 +1,6 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, ElementRef, EventEmitter } from '@angular/core';
+import { TemplateRef, ElementRef, WritableSignal } from '@angular/core';
 import { HasId } from '@mintplayer/ng-bootstrap/has-id';
-import { BehaviorSubject } from 'rxjs';
 import * as i4 from '@angular/common';
 import * as i5 from '@angular/forms';
 import * as i6 from '@mintplayer/ng-bootstrap/dropdown';
@@ -10,34 +9,37 @@ import * as i8 from '@mintplayer/ng-bootstrap/has-overlay';
 import * as i9 from '@mintplayer/ng-bootstrap/in-list';
 
 declare class BsSelect2Component<T extends HasId<U>, U> {
-    isOpen: boolean;
-    suggestions$: BehaviorSubject<T[]>;
-    isLoading$: BehaviorSubject<boolean>;
+    isOpen: i0.WritableSignal<boolean>;
+    isLoading: i0.WritableSignal<boolean>;
+    suggestions: i0.ModelSignal<T[]>;
     defaultItemTemplate: TemplateRef<any>;
     searchBox: ElementRef<HTMLInputElement>;
     itemsBox: ElementRef<HTMLDivElement>;
-    searchterm: string;
-    suggestions: T[];
-    provideSuggestions: EventEmitter<string>;
-    selectedItems: T[];
+    searchterm: i0.ModelSignal<string>;
+    provideSuggestions: i0.OutputEmitterRef<string>;
     isFocused: boolean;
+    selectedItems: i0.ModelSignal<T[]>;
     private charWidth;
-    searchWidth: number;
+    searchWidth: i0.WritableSignal<number>;
     itemTemplate?: TemplateRef<T>;
     suggestionTemplate?: TemplateRef<T>;
+    constructor();
     onProvideSuggestions(value: string): void;
     onSuggestionClicked(suggestion: T): void;
     onRemoveItem(item: T, event: MouseEvent): void;
     focus(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Component<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelect2Component<any, any>, "bs-select2", never, { "searchterm": { "alias": "searchterm"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; }, { "provideSuggestions": "provideSuggestions"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelect2Component<any, any>, "bs-select2", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "searchterm": { "alias": "searchterm"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; }, { "suggestions": "suggestionsChange"; "searchterm": "searchtermChange"; "provideSuggestions": "provideSuggestions"; "selectedItems": "selectedItemsChange"; }, never, never, false, never>;
 }
 
 declare class BsItemTemplateDirective<T extends HasId<U>, U> {
     private select2component;
-    constructor(select2component: BsSelect2Component<T, U>, templateRef: TemplateRef<T>);
+    private templateRef;
+    private sourceSignal?;
+    private lastSourceValue?;
+    constructor();
     static ngTemplateContextGuard<T extends HasId<U>, U>(dir: BsItemTemplateDirective<T, U>, ctx: any): ctx is BsItemTemplateContext<Exclude<T, false | 0 | '' | null | undefined>, U>;
-    set bsItemTemplateOf(value: T[]);
+    set bsItemTemplateOf(value: T[] | WritableSignal<T[]>);
     static ɵfac: i0.ɵɵFactoryDeclaration<BsItemTemplateDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsItemTemplateDirective<any, any>, "[bsItemTemplate]", never, { "bsItemTemplateOf": { "alias": "bsItemTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
 }
@@ -48,7 +50,7 @@ declare class BsItemTemplateContext<T extends HasId<U>, U> {
 
 declare class BsSuggestionTemplateDirective<T extends HasId<U>, U> {
     private select2component;
-    constructor(select2component: BsSelect2Component<T, U>, templateRef: TemplateRef<T>);
+    constructor();
     static ngTemplateContextGuard<T extends HasId<U>, U>(dir: BsSuggestionTemplateDirective<T, U>, ctx: any): ctx is BsSuggestionTemplateContext<Exclude<T, false | 0 | '' | null | undefined>, U>;
     set bsSuggestionTemplateOf(value: T[]);
     static ɵfac: i0.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;

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

@@ -1,30 +1,24 @@
 import * as i0 from '@angular/core';
 import { TemplateRef, ElementRef } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
 import { Breakpoint } from '@mintplayer/ng-bootstrap';
 import * as i3 from '@angular/common';
 
 type BsShellState = 'auto' | 'show' | 'hide';
 
 declare class BsShellComponent {
-    constructor();
     sidebarTemplate: TemplateRef<any> | null;
     rootElement: ElementRef<HTMLDivElement>;
-    set state(value: BsShellState);
-    set breakpoint(value: Breakpoint);
-    state$: BehaviorSubject<BsShellState>;
-    breakpoint$: BehaviorSubject<Breakpoint>;
-    stateClass$: Observable<string | null>;
-    breakpointClass$: Observable<string>;
+    state: i0.InputSignal<BsShellState>;
+    breakpoint: i0.InputSignal<Breakpoint>;
+    stateClass: i0.Signal<"show" | "hide" | null>;
+    breakpointClass: i0.Signal<string>;
     setSize(size: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsShellComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsShellComponent, "bs-shell", never, { "state": { "alias": "state"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsShellComponent, "bs-shell", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }
 
 declare class BsShellSidebarDirective {
-    private shell;
-    private template;
-    constructor(shell: BsShellComponent, template: TemplateRef<any>);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsShellSidebarDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsShellSidebarDirective, "[bsShellSidebar]", never, {}, {}, never, never, false, never>;
 }

package/types/mintplayer-ng-bootstrap-signature-pad.d.ts

@@ -1,6 +1,5 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, EventEmitter, ElementRef } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, ElementRef } from '@angular/core';
 
 interface Point {
     x: number;
@@ -16,13 +15,9 @@ interface Signature {
 }
 
 declare class BsSignaturePadComponent implements AfterViewInit {
-    constructor();
-    signature$: BehaviorSubject<Signature>;
-    signatureChange: EventEmitter<Signature>;
-    get signature(): Signature;
-    set signature(value: Signature);
-    width: number;
-    height: number;
+    signature: _angular_core.ModelSignal<Signature>;
+    width: _angular_core.InputSignal<number>;
+    height: _angular_core.InputSignal<number>;
     classes: boolean;
     isDrawing: boolean;
     canvas: ElementRef<HTMLCanvasElement>;
@@ -33,8 +28,8 @@ declare class BsSignaturePadComponent implements AfterViewInit {
     onPointerStart(ev: PointerEvent): void;
     onPointerMove(ev: PointerEvent): void;
     onPointerEnd(ev: PointerEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSignaturePadComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSignaturePadComponent, "bs-signature-pad", never, { "signature": { "alias": "signature"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "signatureChange": "signatureChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSignaturePadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSignaturePadComponent, "bs-signature-pad", never, { "signature": { "alias": "signature"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "signature": "signatureChange"; }, never, never, true, never>;
 }
 
 export { BsSignaturePadComponent };

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

@@ -1,22 +1,14 @@
-import * as i0 from '@angular/core';
-import { OnInit } from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import { Observable, BehaviorSubject } from 'rxjs';
 
-declare class BsSpinnerComponent implements OnInit {
-    constructor();
-    spinnerClass$: Observable<string>;
-    colorClass$: Observable<string>;
+declare class BsSpinnerComponent {
     colors: typeof Color;
-    ngOnInit(): void;
-    type$: BehaviorSubject<"border" | "grow">;
-    get type(): "border" | "grow";
-    set type(value: 'border' | 'grow');
-    color$: BehaviorSubject<Color>;
-    get color(): Color;
-    set color(value: Color);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSpinnerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSpinnerComponent, "bs-spinner", never, { "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+    type: _angular_core.InputSignal<"border" | "grow">;
+    color: _angular_core.InputSignal<Color>;
+    spinnerClass: _angular_core.Signal<string>;
+    colorClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSpinnerComponent, "bs-spinner", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { BsSpinnerComponent };

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

@@ -1,6 +1,5 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, ElementRef, DestroyRef, QueryList, PipeTransform } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, QueryList, ElementRef, PipeTransform } from '@angular/core';
 import * as i5 from '@angular/cdk/portal';
 import { DomPortal } from '@angular/cdk/portal';
 import * as i4 from '@angular/common';
@@ -25,32 +24,27 @@ declare enum EDragOperation {
 
 declare class BsSplitPanelComponent implements AfterViewInit {
     private element;
-    constructor(element: ElementRef);
     portal?: DomPortal;
     ngAfterViewInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitPanelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSplitPanelComponent, "bs-split-panel", never, {}, {}, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSplitPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSplitPanelComponent, "bs-split-panel", never, {}, {}, never, ["*"], false, never>;
 }
 
 type Direction = 'horizontal' | 'vertical';
 
 declare class BsSplitterComponent {
-    private destroy;
-    constructor(destroy: DestroyRef);
-    orientation$: BehaviorSubject<Direction>;
-    get orientation(): Direction;
-    set orientation(value: Direction);
-    previewSizes$: BehaviorSubject<number[] | null>;
-    panels$: BehaviorSubject<BsSplitPanelComponent[]>;
-    set panels(value: QueryList<BsSplitPanelComponent>);
+    orientation: _angular_core.InputSignal<Direction>;
+    previewSizes: _angular_core.WritableSignal<number[] | null>;
+    panels: _angular_core.WritableSignal<BsSplitPanelComponent[]>;
+    isResizing: _angular_core.WritableSignal<boolean>;
+    touchedDivider: _angular_core.WritableSignal<HTMLDivElement | null>;
+    set panelsList(value: QueryList<BsSplitPanelComponent>);
     splitPanels: QueryList<ElementRef<HTMLDivElement>>;
     classes: boolean;
-    directionClass$: Observable<string>;
-    splitterClass$: Observable<string>;
-    widthStyles$: Observable<string[] | null>;
-    heightStyles$: Observable<string[] | null>;
-    isResizing$: BehaviorSubject<boolean>;
-    touchedDivider$: BehaviorSubject<HTMLDivElement | null>;
+    directionClass: _angular_core.Signal<"flex-row" | "flex-column">;
+    splitterClass: _angular_core.Signal<"split-hor" | "split-ver">;
+    widthStyles: _angular_core.Signal<any[] | null>;
+    heightStyles: _angular_core.Signal<any[] | null>;
     operation: DragOperation | null;
     computeSizes(): number[];
     startResizeMouse(ev: MouseEvent, indexBefore: number, indexAfter: number): void;
@@ -62,20 +56,20 @@ declare class BsSplitterComponent {
     onMouseUp(ev: MouseEvent): void;
     onTouchEnd(ev: TouchEvent): void;
     onResizeUp(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitterComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSplitterComponent, "bs-splitter", never, { "orientation": { "alias": "orientation"; "required": false; }; }, {}, ["panels"], ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSplitterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSplitterComponent, "bs-splitter", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["panelsList"], ["*"], false, never>;
 }
 
 declare class BsElementAtPipe implements PipeTransform {
     transform(value: any[] | null | undefined, index: number): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsElementAtPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<BsElementAtPipe, "bsElementAt", false>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsElementAtPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<BsElementAtPipe, "bsElementAt", false>;
 }
 
 declare class BsSplitterModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitterModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSplitterModule, [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe], [typeof i4.AsyncPipe, typeof i5.PortalModule, typeof i6.BsUserAgentDirective], [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsSplitterModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSplitterModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsSplitterModule, [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe], [typeof i4.AsyncPipe, typeof i5.PortalModule, typeof i6.BsUserAgentDirective], [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsSplitterModule>;
 }
 
 export { BsElementAtPipe, BsSplitPanelComponent, BsSplitterComponent, BsSplitterModule };

package/types/mintplayer-ng-bootstrap-sticky-footer.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { AfterViewInit, DestroyRef } from '@angular/core';
+import { AfterViewInit, Injector } from '@angular/core';
 import * as i4 from '@mintplayer/ng-swiper/observe-size';
 import { BsObserveSizeDirective } from '@mintplayer/ng-swiper/observe-size';
 import * as i3 from '@angular/common';
@@ -12,8 +12,8 @@ declare class BsStickyFooterParentDirective {
 
 declare class BsStickyFooterComponent implements AfterViewInit {
     private parent;
-    private destroy;
-    constructor(parent: BsStickyFooterParentDirective, destroy: DestroyRef);
+    private injector;
+    constructor(parent: BsStickyFooterParentDirective, injector: Injector);
     ngAfterViewInit(): void;
     sizeObserver: BsObserveSizeDirective;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsStickyFooterComponent, never>;

package/types/mintplayer-ng-bootstrap-tab-control.d.ts

@@ -1,71 +1,63 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef, ElementRef, QueryList } from '@angular/core';
 import * as i5 from '@angular/cdk/drag-drop';
 import { CdkDragStart, CdkDragDrop } from '@angular/cdk/drag-drop';
-import { BehaviorSubject, Observable } from 'rxjs';
 import * as i4 from '@angular/common';
 import * as i6 from '@mintplayer/ng-bootstrap/no-noscript';
 
 declare class BsTabPageHeaderDirective {
     template: TemplateRef<any>;
-    constructor(template: TemplateRef<any>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabPageHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsTabPageHeaderDirective, "[bsTabPageHeader]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabPageHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsTabPageHeaderDirective, "[bsTabPageHeader]", never, {}, {}, never, never, false, never>;
 }
 
 declare class BsTabPageComponent {
-    constructor(tabControl: BsTabControlComponent, element: ElementRef<any>);
     element: ElementRef<any>;
     tabControl: BsTabControlComponent;
-    tabId$: BehaviorSubject<number>;
-    tabName$: Observable<string>;
-    disabled: boolean;
+    constructor();
+    tabId: _angular_core.WritableSignal<number>;
+    tabName: _angular_core.Signal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
     headerTemplate: BsTabPageHeaderDirective;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabPageComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsTabPageComponent, "bs-tab-page", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["headerTemplate"], ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTabPageComponent, "bs-tab-page", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate"], ["*"], false, never>;
 }
 
 type BsTabsPosition = 'top' | 'bottom';
 
 declare class BsTabControlComponent {
-    constructor(element: ElementRef<any>);
+    element: ElementRef<any>;
+    constructor();
     dBlock: boolean;
     positionRelative: boolean;
     set setTabPages(value: QueryList<BsTabPageComponent>);
-    border: boolean;
-    set restrictDragging(value: boolean);
-    dragBoundarySelector: string;
-    element: ElementRef<any>;
-    tabPages$: BehaviorSubject<QueryList<BsTabPageComponent> | null>;
-    activeTab$: BehaviorSubject<BsTabPageComponent | null>;
+    border: _angular_core.InputSignal<boolean>;
+    restrictDragging: _angular_core.InputSignal<boolean>;
+    selectFirstTab: _angular_core.InputSignal<boolean>;
+    tabsPosition: _angular_core.InputSignal<BsTabsPosition>;
+    allowDragDrop: _angular_core.InputSignal<boolean>;
+    dragBoundarySelector: _angular_core.Signal<"ul" | "">;
+    tabPages: _angular_core.WritableSignal<QueryList<BsTabPageComponent> | null>;
+    activeTab: _angular_core.WritableSignal<BsTabPageComponent | null>;
     orderedTabPages: BsTabPageComponent[];
-    tabControlId$: BehaviorSubject<number>;
-    tabControlName$: Observable<string>;
-    topTabs$: Observable<boolean>;
-    bottomTabs$: Observable<boolean>;
-    disableDragDrop$: Observable<boolean>;
+    tabControlId: _angular_core.WritableSignal<number>;
+    tabControlName: _angular_core.Signal<string>;
+    topTabs: _angular_core.Signal<boolean>;
+    bottomTabs: _angular_core.Signal<boolean>;
+    disableDragDrop: _angular_core.Signal<boolean>;
     static tabControlCounter: number;
     tabCounter: number;
-    selectFirstTab$: BehaviorSubject<boolean>;
-    get selectFirstTab(): boolean;
-    set selectFirstTab(value: boolean);
-    tabsPosition$: BehaviorSubject<BsTabsPosition>;
-    get tabsPosition(): BsTabsPosition;
-    set tabsPosition(value: BsTabsPosition);
-    allowDragDrop$: BehaviorSubject<boolean>;
-    get allowDragDrop(): boolean;
-    set allowDragDrop(value: boolean);
     setActiveTab(tab: BsTabPageComponent): boolean;
     startDragTab(ev: CdkDragStart<BsTabPageComponent>): void;
     moveTab(ev: CdkDragDrop<QueryList<BsTabPageComponent> | null>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsTabControlComponent, "bs-tab-control", never, { "border": { "alias": "border"; "required": false; }; "restrictDragging": { "alias": "restrictDragging"; "required": false; }; "selectFirstTab": { "alias": "selectFirstTab"; "required": false; }; "tabsPosition": { "alias": "tabsPosition"; "required": false; }; "allowDragDrop": { "alias": "allowDragDrop"; "required": false; }; }, {}, ["setTabPages"], ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTabControlComponent, "bs-tab-control", never, { "border": { "alias": "border"; "required": false; "isSignal": true; }; "restrictDragging": { "alias": "restrictDragging"; "required": false; "isSignal": true; }; "selectFirstTab": { "alias": "selectFirstTab"; "required": false; "isSignal": true; }; "tabsPosition": { "alias": "tabsPosition"; "required": false; "isSignal": true; }; "allowDragDrop": { "alias": "allowDragDrop"; "required": false; "isSignal": true; }; }, {}, ["setTabPages"], ["*"], false, never>;
 }
 
 declare class BsTabControlModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabControlModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsTabControlModule, [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective], [typeof i4.AsyncPipe, typeof i4.NgTemplateOutlet, typeof i5.DragDropModule, typeof i6.BsNoNoscriptDirective], [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsTabControlModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabControlModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsTabControlModule, [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective], [typeof i4.AsyncPipe, typeof i4.NgTemplateOutlet, typeof i5.DragDropModule, typeof i6.BsNoNoscriptDirective], [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsTabControlModule>;
 }
 
 export { BsTabControlComponent, BsTabControlModule, BsTabPageComponent, BsTabPageHeaderDirective };

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

@@ -1,18 +1,11 @@
-import { BehaviorSubject } from 'rxjs';
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 
 declare class BsTableComponent {
-    isResponsive$: BehaviorSubject<boolean>;
-    get isResponsive(): boolean;
-    set isResponsive(value: boolean);
-    striped$: BehaviorSubject<boolean>;
-    get striped(): boolean;
-    set striped(value: boolean);
-    hover$: BehaviorSubject<boolean>;
-    get hover(): boolean;
-    set hover(value: boolean);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsTableComponent, "bs-table", never, { "isResponsive": { "alias": "isResponsive"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; }, {}, never, ["*"], true, never>;
+    isResponsive: _angular_core.InputSignal<boolean>;
+    striped: _angular_core.InputSignal<boolean>;
+    hover: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTableComponent, "bs-table", never, { "isResponsive": { "alias": "isResponsive"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 export { BsTableComponent };

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

@@ -1,15 +1,11 @@
-import * as i0 from '@angular/core';
-import { ChangeDetectorRef, NgZone, Renderer2, EventEmitter } from '@angular/core';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as _angular_core from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
 import { Color } from '@mintplayer/ng-bootstrap';
 
 declare class BsTimepickerComponent {
-    private ref;
-    private zone;
-    private renderer;
     private sanitizer;
-    constructor(ref: ChangeDetectorRef, zone: NgZone, renderer: Renderer2, sanitizer: DomSanitizer);
-    clock?: SafeHtml;
+    constructor();
+    clock: _angular_core.WritableSignal<SafeHtml | undefined>;
     colors: typeof Color;
     isOpen: boolean;
     presetTimestamps: Date[];
@@ -17,17 +13,14 @@ declare class BsTimepickerComponent {
     selectAll(box: HTMLInputElement): void;
     setNumber(event: Event, max: number, nextInput: HTMLInputElement | null): void;
     setTime(time: Date): void;
-    private _selectedTime;
-    selectedTimeChange: EventEmitter<Date>;
-    get selectedTime(): Date;
-    set selectedTime(value: Date);
+    selectedTime: _angular_core.ModelSignal<Date>;
     get hours(): number;
     set hours(value: number);
     get minutes(): number;
     set minutes(value: number);
     timesEqual(time1: Date, time2: Date): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTimepickerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsTimepickerComponent, "bs-timepicker", never, { "selectedTime": { "alias": "selectedTime"; "required": false; }; }, { "selectedTimeChange": "selectedTimeChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTimepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTimepickerComponent, "bs-timepicker", never, { "selectedTime": { "alias": "selectedTime"; "required": false; "isSignal": true; }; }, { "selectedTime": "selectedTimeChange"; }, never, never, true, never>;
 }
 
 export { BsTimepickerComponent };

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

@@ -1,16 +1,14 @@
 import * as i0 from '@angular/core';
-import { Injector, TemplateRef, PipeTransform } from '@angular/core';
+import { TemplateRef, PipeTransform } from '@angular/core';
 import * as i8 from '@angular/cdk/overlay';
-import { Overlay, OverlayRef } from '@angular/cdk/overlay';
-import { ComponentPortal } from '@angular/cdk/portal';
-import { BehaviorSubject } from 'rxjs';
+import { OverlayRef } from '@angular/cdk/overlay';
 import * as i7 from '@angular/common';
 import * as i9 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsToastComponent {
-    isVisible: boolean;
+    isVisible: i0.InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastComponent, "bs-toast", never, { "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastComponent, "bs-toast", never, { "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }
 
 declare class BsToastHeaderComponent {
@@ -29,9 +27,8 @@ declare class BsToastService {
     private overlayService;
     private rootInjector;
     private portalFactory;
-    constructor(overlayService: Overlay, rootInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<any>);
     overlayRef: OverlayRef | null;
-    toasts$: BehaviorSubject<ToastItem[]>;
+    toasts: i0.WritableSignal<ToastItem[]>;
     pushToast(toast: TemplateRef<any>, context?: Object): void;
     close(index: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastService, never>;
@@ -43,7 +40,6 @@ interface ToastItem {
 }
 
 declare class BsToastContainerComponent {
-    constructor(toastService: BsToastService);
     toastService: BsToastService;
     overflowY: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastContainerComponent, never>;
@@ -53,7 +49,6 @@ declare class BsToastContainerComponent {
 declare class BsToastCloseDirective {
     private toast;
     private toastService;
-    constructor(toast: BsToastComponent, toastService: BsToastService);
     onClick(): void;
     index: number | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastCloseDirective, never>;