@mintplayer/ng-bootstrap 21.6.0 → 21.7.0

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

@@ -1,9 +1,14 @@
 import * as _angular_core from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import * as i3 from '@angular/common';
+
+declare class BsProgressComponent {
+    readonly height: _angular_core.InputSignal<number | null>;
+    readonly isIndeterminate: _angular_core.InputSignal<boolean>;
+    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>;
+}
 
 declare class BsProgressBarComponent {
-    constructor();
     minimum: _angular_core.InputSignal<number>;
     maximum: _angular_core.InputSignal<number>;
     value: _angular_core.InputSignal<number>;
@@ -13,31 +18,8 @@ declare class BsProgressBarComponent {
     percentage: _angular_core.Signal<number>;
     width: _angular_core.Signal<string>;
     colorClassComputed: _angular_core.Signal<string>;
-    progressBar: boolean;
-    get stripedClass(): boolean;
-    get animatedClass(): boolean;
-    colorClass: string;
-    widthStyle: string;
-    role: string;
-    valueNow: number;
-    valueMin: number;
-    valueMax: number;
     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, false, never>;
-}
-
-declare class BsProgressComponent {
-    height: number | null;
-    isIndeterminate: boolean;
-    progressClass: boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsProgressComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsProgressComponent, "bs-progress", never, { "height": { "alias": "height"; "required": false; }; "isIndeterminate": { "alias": "isIndeterminate"; "required": false; }; }, {}, never, ["*"], false, never>;
-}
-
-declare class BsProgressBarModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsProgressBarModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsProgressBarModule, [typeof BsProgressBarComponent, typeof BsProgressComponent], [typeof i3.CommonModule], [typeof BsProgressBarComponent, typeof BsProgressComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsProgressBarModule>;
+    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>;
 }
 
-export { BsProgressBarComponent, BsProgressBarModule, BsProgressComponent };
+export { BsProgressBarComponent, BsProgressComponent };

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

@@ -1,35 +1,27 @@
-import * as i0 from '@angular/core';
-import { ElementRef, AfterViewInit } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
-import * as i3 from '@angular/common';
 
 declare class BsRangeComponent {
-    slider: ElementRef<HTMLInputElement>;
-    min: number;
-    max: number;
-    step: number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsRangeComponent, "bs-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, never, never, false, never>;
+    readonly slider: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    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, never>;
 }
 
-declare class BsRangeValueAccessor implements ControlValueAccessor, AfterViewInit {
+declare class BsRangeValueAccessor implements ControlValueAccessor {
     private host;
-    private destroy;
     onValueChange?: (value: number) => void;
     onTouched?: () => void;
-    ngAfterViewInit(): void;
+    onInputEvent(ev: Event): void;
     registerOnChange(fn: (_: any) => void): void;
     registerOnTouched(fn: () => void): void;
     writeValue(value?: number): void;
     setDisabledState(isDisabled: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeValueAccessor, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsRangeValueAccessor, "bs-range", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsRangeValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsRangeValueAccessor, "bs-range", never, {}, {}, never, never, true, never>;
 }
 
-declare class BsRangeModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsRangeModule, [typeof BsRangeComponent, typeof BsRangeValueAccessor], [typeof i3.CommonModule], [typeof BsRangeComponent, typeof BsRangeValueAccessor]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsRangeModule>;
-}
-
-export { BsRangeComponent, BsRangeModule, BsRangeValueAccessor };
+export { BsRangeComponent, BsRangeValueAccessor };

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

@@ -1,8 +1,6 @@
 import * as _angular_core from '@angular/core';
 
 declare class BsRatingComponent {
-    role: string;
-    ariaLabel: string;
     constructor();
     maximum: _angular_core.InputSignal<number>;
     value: _angular_core.ModelSignal<number>;

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

@@ -1,7 +1,6 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { ElementRef, InjectionToken } from '@angular/core';
 import { Position } from '@mintplayer/ng-bootstrap';
-import * as i3 from '@angular/common';
 
 type ResizablePositioning = 'absolute' | 'inline';
 
@@ -33,10 +32,11 @@ interface PresetPosition {
 declare class BsResizableComponent {
     element: ElementRef<any>;
     resizeAction?: ResizeAction;
-    positioning: i0.InputSignal<ResizablePositioning>;
-    hostPosition: i0.Signal<"position-absolute" | "position-relative">;
-    wrapperPosition: i0.Signal<string[]>;
-    set presetPosition(value: PresetPosition);
+    positioning: _angular_core.InputSignal<ResizablePositioning>;
+    hostPosition: _angular_core.Signal<"position-absolute" | "position-relative">;
+    wrapperPosition: _angular_core.Signal<string[]>;
+    readonly presetPosition: _angular_core.InputSignal<PresetPosition | undefined>;
+    constructor();
     marginLeft?: number;
     marginRight?: number;
     marginTop?: number;
@@ -45,10 +45,8 @@ declare class BsResizableComponent {
     height?: number;
     left?: number;
     top?: number;
-    classes: boolean;
-    get hostClass(): string | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsResizableComponent, "bs-resizable", never, { "positioning": { "alias": "positioning"; "required": false; "isSignal": true; }; "presetPosition": { "alias": "presetPosition"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsResizableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsResizableComponent, "bs-resizable", never, { "positioning": { "alias": "positioning"; "required": false; "isSignal": true; }; "presetPosition": { "alias": "presetPosition"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 interface PointerData {
@@ -59,11 +57,10 @@ interface PointerData {
 
 declare class BsResizeGlyphDirective {
     private readonly resizable;
-    constructor(resizable: any);
+    constructor();
     positions: string;
-    glyphClass: boolean;
     activeClass: boolean;
-    set bsResizeGlyph(value: Position[]);
+    readonly bsResizeGlyph: _angular_core.InputSignal<Position[]>;
     onMouseDown(ev: MouseEvent): void;
     onTouchStart(ev: TouchEvent): void;
     onMouseMove(ev: MouseEvent): void;
@@ -74,17 +71,11 @@ declare class BsResizeGlyphDirective {
     private isBusy;
     onPointerMove(ev: PointerData): void;
     onPointerUp(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizeGlyphDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsResizeGlyphDirective, "[bsResizeGlyph]", never, { "bsResizeGlyph": { "alias": "bsResizeGlyph"; "required": false; }; }, {}, never, never, false, never>;
-}
-
-declare class BsResizableModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizableModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsResizableModule, [typeof BsResizableComponent, typeof BsResizeGlyphDirective], [typeof i3.CommonModule], [typeof BsResizableComponent, typeof BsResizeGlyphDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsResizableModule>;
+    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>;
 }
 
 declare const RESIZABLE: InjectionToken<BsResizableComponent>;
 
-export { BsResizableComponent, BsResizableModule, BsResizeGlyphDirective, RESIZABLE };
+export { BsResizableComponent, BsResizeGlyphDirective, RESIZABLE };
 export type { PointerData, PresetPosition, ResizablePositioning, ResizeAction, ResizeActionSide };

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

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit, OnDestroy } from '@angular/core';
-import { SchedulerEvent, Resource, ViewType, ResourceGroup, SchedulerOptions } from '@mintplayer/scheduler-core';
+import { ViewType, SchedulerEvent, Resource, ResourceGroup, SchedulerOptions } from '@mintplayer/scheduler-core';
 export { PreviewEvent, Resource, ResourceGroup, SchedulerEvent, SchedulerEventPart, SchedulerOptions, TimeSlot, ViewType, generateEventId, generateGroupId, generateResourceId } from '@mintplayer/scheduler-core';
 
 /**
@@ -62,7 +62,7 @@ interface ViewChangeEvent {
  */
 declare class BsSchedulerComponent implements AfterViewInit, OnDestroy {
     private readonly injector;
-    private schedulerRef;
+    private readonly schedulerRef;
     readonly view: _angular_core.InputSignal<ViewType>;
     readonly date: _angular_core.InputSignal<Date>;
     readonly events: _angular_core.InputSignal<SchedulerEvent[]>;
@@ -134,11 +134,5 @@ declare class BsSchedulerComponent implements AfterViewInit, OnDestroy {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSchedulerComponent, "bs-scheduler", never, { "view": { "alias": "view"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "resources": { "alias": "resources"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "selectedEvent": { "alias": "selectedEvent"; "required": false; "isSignal": true; }; "selectedRange": { "alias": "selectedRange"; "required": false; "isSignal": true; }; }, { "selectedEvent": "selectedEventChange"; "selectedRange": "selectedRangeChange"; "eventClick": "eventClick"; "eventDblClick": "eventDblClick"; "eventCreate": "eventCreate"; "eventUpdate": "eventUpdate"; "eventDelete": "eventDelete"; "dateClick": "dateClick"; "dateSelect": "dateSelect"; "viewChange": "viewChange"; }, never, never, true, never>;
 }
 
-declare class BsSchedulerModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSchedulerModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsSchedulerModule, never, [typeof BsSchedulerComponent], [typeof BsSchedulerComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsSchedulerModule>;
-}
-
-export { BsSchedulerComponent, BsSchedulerModule };
+export { BsSchedulerComponent };
 export type { DateClickEvent, DateSelectEvent, SchedulerEventClickEvent, SchedulerEventCreateEvent, SchedulerEventDeleteEvent, SchedulerEventUpdateEvent, ViewChangeEvent };

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

@@ -1,21 +1,19 @@
 import * as i0 from '@angular/core';
-import { ElementRef, AfterViewInit, AfterContentInit, QueryList } from '@angular/core';
-import { ExtraOptions } from '@angular/router';
+import { ElementRef, AfterViewInit, AfterContentInit } from '@angular/core';
 
 declare class BsScrollspyDirective {
     element: ElementRef<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsScrollspyDirective, "[bsScrollspy]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsScrollspyDirective, "[bsScrollspy]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
     private scrollOffsetService;
-    private zone;
     doc: Document;
     private viewInit;
     private contentInit;
-    directives: QueryList<BsScrollspyDirective>;
-    anchors: QueryList<ElementRef<HTMLSpanElement>>;
+    readonly directives: i0.Signal<readonly BsScrollspyDirective[]>;
+    readonly anchors: i0.Signal<readonly ElementRef<HTMLSpanElement>[]>;
     activeDirective: BsScrollspyDirective | null;
     constructor();
     ngAfterViewInit(): void;
@@ -25,21 +23,14 @@ declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
     scrollToCurrentInSpy(): void;
     scrollToHeader(directive: BsScrollspyDirective): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsScrollspyComponent, "bs-scrollspy", never, {}, {}, ["directives"], ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsScrollspyComponent, "bs-scrollspy", never, {}, {}, ["directives"], ["*"], true, never>;
 }
 
 declare class BsScrollOffsetService {
     private routerConfig;
-    constructor(routerConfig: ExtraOptions);
     getScrollOffset(): [number, number];
     static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollOffsetService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BsScrollOffsetService>;
 }
 
-declare class BsScrollspyModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsScrollspyModule, [typeof BsScrollspyComponent, typeof BsScrollspyDirective], never, [typeof BsScrollspyComponent, typeof BsScrollspyDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsScrollspyModule>;
-}
-
-export { BsScrollOffsetService, BsScrollspyComponent, BsScrollspyDirective, BsScrollspyModule };
+export { BsScrollOffsetService, BsScrollspyComponent, BsScrollspyDirective };

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

@@ -1,36 +1,28 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { OnDestroy, ElementRef, TemplateRef } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
 import { HasId } from '@mintplayer/ng-bootstrap/has-id';
 import { SafeHtml } from '@angular/platform-browser';
-import * as i5 from '@angular/forms';
-import * as i6 from '@angular/common';
-import * as i7 from '@mintplayer/ng-focus-on-load';
-import * as i8 from '@mintplayer/ng-bootstrap/dropdown';
-import * as i9 from '@mintplayer/ng-bootstrap/dropdown-menu';
-import * as i10 from '@mintplayer/ng-bootstrap/button-type';
-import * as i11 from '@mintplayer/ng-bootstrap/progress-bar';
-import * as i12 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsEnterSearchTermTemplateDirective<T extends HasId<U>, U> {
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsEnterSearchTermTemplateDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsEnterSearchTermTemplateDirective<any, any>, "[bsEnterSearchTermTemplate]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsEnterSearchTermTemplateDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsEnterSearchTermTemplateDirective<any, any>, "[bsEnterSearchTermTemplate]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsNoResultsTemplateDirective<T extends HasId<U>, U> {
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsNoResultsTemplateDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNoResultsTemplateDirective<any, any>, "[bsNoResultsTemplate]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNoResultsTemplateDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsNoResultsTemplateDirective<any, any>, "[bsNoResultsTemplate]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsSuggestionTemplateDirective<TData extends HasId<U>, U> {
     private searchbox;
     constructor();
     static ngTemplateContextGuard<TData extends HasId<U>, U>(dir: BsSuggestionTemplateDirective<TData, U>, ctx: any): ctx is BsSuggestionTemplateContext<Exclude<TData, false | 0 | '' | null | undefined>, U>;
-    set bsSuggestionTemplateOf(value: TData[]);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+    readonly bsSuggestionTemplateOf: _angular_core.InputSignal<TData[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsSuggestionTemplateContext<TData extends HasId<U>, U> {
     $implicit: TData;
@@ -40,33 +32,27 @@ declare class BsSuggestionTemplateContext<TData extends HasId<U>, U> {
 declare class BsSearchboxComponent<T extends HasId<U>, U> implements OnDestroy {
     private bsForm;
     private sanitizer;
-    caretUpFill: i0.WritableSignal<SafeHtml | undefined>;
-    caretDownFill: i0.WritableSignal<SafeHtml | undefined>;
+    caretUpFill: _angular_core.WritableSignal<SafeHtml | undefined>;
+    caretDownFill: _angular_core.WritableSignal<SafeHtml | undefined>;
     colors: typeof Color;
-    isBusy: i0.WritableSignal<boolean>;
-    textbox: ElementRef<HTMLInputElement>;
-    isOpen: i0.ModelSignal<boolean>;
-    selectedItem: i0.ModelSignal<T | undefined>;
-    searchterm: i0.ModelSignal<string>;
-    suggestions: i0.ModelSignal<T[]>;
+    isBusy: _angular_core.WritableSignal<boolean>;
+    readonly textbox: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    selectedItem: _angular_core.ModelSignal<T | undefined>;
+    searchterm: _angular_core.ModelSignal<string>;
+    suggestions: _angular_core.ModelSignal<T[]>;
     suggestionTemplate?: TemplateRef<BsSuggestionTemplateContext<T, U>>;
     enterSearchtermTemplate?: TemplateRef<T>;
     noResultsTemplate?: TemplateRef<T>;
-    provideSuggestions: i0.OutputEmitterRef<string>;
+    provideSuggestions: _angular_core.OutputEmitterRef<string>;
     private debouncedSearchterm;
     private debounceTimeout;
     constructor();
     ngOnDestroy(): void;
     onSearchtermChange(searchterm: string): void;
     onSuggestionClicked(suggestion: T): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSearchboxComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSearchboxComponent<any, any>, "bs-searchbox", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "selectedItem": { "alias": "selectedItem"; "required": false; "isSignal": true; }; "searchterm": { "alias": "searchterm"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "selectedItem": "selectedItemChange"; "searchterm": "searchtermChange"; "suggestions": "suggestionsChange"; "provideSuggestions": "provideSuggestions"; }, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSearchboxComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSearchboxComponent<any, any>, "bs-searchbox", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "selectedItem": { "alias": "selectedItem"; "required": false; "isSignal": true; }; "searchterm": { "alias": "searchterm"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "selectedItem": "selectedItemChange"; "searchterm": "searchtermChange"; "suggestions": "suggestionsChange"; "provideSuggestions": "provideSuggestions"; }, never, ["*"], true, never>;
 }
 
-declare class BsSearchboxModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSearchboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSearchboxModule, [typeof BsSearchboxComponent, typeof BsEnterSearchTermTemplateDirective, typeof BsSuggestionTemplateDirective, typeof BsNoResultsTemplateDirective], [typeof i5.FormsModule, typeof i6.AsyncPipe, typeof i6.NgTemplateOutlet, typeof i7.FocusOnLoadDirective, typeof i8.BsDropdownModule, typeof i9.BsDropdownMenuModule, typeof i10.BsButtonTypeDirective, typeof i11.BsProgressBarModule, typeof i12.BsHasOverlayComponent], [typeof BsSearchboxComponent, typeof BsEnterSearchTermTemplateDirective, typeof BsSuggestionTemplateDirective, typeof BsNoResultsTemplateDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsSearchboxModule>;
-}
-
-export { BsEnterSearchTermTemplateDirective, BsNoResultsTemplateDirective, BsSearchboxComponent, BsSearchboxModule, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };
+export { BsEnterSearchTermTemplateDirective, BsNoResultsTemplateDirective, BsSearchboxComponent, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };

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

@@ -1,23 +1,22 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 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 {
     private renderer;
     constructor();
-    identifier: i0.InputSignal<number>;
-    selectBox: ElementRef<HTMLSelectElement>;
-    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; "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>;
+    identifier: _angular_core.InputSignal<number>;
+    readonly selectBox: _angular_core.Signal<ElementRef<HTMLSelectElement>>;
+    size: _angular_core.InputSignal<BsSelectSize>;
+    multiple: _angular_core.InputSignal<boolean>;
+    numberVisible: _angular_core.InputSignal<number | null>;
+    disabled: _angular_core.InputSignal<boolean>;
+    sizeClass: _angular_core.Signal<string | null>;
+    multipleValue: _angular_core.Signal<true | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵ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, ["*"], true, never>;
 }
 
 declare class BsSelectValueAccessor implements ControlValueAccessor {
@@ -36,15 +35,16 @@ declare class BsSelectValueAccessor implements ControlValueAccessor {
     optionMap: Map<string, any>;
     idCounter: number;
     private compareWithFunction;
-    set compareWith(value: (value1: any, value2: any) => boolean);
+    readonly compareWith: _angular_core.InputSignal<((value1: any, value2: any) => boolean) | undefined>;
+    constructor();
     buildValueString(id: string | null, value: any): string;
     extractId(valueString: string): string;
     writeValue(value: any): void;
     registerOption(): string;
     getOptionId(value: any): string | null;
     getOptionValue(valueString: string): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectValueAccessor, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectValueAccessor, "bs-select", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSelectValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsSelectValueAccessor, "bs-select", never, { "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsSelectOption implements OnDestroy {
     private element;
@@ -52,19 +52,13 @@ declare class BsSelectOption implements OnDestroy {
     private select;
     constructor();
     id: string;
-    set ngValue(value: any);
-    set value(value: any);
+    readonly ngValue: _angular_core.InputSignal<any>;
+    readonly value: _angular_core.InputSignal<any>;
     setElementValue(value: string): void;
     ngOnDestroy(): void;
-    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>;
-}
-
-declare class BsSelectModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSelectModule, [typeof BsSelectComponent, typeof BsSelectValueAccessor, typeof BsSelectOption], [typeof i3.CommonModule], [typeof BsSelectComponent, typeof BsSelectValueAccessor, typeof BsSelectOption]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsSelectModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSelectOption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsSelectOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { BsSelectComponent, BsSelectModule, BsSelectOption, BsSelectValueAccessor };
+export { BsSelectComponent, BsSelectOption, BsSelectValueAccessor };
 export type { BsSelectSize };

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

@@ -1,26 +1,20 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef, ElementRef, WritableSignal } from '@angular/core';
 import { HasId } from '@mintplayer/ng-bootstrap/has-id';
-import * as i4 from '@angular/common';
-import * as i5 from '@angular/forms';
-import * as i6 from '@mintplayer/ng-bootstrap/dropdown';
-import * as i7 from '@mintplayer/ng-bootstrap/dropdown-menu';
-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: i0.WritableSignal<boolean>;
-    isLoading: i0.WritableSignal<boolean>;
-    suggestions: i0.ModelSignal<T[]>;
-    defaultItemTemplate: TemplateRef<any>;
-    searchBox: ElementRef<HTMLInputElement>;
-    itemsBox: ElementRef<HTMLDivElement>;
-    searchterm: i0.ModelSignal<string>;
-    provideSuggestions: i0.OutputEmitterRef<string>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    suggestions: _angular_core.ModelSignal<T[]>;
+    readonly defaultItemTemplate: _angular_core.Signal<TemplateRef<any>>;
+    readonly searchBox: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly itemsBox: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    searchterm: _angular_core.ModelSignal<string>;
+    provideSuggestions: _angular_core.OutputEmitterRef<string>;
     isFocused: boolean;
-    selectedItems: i0.ModelSignal<T[]>;
+    selectedItems: _angular_core.ModelSignal<T[]>;
     private charWidth;
-    searchWidth: i0.WritableSignal<number>;
+    searchWidth: _angular_core.WritableSignal<number>;
     itemTemplate?: TemplateRef<T>;
     suggestionTemplate?: TemplateRef<T>;
     constructor();
@@ -28,8 +22,8 @@ declare class BsSelect2Component<T extends HasId<U>, U> {
     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, { "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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSelect2Component<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵ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, true, never>;
 }
 
 declare class BsItemTemplateDirective<T extends HasId<U>, U> {
@@ -39,9 +33,9 @@ declare class BsItemTemplateDirective<T extends HasId<U>, U> {
     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[] | 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>;
+    readonly bsItemTemplateOf: _angular_core.InputSignal<T[] | WritableSignal<T[]> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsItemTemplateDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsItemTemplateDirective<any, any>, "[bsItemTemplate]", never, { "bsItemTemplateOf": { "alias": "bsItemTemplateOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsItemTemplateContext<T extends HasId<U>, U> {
     $implicit: T;
@@ -52,19 +46,13 @@ declare class BsSuggestionTemplateDirective<T extends HasId<U>, U> {
     private select2component;
     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>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+    readonly bsSuggestionTemplateOf: _angular_core.InputSignal<T[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsSuggestionTemplateContext<T extends HasId<U>, U> {
     $implicit: T;
     select2: BsSelect2Component<T, U>;
 }
 
-declare class BsSelect2Module {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Module, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSelect2Module, [typeof BsSelect2Component, typeof BsItemTemplateDirective, typeof BsSuggestionTemplateDirective], [typeof i4.NgTemplateOutlet, typeof i5.FormsModule, typeof i6.BsDropdownModule, typeof i7.BsDropdownMenuModule, typeof i8.BsHasOverlayComponent, typeof i9.BsInListPipe], [typeof BsSelect2Component, typeof BsItemTemplateDirective, typeof BsSuggestionTemplateDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsSelect2Module>;
-}
-
-export { BsItemTemplateContext, BsItemTemplateDirective, BsSelect2Component, BsSelect2Module, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };
+export { BsItemTemplateContext, BsItemTemplateDirective, BsSelect2Component, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };

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

@@ -1,33 +1,26 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef, ElementRef } from '@angular/core';
 import { Breakpoint } from '@mintplayer/ng-bootstrap';
-import * as i3 from '@angular/common';
 
 type BsShellState = 'auto' | 'show' | 'hide';
 
 declare class BsShellComponent {
     sidebarTemplate: TemplateRef<any> | null;
-    rootElement: ElementRef<HTMLDivElement>;
-    state: i0.InputSignal<BsShellState>;
-    breakpoint: i0.InputSignal<Breakpoint>;
-    stateClass: i0.Signal<"show" | "hide" | null>;
-    breakpointClass: i0.Signal<string>;
+    readonly rootElement: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    state: _angular_core.InputSignal<BsShellState>;
+    breakpoint: _angular_core.InputSignal<Breakpoint>;
+    stateClass: _angular_core.Signal<"show" | "hide" | null>;
+    breakpointClass: _angular_core.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; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsShellComponent, "bs-shell", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsShellSidebarDirective {
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsShellSidebarDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsShellSidebarDirective, "[bsShellSidebar]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsShellSidebarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsShellSidebarDirective, "[bsShellSidebar]", never, {}, {}, never, never, true, never>;
 }
 
-declare class BsShellModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsShellModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsShellModule, [typeof BsShellComponent, typeof BsShellSidebarDirective], [typeof i3.CommonModule], [typeof BsShellComponent, typeof BsShellSidebarDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsShellModule>;
-}
-
-export { BsShellComponent, BsShellModule, BsShellSidebarDirective };
+export { BsShellComponent, BsShellSidebarDirective };
 export type { BsShellState };

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

@@ -18,12 +18,11 @@ declare class BsSignaturePadComponent implements AfterViewInit {
     signature: _angular_core.ModelSignal<Signature>;
     width: _angular_core.InputSignal<number>;
     height: _angular_core.InputSignal<number>;
-    classes: boolean;
+    minHeight: number;
     isDrawing: boolean;
-    canvas: ElementRef<HTMLCanvasElement>;
+    readonly canvas: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
     context: CanvasRenderingContext2D | null;
     ngAfterViewInit(): void;
-    minHeight: number;
     onTouchMove(ev: TouchEvent): void;
     onPointerStart(ev: PointerEvent): void;
     onPointerMove(ev: PointerEvent): void;