@mintplayer/ng-bootstrap 19.0.0 → 20.0.0-preview.2

package/index.d.ts

@@ -1,3 +1,31 @@
-export * from './lib/enums';
-export * from './lib/providers';
-export * from './lib/types';
+import { InjectionToken } from '@angular/core';
+
+declare enum Color {
+    primary = 0,
+    secondary = 1,
+    success = 2,
+    danger = 3,
+    warning = 4,
+    info = 5,
+    light = 6,
+    dark = 7,
+    body = 8,
+    white = 9,
+    transparent = 10
+}
+
+/**
+ * Register this provider with a **true** value to enable Development mode for ng-bootstrap.
+ * This will make the overlays, which usually close when clicking outside of them,
+ * to stay open.
+ **/
+declare const BS_DEVELOPMENT: InjectionToken<boolean>;
+
+type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+
+type Position = 'top' | 'end' | 'bottom' | 'start';
+
+type Size = 'small' | 'medium' | 'large';
+
+export { BS_DEVELOPMENT, Color };
+export type { Breakpoint, Position, Size };

package/input-group/index.d.ts

@@ -1 +1,8 @@
-export * from './src';
+import * as i0 from '@angular/core';
+
+declare class BsInputGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInputGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsInputGroupComponent, "bs-input-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { BsInputGroupComponent };

package/instance-of/index.d.ts

@@ -1 +1,81 @@
-export * from './src';
+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>;
+}
+
+declare class BsInstanceOfContext<T = unknown> {
+    $implicit: T;
+    bsInstanceofCase: T;
+}
+
+declare class SwitchView<T = unknown> {
+    private _viewContainerRef;
+    private _templateRef;
+    private _created;
+    private _context;
+    constructor(_viewContainerRef: ViewContainerRef, _templateRef: TemplateRef<BsInstanceOfContext<T>>);
+    enforceState(result?: T): void;
+    private create;
+    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>;
+}
+
+declare class BsInstanceofCaseDirective<T> implements DoCheck {
+    private bsInstanceof;
+    bsInstanceofCase: AbstractType<T>;
+    private _view;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext<T>>, bsInstanceof: BsInstanceOfDirective);
+    /**
+     * Asserts the correct type of the context for the template that `InstanceofCaseDirective` will render.
+     *
+     * The presence of this method is a signal to the Ivy template type-check compiler that the
+     * `InstanceofCaseDirective` structural directive renders its template with a specific context type.
+     * Magic happens here!
+     */
+    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>;
+}
+
+declare class BsInstanceOfDefaultDirective {
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext>, bsInstanceof: BsInstanceOfDirective);
+    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>;
+}
+
+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>;
+}
+
+export { BsInstanceOfContext, BsInstanceOfDefaultDirective, BsInstanceOfDirective, BsInstanceOfModule, BsInstanceofCaseDirective, BsInstanceofPipe, SwitchView };
+export type { AbstractType };

package/let/index.d.ts

@@ -1,2 +1,45 @@
-export * from './directive/let.directive';
-export * from './interfaces';
+import * as i0 from '@angular/core';
+import { ViewContainerRef, TemplateRef } from '@angular/core';
+
+interface BsLetContext<T> {
+    /**
+     * using `bsLet` to enable `as` syntax: `*bsLet="foo as bar"`
+     */
+    bsLet: T;
+    /**
+     * using `$implicit` to enable `let` syntax: `*bsLet="foo; let bar"`
+     */
+    $implicit: T;
+}
+
+declare class BsLetDirective<T> {
+    private viewContainer;
+    private templateRef;
+    private context;
+    private hasView;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsLetContext<T>>);
+    set bsLet(value: T);
+    /** @internal */
+    static bsLetUseIfTypeGuard: void;
+    /**
+     * Assert the correct type of the expression bound to the `NgLet` input within the template.
+     *
+     * The presence of this static field is a signal to the Ivy template type check compiler that
+     * when the `NgLet` structural directive renders its template, the type of the expression bound
+     * to `NgLet` should be narrowed in some way. For `NgLet`, the binding expression itself is used to
+     * narrow its type, which allows the strictNullChecks feature of TypeScript to work with `NgLet`.
+     */
+    static ngTemplateGuard_bsLet: 'binding';
+    /**
+     * Asserts the correct type of the context for the template that `NgLet` will render.
+     *
+     * The presence of this method is a signal to the Ivy template type-check compiler that the
+     * `NgLet` structural directive renders its template with a specific context type.
+     */
+    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>;
+}
+
+export { BsLetDirective };
+export type { BsLetContext };

