@mintplayer/ng-bootstrap 21.5.1 → 21.7.0

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

@@ -1,16 +1,12 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef, EventEmitter } from '@angular/core';
-import * as i9 from '@angular/cdk/overlay';
+import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
 import { OverlayRef } from '@angular/cdk/overlay';
-import * as i8 from '@angular/common';
-import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsModalComponent {
-    constructor(template: TemplateRef<any>);
-    isOpen: boolean;
     template: TemplateRef<any>;
+    isOpen: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalComponent, "bs-modal-content", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalComponent, "bs-modal-content", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
@@ -21,54 +17,42 @@ declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
     overlayRef: OverlayRef;
     componentInstance?: ComponentRef<BsModalComponent>;
     template: TemplateRef<any>;
-    private _isOpen;
-    get isOpen(): boolean;
-    set isOpen(value: boolean);
-    isOpenChange: EventEmitter<boolean>;
-    closeOnEscape: boolean;
+    readonly isOpen: i0.ModelSignal<boolean>;
+    readonly closeOnEscape: i0.InputSignal<boolean>;
+    constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     onKeyDown(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHostComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalHostComponent, "bs-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalHostComponent, "bs-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, never, never, true, never>;
 }
 
 declare class BsModalDirective {
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalDirective, "[bsModal]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalDirective, "[bsModal]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalHeaderDirective {
-    headerClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalHeaderDirective, "[bsModalHeader]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalHeaderDirective, "[bsModalHeader]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalBodyDirective {
-    bodyClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalBodyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalBodyDirective, "[bsModalBody]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalBodyDirective, "[bsModalBody]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalFooterDirective {
-    footerClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalFooterDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalFooterDirective, "[bsModalFooter]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalFooterDirective, "[bsModalFooter]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsModalCloseDirective {
     private host;
-    ariaLabel: string;
     onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsModalCloseDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalCloseDirective, "[bsModalClose]", never, {}, {}, never, never, false, never>;
-}
-
-declare class BsModalModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsModalModule, [typeof BsModalHeaderDirective, typeof BsModalBodyDirective, typeof BsModalFooterDirective, typeof BsModalDirective, typeof BsModalCloseDirective, typeof BsModalComponent, typeof BsModalHostComponent], [typeof i8.NgTemplateOutlet, typeof i9.OverlayModule, typeof i10.BsHasOverlayComponent], [typeof BsModalHeaderDirective, typeof BsModalBodyDirective, typeof BsModalFooterDirective, typeof BsModalDirective, typeof BsModalCloseDirective, typeof BsModalComponent, typeof BsModalHostComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsModalModule>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalCloseDirective, "[bsModalClose]", never, {}, {}, never, never, true, never>;
 }
 
-export { BsModalBodyDirective, BsModalCloseDirective, BsModalComponent, BsModalDirective, BsModalFooterDirective, BsModalHeaderDirective, BsModalHostComponent, BsModalModule };
+export { BsModalBodyDirective, BsModalCloseDirective, BsModalComponent, BsModalDirective, BsModalFooterDirective, BsModalHeaderDirective, BsModalHostComponent };

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

@@ -1,53 +1,40 @@
 import * as i0 from '@angular/core';
 import { TemplateRef } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import * as i5 from '@angular/common';
-import * as i6 from '@angular/forms';
-import * as i7 from '@mintplayer/ng-bootstrap/dropdown';
-import * as i8 from '@mintplayer/ng-bootstrap/toggle-button';
-import * as i9 from '@mintplayer/ng-bootstrap/button-type';
-import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
-import * as i11 from '@mintplayer/ng-focus-on-load';
 
 declare class BsMultiselectComponent<T> {
     headerTemplate?: TemplateRef<any>;
     footerTemplate?: TemplateRef<any>;
     buttonTemplate?: TemplateRef<any>;
     colors: typeof Color;
-    items: T[];
-    selectedItems: T[];
-    defaultButtonTemplate: TemplateRef<any>;
+    readonly items: i0.InputSignal<T[]>;
+    readonly selectedItems: i0.ModelSignal<T[]>;
+    readonly defaultButtonTemplate: i0.Signal<TemplateRef<any>>;
     itemChange(item: T, value: boolean | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsMultiselectComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsMultiselectComponent<any>, "bs-multiselect", never, { "items": { "alias": "items"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsMultiselectComponent<any>, "bs-multiselect", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; }, { "selectedItems": "selectedItemsChange"; }, never, never, true, never>;
 }
 
 declare class BsHeaderTemplateDirective<T> {
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsHeaderTemplateDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsHeaderTemplateDirective<any>, "[bsHeaderTemplate]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsHeaderTemplateDirective<any>, "[bsHeaderTemplate]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsFooterTemplateDirective<T> {
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<BsFooterTemplateDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFooterTemplateDirective<any>, "[bsFooterTemplate]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFooterTemplateDirective<any>, "[bsFooterTemplate]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsButtonTemplateDirective<T> {
     constructor();
     static ngTemplateContextGuard<TData>(dir: BsButtonTemplateDirective<TData>, ctx: any): ctx is BsRButtonTemplateContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsButtonTemplateDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsButtonTemplateDirective<any>, "[bsButtonTemplate]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsButtonTemplateDirective<any>, "[bsButtonTemplate]", never, {}, {}, never, never, true, never>;
 }
 declare class BsRButtonTemplateContext {
     $implicit: number;
 }
 
-declare class BsMultiselectModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsMultiselectModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsMultiselectModule, [typeof BsMultiselectComponent, typeof BsHeaderTemplateDirective, typeof BsFooterTemplateDirective, typeof BsButtonTemplateDirective], [typeof i5.NgTemplateOutlet, typeof i6.FormsModule, typeof i7.BsDropdownModule, typeof i8.BsToggleButtonModule, typeof i9.BsButtonTypeDirective, typeof i10.BsHasOverlayComponent, typeof i11.FocusOnLoadDirective], [typeof BsMultiselectComponent, typeof BsHeaderTemplateDirective, typeof BsFooterTemplateDirective, typeof BsButtonTemplateDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsMultiselectModule>;
-}
-
-export { BsButtonTemplateDirective, BsFooterTemplateDirective, BsHeaderTemplateDirective, BsMultiselectComponent, BsMultiselectModule, BsRButtonTemplateContext };
+export { BsButtonTemplateDirective, BsFooterTemplateDirective, BsHeaderTemplateDirective, BsMultiselectComponent, BsRButtonTemplateContext };

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

@@ -1,20 +1,12 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, TemplateRef, OnDestroy, QueryList, AfterContentInit, AfterContentChecked, AfterViewInit } from '@angular/core';
+import { ElementRef, TemplateRef, OnDestroy, AfterContentInit, AfterContentChecked, AfterViewInit, QueryList } from '@angular/core';
 import { Color, Breakpoint } from '@mintplayer/ng-bootstrap';
-import * as i10 from '@angular/common';
-import * as i11 from '@mintplayer/ng-click-outside';
-import * as i12 from '@mintplayer/ng-bootstrap/container';
-import * as i13 from '@mintplayer/ng-bootstrap/user-agent';
-import * as i14 from '@mintplayer/ng-bootstrap/no-noscript';
-import * as i15 from '@mintplayer/ng-bootstrap/has-overlay';
-import * as i16 from '@mintplayer/ng-bootstrap/dropdown-divider';
-import * as i17 from '@mintplayer/ng-bootstrap/navbar-toggler';
 
 declare class BsNavbarComponent {
     private resizeTimeout;
     constructor();
     onWindowResize(): void;
-    nav: ElementRef;
+    readonly nav: _angular_core.Signal<ElementRef<any>>;
     autoclose: _angular_core.InputSignal<boolean>;
     expandButtonTemplate: TemplateRef<any> | null;
     isExpanded: _angular_core.WritableSignal<boolean>;
@@ -31,11 +23,16 @@ declare class BsNavbarComponent {
     navClassList: _angular_core.Signal<string[]>;
     toggleExpanded(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["bs-navbar-brand", "*"], false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; }, {}, never, ["bs-navbar-brand", "*"], true, never>;
+}
+
+declare class BsNavbarBrandComponent {
+    readonly routerLink: _angular_core.InputSignal<any[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarBrandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarBrandComponent, "bs-navbar-brand", never, { "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsNavbarNavComponent {
-    private cdr;
     bsNavbar: BsNavbarComponent;
     windowWidth: _angular_core.WritableSignal<number | null>;
     isResizing: _angular_core.WritableSignal<boolean>;
@@ -45,7 +42,7 @@ declare class BsNavbarNavComponent {
     constructor();
     onWindowResize(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarNavComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarNavComponent, "bs-navbar-nav", never, { "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarNavComponent, "bs-navbar-nav", never, { "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsNavbarDropdownComponent implements OnDestroy {
@@ -62,7 +59,7 @@ declare class BsNavbarDropdownComponent implements OnDestroy {
     private overlay?;
     private pendingShowInOverlay;
     autoclose: _angular_core.InputSignal<boolean>;
-    dropdownElement: ElementRef<HTMLDivElement>;
+    readonly dropdownElement: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     isBrowser: boolean;
     isVisible: _angular_core.WritableSignal<boolean>;
     topPos: _angular_core.WritableSignal<number | null>;
@@ -72,9 +69,9 @@ declare class BsNavbarDropdownComponent implements OnDestroy {
     ngOnDestroy(): void;
     set showInOverlay(value: boolean);
     get elementsToExclude(): HTMLElement[];
-    childDropdowns: QueryList<BsNavbarDropdownComponent>;
+    readonly childDropdowns: _angular_core.Signal<readonly BsNavbarDropdownComponent[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarDropdownComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarDropdownComponent, "bs-navbar-dropdown", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; }, {}, ["childDropdowns"], ["*"], false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarDropdownComponent, "bs-navbar-dropdown", never, { "autoclose": { "alias": "autoclose"; "required": false; "isSignal": true; }; }, {}, ["childDropdowns"], ["*"], true, never>;
 }
 
 declare class BsNavbarItemComponent implements AfterContentInit, AfterContentChecked {
@@ -86,30 +83,12 @@ declare class BsNavbarItemComponent implements AfterContentInit, AfterContentChe
     parentDropdown: any;
     hasDropdown: boolean;
     anchorTag: HTMLAnchorElement | null;
-    dropdowns: QueryList<BsNavbarDropdownComponent>;
+    readonly dropdowns: _angular_core.Signal<readonly BsNavbarDropdownComponent[]>;
     constructor();
     ngAfterContentInit(): void;
     ngAfterContentChecked(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarItemComponent, "bs-navbar-item", never, {}, {}, ["dropdowns"], ["*"], false, never>;
-}
-
-declare class DropdownToggleDirective implements AfterContentInit {
-    private elementRef;
-    private bsNavbarItem;
-    constructor(elementRef: ElementRef<HTMLAnchorElement>, bsNavbarItem: BsNavbarItemComponent, parentDropdown: BsNavbarDropdownComponent);
-    childDropdowns: QueryList<BsNavbarDropdownComponent>;
-    ngAfterContentInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownToggleDirective, [null, null, { optional: true; }]>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DropdownToggleDirective, "bs-navbar-item", never, {}, {}, ["childDropdowns"], never, false, never>;
-}
-
-declare class NavLinkDirective {
-    private elementRef;
-    constructor(elementRef: ElementRef<HTMLAnchorElement>, parentNavbar: BsNavbarComponent, parentDropdown: BsNavbarDropdownComponent);
-    cursorPointer: boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavLinkDirective, [null, { optional: true; }, { optional: true; }]>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavLinkDirective, "bs-navbar-item > li > a", never, {}, {}, never, never, false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarItemComponent, "bs-navbar-item", never, {}, {}, ["dropdowns"], ["*"], true, never>;
 }
 
 declare class BsNavbarContentDirective implements AfterViewInit, OnDestroy {
@@ -123,30 +102,36 @@ declare class BsNavbarContentDirective implements AfterViewInit, OnDestroy {
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsNavbarContentDirective, "[bsNavbarContent]", never, { "navbar": { "alias": "bsNavbarContent"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
-}
-
-declare class BsNavbarBrandComponent {
-    routerLink: any[];
-    mxAuto: boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarBrandComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsNavbarBrandComponent, "bs-navbar-brand", never, { "routerLink": { "alias": "routerLink"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsNavbarContentDirective, "[bsNavbarContent]", never, { "navbar": { "alias": "bsNavbarContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BsExpandButtonDirective {
     constructor();
     static ngTemplateContextGuard(dir: BsExpandButtonDirective, ctx: any): ctx is BsExpandButtonContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsExpandButtonDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsExpandButtonDirective, "[bsExpandButton]", never, {}, {}, never, never, false, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsExpandButtonDirective, "[bsExpandButton]", never, {}, {}, never, never, true, never>;
 }
 declare class BsExpandButtonContext {
     $implicit: boolean;
 }
 
-declare class BsNavbarModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsNavbarModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsNavbarModule, [typeof BsNavbarComponent, typeof BsNavbarNavComponent, typeof BsNavbarDropdownComponent, typeof BsNavbarItemComponent, typeof DropdownToggleDirective, typeof NavLinkDirective, typeof BsNavbarContentDirective, typeof BsNavbarBrandComponent, typeof BsExpandButtonDirective], [typeof i10.AsyncPipe, typeof i10.NgTemplateOutlet, typeof i11.ClickOutsideDirective, typeof i12.BsContainerComponent, typeof i13.BsUserAgentDirective, typeof i14.BsNoNoscriptDirective, typeof i15.BsHasOverlayComponent, typeof i16.BsDropdownDividerDirective, typeof i17.BsNavbarTogglerComponent], [typeof BsNavbarComponent, typeof BsNavbarNavComponent, typeof BsNavbarDropdownComponent, typeof BsNavbarItemComponent, typeof DropdownToggleDirective, typeof NavLinkDirective, typeof BsNavbarContentDirective, typeof BsNavbarBrandComponent, typeof BsExpandButtonDirective, typeof i16.BsDropdownDividerDirective, typeof i17.BsNavbarTogglerComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsNavbarModule>;
+declare class DropdownToggleDirective implements AfterContentInit {
+    private elementRef;
+    private bsNavbarItem;
+    childDropdowns: QueryList<BsNavbarDropdownComponent>;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DropdownToggleDirective, "bs-navbar-item", never, {}, {}, ["childDropdowns"], never, true, never>;
+}
+
+declare class NavLinkDirective {
+    private elementRef;
+    private parentNavbar;
+    private parentDropdown;
+    cursorPointer: boolean;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavLinkDirective, "bs-navbar-item > li > a", never, {}, {}, never, never, true, never>;
 }
 
-export { BsExpandButtonContext, BsExpandButtonDirective, BsNavbarBrandComponent, BsNavbarComponent, BsNavbarContentDirective, BsNavbarDropdownComponent, BsNavbarItemComponent, BsNavbarModule, BsNavbarNavComponent, DropdownToggleDirective, NavLinkDirective };
+export { BsExpandButtonContext, BsExpandButtonDirective, BsNavbarBrandComponent, BsNavbarComponent, BsNavbarContentDirective, BsNavbarDropdownComponent, BsNavbarItemComponent, BsNavbarNavComponent, DropdownToggleDirective, NavLinkDirective };

package/types/mintplayer-ng-bootstrap-navigation-lock.d.ts

@@ -1,8 +1,7 @@
+import { ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
 import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
 import { Observable } from 'rxjs';
-import * as i2 from '@angular/common';
-import * as i3 from '@angular/router';
-import { ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
 
 /**
  * Places a navigation lock on this page.
@@ -24,19 +23,13 @@ declare class BsNavigationLockDirective {
     private router;
     private route;
     private destroy;
-    canExit?: boolean | (() => boolean) | Observable<boolean>;
-    exitMessage?: string;
+    readonly canExit: i0.InputSignal<boolean | Observable<boolean> | (() => boolean) | undefined>;
+    readonly exitMessage: i0.InputSignal<string | undefined>;
     requestCanExit(): Promise<boolean>;
     onBeforeUnload(ev: BeforeUnloadEvent): Promise<string | undefined>;
     onUnload(ev: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNavigationLockDirective, "[bsNavigationLock]", ["bsNavigationLock"], { "canExit": { "alias": "canExit"; "required": false; }; "exitMessage": { "alias": "exitMessage"; "required": false; }; }, {}, never, never, false, never>;
-}
-
-declare class BsNavigationLockModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsNavigationLockModule, [typeof BsNavigationLockDirective], [typeof i2.CommonModule, typeof i3.RouterModule], [typeof BsNavigationLockDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsNavigationLockModule>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNavigationLockDirective, "[bsNavigationLock]", ["bsNavigationLock"], { "canExit": { "alias": "canExit"; "required": false; "isSignal": true; }; "exitMessage": { "alias": "exitMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -45,13 +38,13 @@ declare class BsNavigationLockModule {
  * @example
  *
  * ```ts
- * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * readonly navigationLock = viewChild.required<BsNavigationLockDirective>('navigationLock');
  * ```
  *
  * Don't forget to add the `canDeactivate: [BsNavigationLockGuard]` guard to your page route.
  */
 interface BsHasNavigationLock {
-    navigationLock: BsNavigationLockDirective;
+    navigationLock: Signal<BsNavigationLockDirective>;
 }
 
 declare class BsNavigationLockGuard {
@@ -60,5 +53,5 @@ declare class BsNavigationLockGuard {
     static ɵprov: i0.ɵɵInjectableDeclaration<BsNavigationLockGuard>;
 }
 
-export { BsNavigationLockDirective, BsNavigationLockGuard, BsNavigationLockModule };
+export { BsNavigationLockDirective, BsNavigationLockGuard };
 export type { BsHasNavigationLock };

package/types/mintplayer-ng-bootstrap-no-noscript.d.ts

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 
 declare class BsNoNoscriptDirective {
     private platformId;
-    constructor(platformId: Object);
+    constructor();
     isNoScript: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsNoNoscriptDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BsNoNoscriptDirective, "[bsNoNoscript]", never, {}, {}, never, never, true, never>;

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

@@ -1,15 +1,12 @@
 import * as _angular_core from '@angular/core';
 import { TemplateRef, AfterViewInit, OnDestroy, ComponentRef } from '@angular/core';
 import { Position } from '@mintplayer/ng-bootstrap';
-import * as i9 from '@angular/cdk/overlay';
 import { OverlayRef } from '@angular/cdk/overlay';
-import * as i8 from '@angular/common';
-import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsOffcanvasComponent {
-    private platformId;
-    constructor(contentTemplate: TemplateRef<any>, platformId: Object);
     contentTemplate: TemplateRef<any>;
+    private platformId;
+    constructor();
     position: _angular_core.WritableSignal<Position>;
     size: _angular_core.WritableSignal<number | null>;
     isVisible: _angular_core.WritableSignal<boolean>;
@@ -26,13 +23,18 @@ declare class BsOffcanvasComponent {
     backdropClick: _angular_core.OutputEmitterRef<MouseEvent>;
     onBackdropClick(ev: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsOffcanvasComponent, "bs-offcanvas-holder", never, {}, { "isVisibleChange": "isVisibleChange"; "backdropClick": "backdropClick"; }, never, never, false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsOffcanvasComponent, "bs-offcanvas-holder", never, {}, { "isVisibleChange": "isVisibleChange"; "backdropClick": "backdropClick"; }, never, never, true, never>;
 }
 
-declare class BsOffcanvasContentDirective {
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasContentDirective, "[bsOffcanvasContent]", never, {}, {}, never, never, false, never>;
+declare class OffcanvasHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasHeaderComponent, "bs-offcanvas-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class OffcanvasBodyComponent {
+    readonly noPadding: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasBodyComponent, "bs-offcanvas-body", never, { "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class BsOffcanvasHostComponent implements AfterViewInit, OnDestroy {
@@ -53,26 +55,20 @@ declare class BsOffcanvasHostComponent implements AfterViewInit, OnDestroy {
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasHostComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsOffcanvasHostComponent, "bs-offcanvas", never, { "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; }, { "isVisible": "isVisibleChange"; "size": "sizeChange"; "position": "positionChange"; "hasBackdrop": "hasBackdropChange"; "backdropClick": "backdropClick"; }, never, never, false, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsOffcanvasHostComponent, "bs-offcanvas", never, { "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; }, { "isVisible": "isVisibleChange"; "size": "sizeChange"; "position": "positionChange"; "hasBackdrop": "hasBackdropChange"; "backdropClick": "backdropClick"; }, never, never, true, never>;
 }
 
 declare class BsOffcanvasCloseDirective {
     private offcanvas;
-    ariaLabel: string;
     onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasCloseDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasCloseDirective, "[bsOffcanvasClose]", never, {}, {}, never, never, false, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasCloseDirective, "[bsOffcanvasClose]", never, {}, {}, never, never, true, never>;
 }
 
-declare class OffcanvasHeaderComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasHeaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasHeaderComponent, "bs-offcanvas-header", never, {}, {}, never, ["*"], false, never>;
-}
-
-declare class OffcanvasBodyComponent {
-    noPadding: boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OffcanvasBodyComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OffcanvasBodyComponent, "bs-offcanvas-body", never, { "noPadding": { "alias": "noPadding"; "required": false; }; }, {}, never, ["*"], false, never>;
+declare class BsOffcanvasContentDirective {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasContentDirective, "[bsOffcanvasContent]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsOffcanvasPushDirective {
@@ -82,13 +78,7 @@ declare class BsOffcanvasPushDirective {
     private initialOverflowX?;
     offcanvas: _angular_core.InputSignal<BsOffcanvasHostComponent | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasPushDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasPushDirective, "[bsOffcanvasPush]", never, { "offcanvas": { "alias": "bsOffcanvasPush"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
-}
-
-declare class BsOffcanvasModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsOffcanvasModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsOffcanvasModule, [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective], [typeof i8.AsyncPipe, typeof i8.NgTemplateOutlet, typeof i9.OverlayModule, typeof i10.BsHasOverlayComponent], [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsOffcanvasModule>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsOffcanvasPushDirective, "[bsOffcanvasPush]", never, { "offcanvas": { "alias": "bsOffcanvasPush"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { BsOffcanvasCloseDirective, BsOffcanvasComponent, BsOffcanvasContentDirective, BsOffcanvasHostComponent, BsOffcanvasModule, BsOffcanvasPushDirective, OffcanvasBodyComponent, OffcanvasHeaderComponent };
+export { BsOffcanvasCloseDirective, BsOffcanvasComponent, BsOffcanvasContentDirective, BsOffcanvasHostComponent, BsOffcanvasPushDirective, OffcanvasBodyComponent, OffcanvasHeaderComponent };

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

@@ -1,27 +1,19 @@
 import * as i0 from '@angular/core';
-import * as i3 from '@angular/common';
 
 declare class BsPlaceholderComponent {
     isLoading: i0.ModelSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaceholderComponent, "bs-placeholder", never, { "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "isLoading": "isLoadingChange"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaceholderComponent, "bs-placeholder", never, { "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "isLoading": "isLoadingChange"; }, never, ["*"], true, never>;
 }
 
 declare class BsPlaceholderFieldDirective {
     private placeholder;
     constructor();
     html?: string;
-    minWidth: number;
     marginBottom: number;
     placeholderClass: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderFieldDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPlaceholderFieldDirective, "[bsPlaceholderField]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPlaceholderFieldDirective, "[bsPlaceholderField]", never, {}, {}, never, never, true, never>;
 }
 
-declare class BsPlaceholderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsPlaceholderModule, [typeof BsPlaceholderComponent, typeof BsPlaceholderFieldDirective], [typeof i3.CommonModule], [typeof BsPlaceholderComponent, typeof BsPlaceholderFieldDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsPlaceholderModule>;
-}
-
-export { BsPlaceholderComponent, BsPlaceholderFieldDirective, BsPlaceholderModule };
+export { BsPlaceholderComponent, BsPlaceholderFieldDirective };

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

@@ -1,21 +1,16 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef, AfterViewInit, OnDestroy } from '@angular/core';
 import { Position } from '@mintplayer/ng-bootstrap';
-import * as i6 from '@angular/cdk/overlay';
 import { ConnectedPosition } from '@angular/cdk/overlay';
-import * as i5 from '@angular/common';
-import * as i7 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsPopoverComponent {
-    constructor(content: TemplateRef<any>);
-    position: i0.InputSignal<Position>;
-    isVisible: i0.InputSignal<boolean>;
-    marginClass: i0.Signal<"mb-2" | "me-2" | "ms-2" | "mt-2">;
-    positionClass: i0.Signal<string>;
     template: TemplateRef<any>;
-    positionRelative: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsPopoverComponent, "bs-popover", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+    position: _angular_core.InputSignal<Position>;
+    isVisible: _angular_core.InputSignal<boolean>;
+    marginClass: _angular_core.Signal<"mb-2" | "me-2" | "ms-2" | "mt-2">;
+    positionClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsPopoverComponent, "bs-popover", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BsPopoverDirective implements AfterViewInit, OnDestroy {
@@ -24,37 +19,29 @@ declare class BsPopoverDirective implements AfterViewInit, OnDestroy {
     private parentInjector;
     private portalFactory;
     private parent;
-    bsPopover: i0.InputSignal<Position>;
-    updatePosition: i0.InputSignal<boolean>;
+    bsPopover: _angular_core.InputSignal<Position>;
+    updatePosition: _angular_core.InputSignal<boolean>;
     private localInjector;
     private portal;
     private overlayRef;
     private component;
-    isVisible: i0.WritableSignal<boolean>;
-    connectedPosition: i0.Signal<ConnectedPosition>;
+    isVisible: _angular_core.WritableSignal<boolean>;
+    connectedPosition: _angular_core.Signal<ConnectedPosition>;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverDirective, "*[bsPopover]", never, { "bsPopover": { "alias": "bsPopover"; "required": false; "isSignal": true; }; "updatePosition": { "alias": "updatePosition"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsPopoverDirective, "*[bsPopover]", never, { "bsPopover": { "alias": "bsPopover"; "required": false; "isSignal": true; }; "updatePosition": { "alias": "updatePosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BsPopoverBodyDirective {
-    bodyClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverBodyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverBodyDirective, "[bsPopoverBody]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverBodyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsPopoverBodyDirective, "[bsPopoverBody]", never, {}, {}, never, never, true, never>;
 }
 
 declare class BsPopoverHeaderDirective {
-    headerClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverHeaderDirective, "[bsPopoverHeader]", never, {}, {}, never, never, false, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsPopoverHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsPopoverHeaderDirective, "[bsPopoverHeader]", never, {}, {}, never, never, true, never>;
 }
 
-declare class BsPopoverModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsPopoverModule, [typeof BsPopoverComponent, typeof BsPopoverDirective, typeof BsPopoverHeaderDirective, typeof BsPopoverBodyDirective], [typeof i5.AsyncPipe, typeof i5.NgTemplateOutlet, typeof i6.OverlayModule, typeof i7.BsHasOverlayComponent], [typeof BsPopoverDirective, typeof BsPopoverHeaderDirective, typeof BsPopoverBodyDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsPopoverModule>;
-}
-
-export { BsPopoverBodyDirective, BsPopoverComponent, BsPopoverDirective, BsPopoverHeaderDirective, BsPopoverModule };
+export { BsPopoverBodyDirective, BsPopoverComponent, BsPopoverDirective, BsPopoverHeaderDirective };