@mintplayer/ng-bootstrap 20.6.3 → 21.1.0

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

@@ -0,0 +1,144 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { SchedulerEvent, Resource, ViewType, ResourceGroup, SchedulerOptions } from '@mintplayer/scheduler-core';
+export { PreviewEvent, Resource, ResourceGroup, SchedulerEvent, SchedulerEventPart, SchedulerOptions, TimeSlot, ViewType, generateEventId, generateGroupId, generateResourceId } from '@mintplayer/scheduler-core';
+
+/**
+ * Event click event detail
+ */
+interface SchedulerEventClickEvent {
+    event: SchedulerEvent;
+    originalEvent?: Event;
+}
+/**
+ * Event create event detail
+ */
+interface SchedulerEventCreateEvent {
+    event: SchedulerEvent;
+    resource?: Resource;
+    originalEvent?: Event;
+}
+/**
+ * Event update event detail
+ */
+interface SchedulerEventUpdateEvent {
+    event: SchedulerEvent;
+    oldEvent: SchedulerEvent;
+    originalEvent?: Event;
+}
+/**
+ * Event delete event detail
+ */
+interface SchedulerEventDeleteEvent {
+    event: SchedulerEvent;
+    originalEvent?: Event;
+}
+/**
+ * Date click event detail
+ */
+interface DateClickEvent {
+    date: Date;
+    resource?: Resource;
+    originalEvent?: Event;
+}
+/**
+ * Date select event detail
+ */
+interface DateSelectEvent {
+    start: Date;
+    end: Date;
+    resource?: Resource;
+    originalEvent?: Event;
+}
+/**
+ * View change event detail
+ */
+interface ViewChangeEvent {
+    view: ViewType;
+    date: Date;
+}
+/**
+ * Angular wrapper for the mp-scheduler web component using signals
+ */
+declare class BsSchedulerComponent implements AfterViewInit, OnDestroy {
+    private readonly injector;
+    private schedulerRef;
+    readonly view: _angular_core.InputSignal<ViewType>;
+    readonly date: _angular_core.InputSignal<Date>;
+    readonly events: _angular_core.InputSignal<SchedulerEvent[]>;
+    readonly resources: _angular_core.InputSignal<(Resource | ResourceGroup)[]>;
+    readonly options: _angular_core.InputSignal<Partial<SchedulerOptions>>;
+    readonly selectedEvent: _angular_core.ModelSignal<SchedulerEvent | null>;
+    readonly selectedRange: _angular_core.ModelSignal<{
+        start: Date;
+        end: Date;
+    } | null>;
+    readonly eventClick: _angular_core.OutputEmitterRef<SchedulerEventClickEvent>;
+    readonly eventDblClick: _angular_core.OutputEmitterRef<SchedulerEventClickEvent>;
+    readonly eventCreate: _angular_core.OutputEmitterRef<SchedulerEventCreateEvent>;
+    readonly eventUpdate: _angular_core.OutputEmitterRef<SchedulerEventUpdateEvent>;
+    readonly eventDelete: _angular_core.OutputEmitterRef<SchedulerEventDeleteEvent>;
+    readonly dateClick: _angular_core.OutputEmitterRef<DateClickEvent>;
+    readonly dateSelect: _angular_core.OutputEmitterRef<DateSelectEvent>;
+    readonly viewChange: _angular_core.OutputEmitterRef<ViewChangeEvent>;
+    readonly currentWeekStart: _angular_core.Signal<Date>;
+    readonly currentWeekEnd: _angular_core.Signal<Date>;
+    readonly visibleEvents: _angular_core.Signal<SchedulerEvent[]>;
+    private readonly initialized;
+    private eventListeners;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setupEventListeners;
+    private removeEventListeners;
+    /**
+     * Navigate to next period
+     */
+    next(): void;
+    /**
+     * Navigate to previous period
+     */
+    prev(): void;
+    /**
+     * Navigate to today
+     */
+    today(): void;
+    /**
+     * Navigate to a specific date
+     */
+    gotoDate(date: Date): void;
+    /**
+     * Change the current view
+     */
+    changeView(view: ViewType): void;
+    /**
+     * Add an event
+     */
+    addEvent(event: SchedulerEvent): void;
+    /**
+     * Update an event
+     */
+    updateEvent(event: SchedulerEvent): void;
+    /**
+     * Remove an event
+     */
+    removeEvent(eventId: string): void;
+    /**
+     * Get an event by ID
+     */
+    getEventById(eventId: string): SchedulerEvent | null;
+    /**
+     * Refetch/refresh events
+     */
+    refetchEvents(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSchedulerComponent, never>;
+    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 type { DateClickEvent, DateSelectEvent, SchedulerEventClickEvent, SchedulerEventCreateEvent, SchedulerEventDeleteEvent, SchedulerEventUpdateEvent, ViewChangeEvent };

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

@@ -1,18 +1,9 @@
 import * as i0 from '@angular/core';
-import { ElementRef, AfterViewInit, AfterContentInit, NgZone, QueryList } from '@angular/core';
+import { ElementRef, AfterViewInit, AfterContentInit, QueryList } from '@angular/core';
 import { ExtraOptions } from '@angular/router';
 
-declare class BsScrollOffsetService {
-    private routerConfig;
-    constructor(routerConfig: ExtraOptions);
-    getScrollOffset(): [number, number];
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollOffsetService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BsScrollOffsetService>;
-}
-
 declare class BsScrollspyDirective {
-    constructor(element: ElementRef);
-    element: ElementRef;
+    element: ElementRef<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsScrollspyDirective, "[bsScrollspy]", never, {}, {}, never, never, false, never>;
 }
@@ -20,13 +11,13 @@ declare class BsScrollspyDirective {
 declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
     private scrollOffsetService;
     private zone;
-    constructor(scrollOffsetService: BsScrollOffsetService, document: any, zone: NgZone);
-    private viewInit$;
-    private contentInit$;
+    doc: Document;
+    private viewInit;
+    private contentInit;
     directives: QueryList<BsScrollspyDirective>;
     anchors: QueryList<ElementRef<HTMLSpanElement>>;
-    doc: Document;
     activeDirective: BsScrollspyDirective | null;
+    constructor();
     ngAfterViewInit(): void;
     ngAfterContentInit(): void;
     onWindowScroll(): void;
@@ -37,6 +28,14 @@ declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<BsScrollspyComponent, "bs-scrollspy", never, {}, {}, ["directives"], ["*"], false, 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]>;

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

@@ -1,10 +1,8 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, ElementRef, EventEmitter } from '@angular/core';
+import { ElementRef, TemplateRef } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import { BsFormComponent } from '@mintplayer/ng-bootstrap/form';
 import { HasId } from '@mintplayer/ng-bootstrap/has-id';
-import { BehaviorSubject } from 'rxjs';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+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';
@@ -15,20 +13,20 @@ 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(searchbox: BsSearchboxComponent<T, U>, template: TemplateRef<T>);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsEnterSearchTermTemplateDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsEnterSearchTermTemplateDirective<any, any>, "[bsEnterSearchTermTemplate]", never, {}, {}, never, never, false, never>;
 }
 
 declare class BsNoResultsTemplateDirective<T extends HasId<U>, U> {
-    constructor(searchbox: BsSearchboxComponent<T, U>, template: TemplateRef<T>);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsNoResultsTemplateDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsNoResultsTemplateDirective<any, any>, "[bsNoResultsTemplate]", never, {}, {}, never, never, false, never>;
 }
 
 declare class BsSuggestionTemplateDirective<TData extends HasId<U>, U> {
     private searchbox;
-    constructor(searchbox: BsSearchboxComponent<TData, U>, template: TemplateRef<BsSuggestionTemplateContext<TData, U>>);
+    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>;
@@ -40,33 +38,28 @@ declare class BsSuggestionTemplateContext<TData extends HasId<U>, U> {
 }
 
 declare class BsSearchboxComponent<T extends HasId<U>, U> {
-    constructor(bsForm: BsFormComponent, sanitizer: DomSanitizer);
-    caretUpFill?: SafeHtml;
-    caretDownFill?: SafeHtml;
+    private bsForm;
+    private sanitizer;
+    caretUpFill: i0.WritableSignal<SafeHtml | undefined>;
+    caretDownFill: i0.WritableSignal<SafeHtml | undefined>;
     colors: typeof Color;
-    isBusy$: BehaviorSubject<boolean>;
+    isBusy: i0.WritableSignal<boolean>;
     textbox: ElementRef<HTMLInputElement>;
-    private _isOpen;
-    get isOpen(): boolean;
-    set isOpen(value: boolean);
-    private _suggestions;
-    get suggestions(): T[];
-    set suggestions(value: T[]);
-    private _selectedItem?;
-    get selectedItem(): T | undefined;
-    set selectedItem(value: T | undefined);
-    selectedItemChange: EventEmitter<T | undefined>;
-    searchterm$: BehaviorSubject<string>;
-    get searchterm(): string;
-    set searchterm(value: string);
+    isOpen: i0.ModelSignal<boolean>;
+    selectedItem: i0.ModelSignal<T | undefined>;
+    searchterm: i0.ModelSignal<string>;
+    suggestions: i0.ModelSignal<T[]>;
     suggestionTemplate?: TemplateRef<BsSuggestionTemplateContext<T, U>>;
     enterSearchtermTemplate?: TemplateRef<T>;
     noResultsTemplate?: TemplateRef<T>;
-    provideSuggestions: EventEmitter<string>;
+    provideSuggestions: i0.OutputEmitterRef<string>;
+    private debouncedSearchterm;
+    private debounceTimeout;
+    constructor();
     onSearchtermChange(searchterm: string): void;
     onSuggestionClicked(suggestion: T): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSearchboxComponent<any, any>, [{ optional: true; }, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSearchboxComponent<any, any>, "bs-searchbox", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "searchterm": { "alias": "searchterm"; "required": false; }; }, { "selectedItemChange": "selectedItemChange"; "provideSuggestions": "provideSuggestions"; }, never, ["*"], false, never>;
+    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>;
 }
 
 declare class BsSearchboxModule {

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

@@ -1,46 +1,36 @@
 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;
     registerOnChange(fn: (p: any) => {}): void;
     setDisabledState(isDisabled: boolean): void;
     protected setProperty(key: string, value: any): void;
-    hostOnChange(ev: InputEvent): void;
+    hostOnChange(event: Event): void;
     hostBlur(ev: Event): void;
     value: any;
     optionMap: Map<string, any>;
@@ -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/{select2/index.d.ts → 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/{shell/index.d.ts → 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

@@ -0,0 +1,36 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, ElementRef } from '@angular/core';
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface Stroke {
+    points: Point[];
+}
+
+interface Signature {
+    strokes: Stroke[];
+}
+
+declare class BsSignaturePadComponent implements AfterViewInit {
+    signature: _angular_core.ModelSignal<Signature>;
+    width: _angular_core.InputSignal<number>;
+    height: _angular_core.InputSignal<number>;
+    classes: boolean;
+    isDrawing: boolean;
+    canvas: ElementRef<HTMLCanvasElement>;
+    context: CanvasRenderingContext2D | null;
+    ngAfterViewInit(): void;
+    minHeight: number;
+    onTouchMove(ev: TouchEvent): void;
+    onPointerStart(ev: PointerEvent): void;
+    onPointerMove(ev: PointerEvent): void;
+    onPointerEnd(ev: PointerEvent): void;
+    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 };
+export type { Point, Signature, Stroke };

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

@@ -0,0 +1,14 @@
+import * as _angular_core from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class BsSpinnerComponent {
+    colors: typeof Color;
+    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

@@ -0,0 +1,76 @@
+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';
+import * as i6 from '@mintplayer/ng-bootstrap/user-agent';
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface DragOperation {
+    operation: EDragOperation;
+    startPosition: Point;
+    sizes: number[];
+    indexBefore: number;
+    indexAfter: number;
+}
+declare enum EDragOperation {
+    none = 0,
+    resizeSplitter = 1
+}
+
+declare class BsSplitPanelComponent implements AfterViewInit {
+    private element;
+    portal?: DomPortal;
+    ngAfterViewInit(): void;
+    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 {
+    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: _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;
+    startResizeTouch(ev: TouchEvent, indexBefore: number, indexAfter: number, divider: HTMLDivElement): void;
+    private startResize;
+    onMouseMove(ev: MouseEvent): void;
+    onTouchMove(ev: TouchEvent): void;
+    onResizeMove(pt: Point): void;
+    onMouseUp(ev: MouseEvent): void;
+    onTouchEnd(ev: TouchEvent): void;
+    onResizeUp(): void;
+    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: _angular_core.ɵɵFactoryDeclaration<BsElementAtPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<BsElementAtPipe, "bsElementAt", false>;
+}
+
+declare class 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 };
+export type { Direction };

package/{sticky-footer/index.d.ts → 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>;