package/linify/index.d.ts

@@ -1 +1,10 @@
-export * from './src/linify.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class BsLinifyPipe implements PipeTransform {
+    transform(value: string, removeEmptyEntries?: boolean): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsLinifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsLinifyPipe, "bsLinify", true>;
+}
+
+export { BsLinifyPipe };

package/list-group/index.d.ts

@@ -1 +1,23 @@
-export * from './src';
+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>;
+}
+
+declare class BsListGroupComponent {
+    items: QueryList<BsListGroupItemComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupComponent, "bs-list-group", never, {}, {}, ["items"], ["*"], false, 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 };

package/markdown/index.d.ts

@@ -1,4 +1,37 @@
-export * from './src/bold/bold.pipe';
-export * from './src/italic/italic.pipe';
-export * from './src/strikethrough/strikethrough.pipe';
-export * from './src/underline/underline.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+declare class BsBoldPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsBoldPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsBoldPipe, "bsBold", true>;
+}
+
+declare class BsItalicPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsItalicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsItalicPipe, "bsItalic", true>;
+}
+
+declare class BsStrikethroughPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfTildes?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsStrikethroughPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsStrikethroughPipe, "bsStrikethrough", true>;
+}
+
+declare class BsUnderlinePipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsUnderlinePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsUnderlinePipe, "bsUnderline", true>;
+}
+
+export { BsBoldPipe, BsItalicPipe, BsStrikethroughPipe, BsUnderlinePipe };

package/marquee/index.d.ts

@@ -1 +1,8 @@
-export * from './src/marquee/marquee.component';
+import * as i0 from '@angular/core';
+
+declare class BsMarqueeComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsMarqueeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsMarqueeComponent, "bs-marquee", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { BsMarqueeComponent };

package/modal/index.d.ts

@@ -1 +1,76 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, Injector, ComponentFactoryResolver, ComponentRef, EventEmitter } from '@angular/core';
+import * as i9 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalComponent, "bs-modal-content", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
+    private overlay;
+    private parentInjector;
+    private portalFactory;
+    private componentFactoryResolver;
+    constructor(overlay: Overlay, parentInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<BsModalComponent>, componentFactoryResolver: ComponentFactoryResolver);
+    overlayRef: OverlayRef;
+    componentInstance?: ComponentRef<BsModalComponent>;
+    template: TemplateRef<any>;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(value: boolean);
+    isOpenChange: EventEmitter<boolean>;
+    closeOnEscape: boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private onKeyDown;
+    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>;
+}
+
+declare class BsModalDirective {
+    constructor(template: TemplateRef<any>, host: BsModalHostComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalDirective, "[bsModal]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalHeaderDirective {
+    headerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalHeaderDirective, "[bsModalHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalBodyDirective {
+    bodyClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalBodyDirective, "[bsModalBody]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalFooterDirective {
+    footerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalFooterDirective, "[bsModalFooter]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalCloseDirective {
+    private host;
+    constructor(host: BsModalHostComponent);
+    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>;
+}
+
+export { BsModalBodyDirective, BsModalCloseDirective, BsModalComponent, BsModalDirective, BsModalFooterDirective, BsModalHeaderDirective, BsModalHostComponent, BsModalModule };

package/multiselect/index.d.ts

@@ -1 +1,53 @@
-export * from './src';
+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>;
+    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>;
+}
+
+declare class BsHeaderTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsHeaderTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsHeaderTemplateDirective<any>, "[bsHeaderTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsFooterTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFooterTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFooterTemplateDirective<any>, "[bsFooterTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsButtonTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    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>;
+}
+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 };

