@mintplayer/ng-bootstrap 21.6.0 → 21.8.0

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

@@ -1,6 +1,5 @@
-import * as i0 from '@angular/core';
-import { AfterContentInit, TemplateRef, AfterViewInit, EventEmitter, QueryList, ElementRef, ChangeDetectorRef } from '@angular/core';
-import * as i3 from '@angular/common';
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, TemplateRef, AfterViewInit, ElementRef } from '@angular/core';
 
 type DockLayoutNode = DockSplitNode | DockStackNode;
 interface DockSplitNode {
@@ -69,12 +68,12 @@ interface DockLayoutSnapshot {
 }
 
 declare class BsDockPaneComponent implements AfterContentInit {
-    name: string;
-    title?: string;
-    template: TemplateRef<unknown>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly template: _angular_core.Signal<TemplateRef<any>>;
     ngAfterContentInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDockPaneComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsDockPaneComponent, "bs-dock-pane", never, { "name": { "alias": "name"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDockPaneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDockPaneComponent, "bs-dock-pane", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class MintDockManagerElement extends HTMLElement {
@@ -238,24 +237,18 @@ declare class MintDockManagerElement extends HTMLElement {
     private cloneLayoutNode;
     private cloneFloatingArray;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'mint-dock-manager': MintDockManagerElement;
-    }
-}
 
 declare class BsDockManagerComponent implements AfterViewInit {
-    private readonly changeDetector;
-    set layout(value: DockLayoutNode | DockLayout | null);
-    get layout(): DockLayoutSnapshot | null;
-    layoutChange: EventEmitter<DockLayoutSnapshot | null>;
-    layoutSnapshotChange: EventEmitter<DockLayoutSnapshot>;
-    layoutString: string | null;
-    panes: QueryList<BsDockPaneComponent>;
-    managerRef: ElementRef<MintDockManagerElement>;
+    readonly layout: _angular_core.InputSignal<DockLayoutNode | DockLayout | null>;
+    get layoutSnapshot(): DockLayoutSnapshot | null;
+    readonly layoutChange: _angular_core.OutputEmitterRef<DockLayoutSnapshot | null>;
+    readonly layoutSnapshotChange: _angular_core.OutputEmitterRef<DockLayoutSnapshot>;
+    layoutString: _angular_core.WritableSignal<string | null>;
+    readonly panes: _angular_core.Signal<readonly BsDockPaneComponent[]>;
+    readonly managerRef: _angular_core.Signal<ElementRef<MintDockManagerElement> | undefined>;
     protected readonly trackByPane: (_: number, pane: BsDockPaneComponent) => string;
     private _layout;
-    constructor(changeDetector: ChangeDetectorRef, documentRef: Document);
+    constructor();
     ngAfterViewInit(): void;
     captureLayout(): DockLayoutSnapshot;
     onLayoutChanged(event: Event): void;
@@ -263,15 +256,9 @@ declare class BsDockManagerComponent implements AfterViewInit {
     private ensureSnapshot;
     private stringifyLayout;
     private cloneLayout;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDockManagerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsDockManagerComponent, "bs-dock-manager", never, { "layout": { "alias": "layout"; "required": false; }; }, { "layoutChange": "layoutChange"; "layoutSnapshotChange": "layoutSnapshotChange"; }, ["panes"], never, false, never>;
-}
-
-declare class BsDockModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDockModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsDockModule, [typeof BsDockManagerComponent, typeof BsDockPaneComponent], [typeof i3.CommonModule], [typeof BsDockManagerComponent, typeof BsDockPaneComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsDockModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDockManagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDockManagerComponent, "bs-dock-manager", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; "layoutSnapshotChange": "layoutSnapshotChange"; }, ["panes"], never, true, never>;
 }
 
-export { BsDockManagerComponent, BsDockModule, BsDockPaneComponent, MintDockManagerElement };
+export { BsDockManagerComponent, BsDockPaneComponent, MintDockManagerElement };
 export type { DockFloatingPaneBounds, DockFloatingStackLayout, DockLayout, DockLayoutNode, DockLayoutSnapshot, DockSplitNode, DockStackNode };

package/types/mintplayer-ng-bootstrap-dropdown-divider.d.ts

@@ -1,7 +1,6 @@
 import * as i0 from '@angular/core';
 
 declare class BsDropdownDividerDirective {
-    dropdownDividerClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownDividerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownDividerDirective, "[bsDropdownDivider]", never, {}, {}, never, never, true, never>;
 }

package/types/mintplayer-ng-bootstrap-dropdown-menu.d.ts

@@ -1,32 +1,21 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { AfterViewInit } from '@angular/core';
-import { BsDropdownDirective } from '@mintplayer/ng-bootstrap/dropdown';
-import * as i3 from '@angular/common';
-import * as i4 from '@mintplayer/ng-bootstrap/dropdown-divider';
 
 declare class BsDropdownMenuComponent implements AfterViewInit {
-    private bsDropdown?;
-    constructor(bsDropdown?: BsDropdownDirective | undefined);
-    positionRelative: boolean;
-    maxHeight: number | null;
-    dropdownWith: string | null;
+    private bsDropdown;
+    readonly maxHeight: _angular_core.InputSignal<number | null>;
+    dropdownWith: _angular_core.WritableSignal<string | null>;
     onResize(): void;
     ngAfterViewInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownMenuComponent, [{ optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsDropdownMenuComponent, "bs-dropdown-menu", never, { "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownMenuComponent, "bs-dropdown-menu", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsDropdownItemComponent {
-    isSelected: boolean;
-    disabled: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsDropdownItemComponent, "bs-dropdown-item", never, { "isSelected": { "alias": "isSelected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+    readonly isSelected: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDropdownItemComponent, "bs-dropdown-item", never, { "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class BsDropdownMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsDropdownMenuModule, [typeof BsDropdownMenuComponent, typeof BsDropdownItemComponent], [typeof i3.CommonModule, typeof i4.BsDropdownDividerDirective], [typeof BsDropdownMenuComponent, typeof BsDropdownItemComponent, typeof i4.BsDropdownDividerDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsDropdownMenuModule>;
-}
-
-export { BsDropdownItemComponent, BsDropdownMenuComponent, BsDropdownMenuModule };
+export { BsDropdownItemComponent, BsDropdownMenuComponent };

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

@@ -1,10 +1,6 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
-import * as i7 from '@mintplayer/ng-click-outside';
 import { ClickOutsideDirective } from '@mintplayer/ng-click-outside';
-import * as i4 from '@angular/common';
-import * as i5 from '@angular/cdk/overlay';
-import * as i6 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsDropdownMenuDirective extends ClickOutsideDirective {
     private dropdown;
@@ -20,40 +16,32 @@ declare class BsDropdownMenuDirective extends ClickOutsideDirective {
     clickedOutside(event: Event): void;
     onEscape(event: Event): void;
     private doClose;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownMenuDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownMenuDirective, "[bsDropdownMenu]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownMenuDirective, "[bsDropdownMenu]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsDropdownToggleDirective {
-    private dropdown;
+    dropdown: BsDropdownDirective;
     constructor(dropdown: BsDropdownDirective, toggleButton: ElementRef);
     toggleButton: ElementRef;
-    ariaHasPopup: string;
-    get ariaExpanded(): boolean;
     onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownToggleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownToggleDirective, "[bsDropdownToggle]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownToggleDirective, "[bsDropdownToggle]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsDropdownDirective {
     elementRef: ElementRef<HTMLElement>;
     private bsDevelopment;
-    menu: BsDropdownMenuDirective;
-    toggle: BsDropdownToggleDirective | null;
-    hasBackdrop: i0.InputSignal<boolean>;
-    sameWidth: i0.InputSignal<boolean>;
-    closeOnClickOutside: i0.InputSignal<boolean>;
-    sameDropdownWidth: i0.InputSignal<boolean>;
-    isOpen: i0.ModelSignal<boolean>;
+    readonly menu: _angular_core.Signal<BsDropdownMenuDirective>;
+    readonly toggle: _angular_core.Signal<BsDropdownToggleDirective | undefined>;
+    hasBackdrop: _angular_core.InputSignal<boolean>;
+    sameWidth: _angular_core.InputSignal<boolean>;
+    closeOnClickOutside: _angular_core.InputSignal<boolean>;
+    sameDropdownWidth: _angular_core.InputSignal<boolean>;
+    isOpen: _angular_core.ModelSignal<boolean>;
     onBlur(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsDropdownDirective, "[bsDropdown]", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "sameWidth": { "alias": "sameWidth"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "sameDropdownWidth": { "alias": "sameDropdownWidth"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, ["menu", "toggle"], never, false, never>;
-}
-
-declare class BsDropdownModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsDropdownModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsDropdownModule, [typeof BsDropdownDirective, typeof BsDropdownToggleDirective, typeof BsDropdownMenuDirective], [typeof i4.CommonModule, typeof i5.OverlayModule, typeof i6.BsHasOverlayComponent, typeof i7.ClickOutsideDirective], [typeof BsDropdownDirective, typeof BsDropdownToggleDirective, typeof BsDropdownMenuDirective, typeof i6.BsHasOverlayComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsDropdownModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDropdownDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsDropdownDirective, "[bsDropdown]", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "sameWidth": { "alias": "sameWidth"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "sameDropdownWidth": { "alias": "sameDropdownWidth"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, ["menu", "toggle"], never, true, never>;
 }
 
-export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownModule, BsDropdownToggleDirective };
+export { BsDropdownDirective, BsDropdownMenuDirective, BsDropdownToggleDirective };

package/types/mintplayer-ng-bootstrap-enhanced-paste.d.ts

@@ -1,5 +1,4 @@
 import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
 
 interface NumberOverflow {
     boundary: 'min' | 'max' | 'invalid';
@@ -10,7 +9,7 @@ interface NumberOverflow {
 declare class EnhancedPasteDirective {
     private element;
     private model;
-    numberOverflow: EventEmitter<NumberOverflow>;
+    readonly numberOverflow: i0.OutputEmitterRef<NumberOverflow>;
     onPaste(event: ClipboardEvent): void;
     filterInput(value: any, min: number, max: number): NumberOverflow | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<EnhancedPasteDirective, never>;

package/types/mintplayer-ng-bootstrap-file-upload.d.ts

@@ -1,11 +1,6 @@
-import * as i0 from '@angular/core';
-import { TemplateRef, EventEmitter, PipeTransform } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, PipeTransform } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import * as i4 from '@angular/common';
-import * as i5 from '@mintplayer/ng-bootstrap/for';
-import * as i6 from '@mintplayer/ng-bootstrap/progress-bar';
-import * as i7 from '@mintplayer/ng-bootstrap/list-group';
-import * as i8 from '@mintplayer/ng-bootstrap/button-type';
 
 interface FileUpload {
     file: File;
@@ -14,30 +9,30 @@ interface FileUpload {
 }
 
 declare class BsFileUploadComponent {
-    dropFilesCaption: string;
-    browseFilesCaption: string;
-    placeholder: string;
+    readonly dropFilesCaption: _angular_core.InputSignal<string>;
+    readonly browseFilesCaption: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
     colors: typeof Color;
-    isDraggingFile: boolean;
+    isDraggingFile: _angular_core.WritableSignal<boolean>;
     fileTemplate?: TemplateRef<FileUpload>;
-    files: FileUpload[];
-    filesDropped: EventEmitter<FileUpload[]>;
+    readonly files: _angular_core.ModelSignal<FileUpload[]>;
+    readonly filesDropped: _angular_core.OutputEmitterRef<FileUpload[]>;
     onChange(event: Event): void;
     onDragOver(event: DragEvent): void;
     onDragLeave(event: DragEvent): void;
     onDrop(event: DragEvent): void;
     private processDroppedFiles;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFileUploadComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsFileUploadComponent, "bs-file-upload", never, { "dropFilesCaption": { "alias": "dropFilesCaption"; "required": false; }; "browseFilesCaption": { "alias": "browseFilesCaption"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "files": { "alias": "files"; "required": false; }; }, { "filesDropped": "filesDropped"; }, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsFileUploadComponent, "bs-file-upload", never, { "dropFilesCaption": { "alias": "dropFilesCaption"; "required": false; "isSignal": true; }; "browseFilesCaption": { "alias": "browseFilesCaption"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "filesDropped": "filesDropped"; }, never, never, true, never>;
 }
 
 declare class BsFileUploadTemplateDirective {
     private fileUploadComponent;
     constructor();
-    set bsFileUploadTemplateOf(value: FileUpload[]);
+    readonly bsFileUploadTemplateOf: _angular_core.InputSignal<FileUpload[] | undefined>;
     static ngTemplateContextGuard(dir: BsFileUploadTemplateDirective, ctx: any): ctx is BsFileUploadTemplateContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFileUploadTemplateDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFileUploadTemplateDirective, "[bsFileUploadTemplate]", never, { "bsFileUploadTemplateOf": { "alias": "bsFileUploadTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsFileUploadTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsFileUploadTemplateDirective, "[bsFileUploadTemplate]", never, { "bsFileUploadTemplateOf": { "alias": "bsFileUploadTemplateOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsFileUploadTemplateContext {
     $implicit: FileUpload;
@@ -45,15 +40,9 @@ declare class BsFileUploadTemplateContext {
 
 declare class BsFormatBytesPipe implements PipeTransform {
     transform(value: number, decimals?: number): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormatBytesPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<BsFormatBytesPipe, "bsFormatBytes", false>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsFormatBytesPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<BsFormatBytesPipe, "bsFormatBytes", true>;
 }
 
-declare class BsFileUploadModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFileUploadModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsFileUploadModule, [typeof BsFileUploadComponent, typeof BsFileUploadTemplateDirective, typeof BsFormatBytesPipe], [typeof i4.NgTemplateOutlet, typeof i5.BsForDirective, typeof i6.BsProgressBarModule, typeof i7.BsListGroupModule, typeof i8.BsButtonTypeDirective], [typeof BsFileUploadComponent, typeof BsFileUploadTemplateDirective, typeof BsFormatBytesPipe]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsFileUploadModule>;
-}
-
-export { BsFileUploadComponent, BsFileUploadModule, BsFileUploadTemplateContext, BsFileUploadTemplateDirective, BsFormatBytesPipe };
+export { BsFileUploadComponent, BsFileUploadTemplateContext, BsFileUploadTemplateDirective, BsFormatBytesPipe };
 export type { FileUpload };

package/types/mintplayer-ng-bootstrap-floating-labels.d.ts

@@ -1,9 +1,8 @@
-import { BsFormComponent } from '@mintplayer/ng-bootstrap/form';
 import * as i0 from '@angular/core';
 
 declare class BsFloatingLabelComponent {
-    constructor(bsForm: BsFormComponent);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFloatingLabelComponent, [{ optional: true; }]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFloatingLabelComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsFloatingLabelComponent, "bs-floating-label", never, {}, {}, never, ["input", "label"], true, never>;
 }
 

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

@@ -1,13 +1,13 @@
 import * as i0 from '@angular/core';
 
 declare class BsForDirective {
-    defaultCursor: boolean;
     static counter: number;
     private target;
-    set bsFor(value: any);
+    readonly bsFor: i0.InputSignal<any>;
+    constructor();
     forValue?: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsForDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsForDirective, "label[bsFor]", never, { "bsFor": { "alias": "bsFor"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsForDirective, "label[bsFor]", never, { "bsFor": { "alias": "bsFor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { BsForDirective };

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

@@ -1,33 +1,24 @@
 import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
-import * as i4 from '@angular/common';
 
 declare class BsFormComponent {
-    action?: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    submitted: EventEmitter<Event>;
+    readonly action: i0.InputSignal<string | undefined>;
+    readonly method: i0.InputSignal<"GET" | "POST" | "PUT" | "DELETE" | undefined>;
+    readonly submitted: i0.OutputEmitterRef<Event>;
     onSubmit(ev: Event): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsFormComponent, "bs-form", never, { "action": { "alias": "action"; "required": false; }; "method": { "alias": "method"; "required": false; }; }, { "submitted": "submitted"; }, never, ["*"], false, never>;
-}
-
-declare class BsFormControlDirective {
-    constructor(form?: BsFormComponent);
-    formControlClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormControlDirective, [{ optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormControlDirective, "bs-form input:not(.no-form-control), bs-form textarea:not(.no-form-control)", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsFormComponent, "bs-form", never, { "action": { "alias": "action"; "required": false; "isSignal": true; }; "method": { "alias": "method"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, ["*"], true, never>;
 }
 
 declare class BsFormGroupDirective {
-    formGroupClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsFormGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormGroupDirective, "[bsFormGroup]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormGroupDirective, "[bsFormGroup]", never, {}, {}, never, never, true, never>;
 }
 
-declare class BsFormModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsFormModule, [typeof BsFormComponent, typeof BsFormControlDirective, typeof BsFormGroupDirective], [typeof i4.CommonModule], [typeof BsFormComponent, typeof BsFormControlDirective, typeof BsFormGroupDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsFormModule>;
+declare class BsFormControlDirective {
+    private form;
+    formControlClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormControlDirective, "bs-form input:not(.no-form-control), bs-form textarea:not(.no-form-control)", never, {}, {}, never, never, true, never>;
 }
 
-export { BsFormComponent, BsFormControlDirective, BsFormGroupDirective, BsFormModule };
+export { BsFormComponent, BsFormControlDirective, BsFormGroupDirective };

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

@@ -1,51 +1,39 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { Breakpoint } from '@mintplayer/ng-bootstrap';
-import * as i5 from '@angular/common';
-import * as i6 from '@mintplayer/ng-bootstrap/container';
 
 declare class BsGridComponent {
-    stopFullWidthAt: i0.InputSignal<Breakpoint | "never">;
-    containerClass: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsGridComponent, "bs-grid", never, { "stopFullWidthAt": { "alias": "stopFullWidthAt"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+    stopFullWidthAt: _angular_core.InputSignal<Breakpoint | "never">;
+    containerClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsGridComponent, "bs-grid", never, { "stopFullWidthAt": { "alias": "stopFullWidthAt"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsGridRowDirective {
-    rowClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridRowDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridRowDirective, "[bsRow]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsGridRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsGridRowDirective, "[bsRow]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsGridColumnDirective {
-    xxs: i0.InputSignal<number | undefined>;
-    xs: i0.InputSignal<number | undefined>;
-    sm: i0.InputSignal<number | undefined>;
-    md: i0.InputSignal<number | undefined>;
-    lg: i0.InputSignal<number | undefined>;
-    xl: i0.InputSignal<number | undefined>;
-    xxl: i0.InputSignal<number | undefined>;
-    classList: i0.Signal<string>;
-    get classBinding(): string | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridColumnDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColumnDirective, "[xxs],[xs],[sm],[md],[lg],[xl],[xxl]", never, { "xxs": { "alias": "xxs"; "required": false; "isSignal": true; }; "xs": { "alias": "xs"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "md": { "alias": "md"; "required": false; "isSignal": true; }; "lg": { "alias": "lg"; "required": false; "isSignal": true; }; "xl": { "alias": "xl"; "required": false; "isSignal": true; }; "xxl": { "alias": "xxl"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+    xxs: _angular_core.InputSignal<number | undefined>;
+    xs: _angular_core.InputSignal<number | undefined>;
+    sm: _angular_core.InputSignal<number | undefined>;
+    md: _angular_core.InputSignal<number | undefined>;
+    lg: _angular_core.InputSignal<number | undefined>;
+    xl: _angular_core.InputSignal<number | undefined>;
+    xxl: _angular_core.InputSignal<number | undefined>;
+    classList: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsGridColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsGridColumnDirective, "[xxs],[xs],[sm],[md],[lg],[xl],[xxl]", never, { "xxs": { "alias": "xxs"; "required": false; "isSignal": true; }; "xs": { "alias": "xs"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "md": { "alias": "md"; "required": false; "isSignal": true; }; "lg": { "alias": "lg"; "required": false; "isSignal": true; }; "xl": { "alias": "xl"; "required": false; "isSignal": true; }; "xxl": { "alias": "xxl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class BsGridColDirective {
-    colClass: boolean;
-    set col(value: undefined);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridColDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColDirective, "[col]", never, { "col": { "alias": "col"; "required": false; }; }, {}, never, never, false, never>;
+    readonly col: _angular_core.InputSignal<undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsGridColDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsGridColDirective, "[col]", never, { "col": { "alias": "col"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BsColFormLabelDirective {
-    colFormLabelClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsColFormLabelDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsColFormLabelDirective, "[bsColFormLabel]", never, {}, {}, never, never, false, never>;
-}
-
-declare class BsGridModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsGridModule, [typeof BsGridComponent, typeof BsGridRowDirective, typeof BsGridColumnDirective, typeof BsGridColDirective, typeof BsColFormLabelDirective], [typeof i5.CommonModule, typeof i6.BsContainerComponent], [typeof BsGridComponent, typeof BsGridRowDirective, typeof BsGridColumnDirective, typeof BsGridColDirective, typeof BsColFormLabelDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsGridModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsColFormLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsColFormLabelDirective, "[bsColFormLabel]", never, {}, {}, never, never, true, never>;
 }
 
 interface BsColumnDefinition {
@@ -58,5 +46,5 @@ interface BsColumnDefinition {
     xxl?: number;
 }
 
-export { BsColFormLabelDirective, BsGridColDirective, BsGridColumnDirective, BsGridComponent, BsGridModule, BsGridRowDirective };
+export { BsColFormLabelDirective, BsGridColDirective, BsGridColumnDirective, BsGridComponent, BsGridRowDirective };
 export type { BsColumnDefinition };

package/types/mintplayer-ng-bootstrap-instance-of.d.ts

@@ -1,14 +1,5 @@
 import * as i0 from '@angular/core';
-import { PipeTransform, ViewContainerRef, TemplateRef, DoCheck } from '@angular/core';
-import * as i5 from '@angular/common';
-
-type AbstractType<T> = abstract new (...args: any[]) => T;
-
-declare class BsInstanceofPipe implements PipeTransform {
-    transform<V, R>(value: V, type: AbstractType<R>): R | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<BsInstanceofPipe, "bsInstanceof", false>;
-}
+import { ViewContainerRef, TemplateRef, DoCheck, PipeTransform } from '@angular/core';
 
 declare class BsInstanceOfContext<T = unknown> {
     $implicit: T;
@@ -26,30 +17,13 @@ declare class SwitchView<T = unknown> {
     private destroy;
 }
 
-declare class BsInstanceOfDirective {
-    private _defaultViews;
-    private _defaultUsed;
-    private _caseCount;
-    private _lastCaseCheckIndex;
-    private _lastCasesMatched;
-    private _instanceof;
-    set bsInstanceof(newValue: any);
-    /** @internal */
-    _addCase(): number;
-    /** @internal */
-    _addDefault(view: SwitchView): void;
-    /** @internal */
-    _matchCase<T>(type: AbstractType<T>): T | undefined;
-    private _updateDefaultCases;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDirective, "[bsInstanceof]", never, { "bsInstanceof": { "alias": "bsInstanceof"; "required": false; }; }, {}, never, never, false, never>;
-}
+type AbstractType<T> = abstract new (...args: any[]) => T;
 
 declare class BsInstanceofCaseDirective<T> implements DoCheck {
-    private bsInstanceof;
-    bsInstanceofCase: AbstractType<T>;
+    readonly bsInstanceofCase: i0.InputSignal<AbstractType<T>>;
     private _view;
-    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext<T>>, bsInstanceof: BsInstanceOfDirective);
+    private bsInstanceof;
+    constructor();
     /**
      * Asserts the correct type of the context for the template that `InstanceofCaseDirective` will render.
      *
@@ -60,22 +34,41 @@ declare class BsInstanceofCaseDirective<T> implements DoCheck {
     static ngTemplateContextGuard<T>(dir: BsInstanceofCaseDirective<T>, ctx: any): ctx is BsInstanceOfContext<Exclude<T, false | 0 | '' | null | undefined>>;
     ngDoCheck(): void;
     throwError(directiveName: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofCaseDirective<any>, [null, null, { optional: true; host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceofCaseDirective<any>, "[bsInstanceofCase]", never, { "bsInstanceofCase": { "alias": "bsInstanceofCase"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofCaseDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceofCaseDirective<any>, "[bsInstanceofCase]", never, { "bsInstanceofCase": { "alias": "bsInstanceofCase"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BsInstanceOfDefaultDirective {
-    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext>, bsInstanceof: BsInstanceOfDirective);
+    constructor();
     throwError(directiveName: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDefaultDirective, [null, null, { optional: true; host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDefaultDirective, "[bsInstanceofDefault]", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDefaultDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDefaultDirective, "[bsInstanceofDefault]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BsInstanceOfDirective {
+    private _defaultViews;
+    private _defaultUsed;
+    private _caseCount;
+    private _lastCaseCheckIndex;
+    private _lastCasesMatched;
+    readonly bsInstanceof: i0.InputSignal<any>;
+    constructor();
+    /** @internal */
+    _addCase(): number;
+    /** @internal */
+    _addDefault(view: SwitchView): void;
+    /** @internal */
+    _matchCase<T>(type: AbstractType<T>): T | undefined;
+    private _updateDefaultCases;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDirective, "[bsInstanceof]", never, { "bsInstanceof": { "alias": "bsInstanceof"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class BsInstanceOfModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsInstanceOfModule, [typeof BsInstanceofPipe, typeof BsInstanceOfDirective, typeof BsInstanceofCaseDirective, typeof BsInstanceOfDefaultDirective], [typeof i5.CommonModule], [typeof BsInstanceofPipe, typeof BsInstanceOfDirective, typeof BsInstanceofCaseDirective, typeof BsInstanceOfDefaultDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsInstanceOfModule>;
+declare class BsInstanceofPipe implements PipeTransform {
+    transform<V, R>(value: V, type: AbstractType<R>): R | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsInstanceofPipe, "bsInstanceof", true>;
 }
 
-export { BsInstanceOfContext, BsInstanceOfDefaultDirective, BsInstanceOfDirective, BsInstanceOfModule, BsInstanceofCaseDirective, BsInstanceofPipe, SwitchView };
+export { BsInstanceOfContext, BsInstanceOfDefaultDirective, BsInstanceOfDirective, BsInstanceofCaseDirective, BsInstanceofPipe, SwitchView };
 export type { AbstractType };

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

@@ -16,7 +16,8 @@ declare class BsLetDirective<T> {
     private templateRef;
     private context;
     private hasView;
-    set bsLet(value: T);
+    readonly bsLet: i0.InputSignal<T | undefined>;
+    constructor();
     /** @internal */
     static bsLetUseIfTypeGuard: void;
     /**
@@ -36,7 +37,7 @@ declare class BsLetDirective<T> {
      */
     static ngTemplateContextGuard<T>(dir: BsLetDirective<T>, ctx: any): ctx is BsLetContext<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsLetDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsLetDirective<any>, "[bsLet]", never, { "bsLet": { "alias": "bsLet"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsLetDirective<any>, "[bsLet]", never, { "bsLet": { "alias": "bsLet"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { BsLetDirective };

package/types/mintplayer-ng-bootstrap-list-group.d.ts

@@ -1,23 +1,14 @@
 import * as i0 from '@angular/core';
-import { QueryList } from '@angular/core';
-import * as i3 from '@angular/common';
 
 declare class BsListGroupItemComponent {
-    classes: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupItemComponent, "bs-list-group-item", never, {}, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupItemComponent, "bs-list-group-item", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class BsListGroupComponent {
-    items: QueryList<BsListGroupItemComponent>;
+    readonly items: i0.Signal<readonly BsListGroupItemComponent[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupComponent, "bs-list-group", never, {}, {}, ["items"], ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupComponent, "bs-list-group", never, {}, {}, ["items"], ["*"], true, never>;
 }
 
-declare class BsListGroupModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsListGroupModule, [typeof BsListGroupComponent, typeof BsListGroupItemComponent], [typeof i3.CommonModule], [typeof BsListGroupComponent, typeof BsListGroupItemComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsListGroupModule>;
-}
-
-export { BsListGroupComponent, BsListGroupItemComponent, BsListGroupModule };
+export { BsListGroupComponent, BsListGroupItemComponent };