package/navbar/index.d.ts

@@ -1 +1,153 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, AfterContentChecked, DestroyRef, QueryList, Injector, AfterContentInit, AfterViewInit, OnDestroy } from '@angular/core';
+import { Color, Breakpoint } from '@mintplayer/ng-bootstrap';
+import { Observable, BehaviorSubject } from 'rxjs';
+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 {
+    constructor();
+    onWindowResize(): void;
+    nav: ElementRef;
+    autoclose: boolean;
+    expandButtonTemplate: TemplateRef<any> | null;
+    expandClass$: Observable<string | null>;
+    wAutoClass$: Observable<string | null>;
+    dNoneClass$: Observable<string | null>;
+    isExpanded$: BehaviorSubject<boolean>;
+    windowWidth$: BehaviorSubject<number | null>;
+    isResizing$: BehaviorSubject<boolean>;
+    expandAt$: Observable<number | null>;
+    isSmallMode$: Observable<boolean>;
+    backgroundColorClass$: Observable<string[]>;
+    navClassList$: Observable<string[]>;
+    toggleExpanded(): void;
+    color$: BehaviorSubject<Color | null>;
+    get color(): Color | null;
+    set color(value: Color | null);
+    breakPoint$: BehaviorSubject<Breakpoint | null>;
+    get breakpoint(): Breakpoint | null;
+    set breakpoint(value: Breakpoint | null);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; }; "color": { "alias": "color"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, {}, never, ["bs-navbar-brand", "*"], false, never>;
+}
+
+declare class BsNavbarNavComponent {
+    constructor(bsNavbar: BsNavbarComponent);
+    bsNavbar: BsNavbarComponent;
+    collapse$: BehaviorSubject<boolean>;
+    windowWidth$: BehaviorSubject<number | null>;
+    showNavs$: Observable<boolean>;
+    isResizing$: BehaviorSubject<boolean>;
+    set collapse(value: boolean);
+    get collapse(): boolean;
+    onWindowResize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarNavComponent, "bs-navbar-nav", never, { "collapse": { "alias": "collapse"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsNavbarItemComponent implements AfterContentChecked {
+    private navbar;
+    private destroy;
+    private platformId;
+    constructor(navbar: BsNavbarComponent, element: ElementRef, destroy: DestroyRef, platformId: Object, parentDropdown: BsNavbarDropdownComponent);
+    element: ElementRef;
+    parentDropdown: BsNavbarDropdownComponent;
+    hasDropdown: boolean;
+    anchorTag: HTMLAnchorElement | null;
+    dropdowns: QueryList<BsNavbarDropdownComponent>;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarItemComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarItemComponent, "bs-navbar-item", never, {}, {}, ["dropdowns"], ["*"], false, never>;
+}
+
+declare class BsNavbarDropdownComponent {
+    private navbar;
+    element: ElementRef<HTMLElement>;
+    private injector;
+    private document;
+    constructor(navbar: BsNavbarComponent, parentDropdown: BsNavbarDropdownComponent, navbarItem: BsNavbarItemComponent, element: ElementRef<HTMLElement>, injector: Injector, document: Document, platformId: Object);
+    private isAttached;
+    private domPortal?;
+    private overlay?;
+    set showInOverlay(value: boolean);
+    autoclose: boolean;
+    navbarItem: BsNavbarItemComponent;
+    parentDropdown: BsNavbarDropdownComponent;
+    dropdownElement: ElementRef<HTMLDivElement>;
+    isBrowser: boolean;
+    topPos$: BehaviorSubject<number | null>;
+    maxHeight$: Observable<string | null>;
+    maxHeightOrNull$: Observable<string | null>;
+    isVisible$: BehaviorSubject<boolean>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get elementsToExclude(): HTMLElement[];
+    childDropdowns: QueryList<BsNavbarDropdownComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarDropdownComponent, [null, { optional: true; host: true; skipSelf: true; }, { host: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarDropdownComponent, "bs-navbar-dropdown", never, { "autoclose": { "alias": "autoclose"; "required": false; }; }, {}, ["childDropdowns"], ["*"], 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: i0.ɵɵFactoryDeclaration<DropdownToggleDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<NavLinkDirective, [null, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavLinkDirective, "bs-navbar-item > li > a", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsNavbarContentDirective implements AfterViewInit, OnDestroy {
+    private element;
+    private platformId;
+    constructor(element: ElementRef, platformId: any);
+    private viewInit$;
+    private navbar$;
+    resizeObserver: ResizeObserver | null;
+    initialPadding: number;
+    set navbar(value: BsNavbarComponent | undefined);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNavbarContentDirective, "[bsNavbarContent]", never, { "navbar": { "alias": "bsNavbarContent"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsNavbarBrandComponent {
+    routerLink: any[];
+    mxAuto: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarBrandComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarBrandComponent, "bs-navbar-brand", never, { "routerLink": { "alias": "routerLink"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsExpandButtonDirective {
+    constructor(navbar: BsNavbarComponent, templateRef: TemplateRef<any>);
+    static ngTemplateContextGuard(dir: BsExpandButtonDirective, ctx: any): ctx is BsExpandButtonContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsExpandButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsExpandButtonDirective, "[bsExpandButton]", never, {}, {}, never, never, false, never>;
+}
+declare class BsExpandButtonContext {
+    $implicit: boolean;
+}
+
+declare class BsNavbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarModule, never>;
+    static ɵmod: i0.ɵɵ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: i0.ɵɵInjectorDeclaration<BsNavbarModule>;
+}
+
+export { BsExpandButtonContext, BsExpandButtonDirective, BsNavbarBrandComponent, BsNavbarComponent, BsNavbarContentDirective, BsNavbarDropdownComponent, BsNavbarItemComponent, BsNavbarModule, BsNavbarNavComponent, DropdownToggleDirective, NavLinkDirective };

package/navbar-toggler/index.d.ts

@@ -1 +1,17 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+declare class BsNavbarTogglerComponent {
+    constructor();
+    state$: BehaviorSubject<boolean>;
+    stateChange: EventEmitter<boolean>;
+    get state(): boolean;
+    set state(value: boolean);
+    toggleOnClick: boolean;
+    toggleState(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarTogglerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarTogglerComponent, "bs-navbar-toggler", never, { "state": { "alias": "state"; "required": false; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+export { BsNavbarTogglerComponent };

package/navigation-lock/index.d.ts

@@ -1 +1,64 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import * as i3 from '@angular/router';
+import { Router, ActivatedRoute, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i2 from '@angular/common';
+
+/**
+ * Places a navigation lock on this page.
+ *
+ * Don't forget to add the following to your route:
+ *
+ * ```ts
+ * canDeactivate: [BsNavigationLockGuard]
+ * ```
+ *
+ * and implement the `BsHasNavigationLock` on the page:
+ *
+ * ```ts
+ * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * ```
+ *
+ **/
+declare class BsNavigationLockDirective {
+    private router;
+    private route;
+    constructor(router: Router, route: ActivatedRoute);
+    canExit?: boolean | (() => boolean) | Observable<boolean>;
+    exitMessage?: string;
+    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>;
+}
+
+/**
+ * Implement this interface on pages that use the `<... bsNavigationLock>` directive:
+ *
+ * @example
+ *
+ * ```ts
+ * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * ```
+ *
+ * Don't forget to add the `canDeactivate: [BsNavigationLockGuard]` guard to your page route.
+ */
+interface BsHasNavigationLock {
+    navigationLock: BsNavigationLockDirective;
+}
+
+declare class BsNavigationLockGuard {
+    canDeactivate(component: BsHasNavigationLock, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsNavigationLockGuard>;
+}
+
+export { BsNavigationLockDirective, BsNavigationLockGuard, BsNavigationLockModule };
+export type { BsHasNavigationLock };

package/no-noscript/index.d.ts

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