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

package/splitter/index.d.ts

@@ -1 +1,81 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, QueryList, PipeTransform } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i5 from '@angular/cdk/portal';
+import { DomPortal } from '@angular/cdk/portal';
+import * as i4 from '@angular/common';
+import * as i6 from '@mintplayer/ng-bootstrap/user-agent';
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface DragOperation {
+    operation: EDragOperation;
+    startPosition: Point;
+    sizes: number[];
+    indexBefore: number;
+    indexAfter: number;
+}
+declare enum EDragOperation {
+    none = 0,
+    resizeSplitter = 1
+}
+
+declare class BsSplitPanelComponent implements AfterViewInit {
+    private element;
+    constructor(element: ElementRef);
+    portal?: DomPortal;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSplitPanelComponent, "bs-split-panel", never, {}, {}, never, ["*"], false, never>;
+}
+
+type Direction = 'horizontal' | 'vertical';
+
+declare class BsSplitterComponent {
+    constructor();
+    orientation$: BehaviorSubject<Direction>;
+    get orientation(): Direction;
+    set orientation(value: Direction);
+    previewSizes$: BehaviorSubject<number[] | null>;
+    panels$: BehaviorSubject<BsSplitPanelComponent[]>;
+    set panels(value: QueryList<BsSplitPanelComponent>);
+    splitPanels: QueryList<ElementRef<HTMLDivElement>>;
+    classes: boolean;
+    directionClass$: Observable<string>;
+    splitterClass$: Observable<string>;
+    widthStyles$: Observable<string[] | null>;
+    heightStyles$: Observable<string[] | null>;
+    isResizing$: BehaviorSubject<boolean>;
+    touchedDivider$: BehaviorSubject<HTMLDivElement | null>;
+    operation: DragOperation | null;
+    computeSizes(): number[];
+    startResizeMouse(ev: MouseEvent, indexBefore: number, indexAfter: number): void;
+    startResizeTouch(ev: TouchEvent, indexBefore: number, indexAfter: number, divider: HTMLDivElement): void;
+    private startResize;
+    onMouseMove(ev: MouseEvent): void;
+    onTouchMove(ev: TouchEvent): void;
+    onResizeMove(pt: Point): void;
+    onMouseUp(ev: MouseEvent): void;
+    onTouchEnd(ev: TouchEvent): void;
+    onResizeUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSplitterComponent, "bs-splitter", never, { "orientation": { "alias": "orientation"; "required": false; }; }, {}, ["panels"], ["*"], false, never>;
+}
+
+declare class BsElementAtPipe implements PipeTransform {
+    transform(value: any[] | null | undefined, index: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsElementAtPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsElementAtPipe, "bsElementAt", false>;
+}
+
+declare class BsSplitterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSplitterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSplitterModule, [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe], [typeof i4.AsyncPipe, typeof i5.PortalModule, typeof i6.BsUserAgentDirective], [typeof BsSplitterComponent, typeof BsSplitPanelComponent, typeof BsElementAtPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSplitterModule>;
+}
+
+export { BsElementAtPipe, BsSplitPanelComponent, BsSplitterComponent, BsSplitterModule };
+export type { Direction };

package/sticky-footer/index.d.ts

@@ -1 +1,29 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { AfterViewInit, DestroyRef } from '@angular/core';
+import * as i4 from '@mintplayer/ng-swiper/observe-size';
+import { BsObserveSizeDirective } from '@mintplayer/ng-swiper/observe-size';
+import * as i3 from '@angular/common';
+
+declare class BsStickyFooterParentDirective {
+    marginBottom?: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsStickyFooterParentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsStickyFooterParentDirective, "[bsStickyFooterParent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsStickyFooterComponent implements AfterViewInit {
+    private parent;
+    private destroy;
+    constructor(parent: BsStickyFooterParentDirective, destroy: DestroyRef);
+    ngAfterViewInit(): void;
+    sizeObserver: BsObserveSizeDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsStickyFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsStickyFooterComponent, "bs-sticky-footer", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsStickyFooterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsStickyFooterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsStickyFooterModule, [typeof BsStickyFooterComponent, typeof BsStickyFooterParentDirective], [typeof i3.CommonModule, typeof i4.BsObserveSizeDirective], [typeof BsStickyFooterComponent, typeof BsStickyFooterParentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsStickyFooterModule>;
+}
+
+export { BsStickyFooterComponent, BsStickyFooterModule, BsStickyFooterParentDirective };

package/tab-control/index.d.ts

@@ -1 +1,72 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, QueryList } from '@angular/core';
+import * as i5 from '@angular/cdk/drag-drop';
+import { CdkDragStart, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i6 from '@mintplayer/ng-bootstrap/no-noscript';
+
+declare class BsTabPageHeaderDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabPageHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsTabPageHeaderDirective, "[bsTabPageHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsTabPageComponent {
+    constructor(tabControl: BsTabControlComponent, element: ElementRef<any>);
+    element: ElementRef<any>;
+    tabControl: BsTabControlComponent;
+    tabId$: BehaviorSubject<number>;
+    tabName$: Observable<string>;
+    disabled: boolean;
+    headerTemplate: BsTabPageHeaderDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTabPageComponent, "bs-tab-page", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["headerTemplate"], ["*"], false, never>;
+}
+
+type BsTabsPosition = 'top' | 'bottom';
+
+declare class BsTabControlComponent {
+    constructor(element: ElementRef<any>);
+    dBlock: boolean;
+    positionRelative: boolean;
+    set setTabPages(value: QueryList<BsTabPageComponent>);
+    border: boolean;
+    set restrictDragging(value: boolean);
+    dragBoundarySelector: string;
+    element: ElementRef<any>;
+    tabPages$: BehaviorSubject<QueryList<BsTabPageComponent> | null>;
+    activeTab$: BehaviorSubject<BsTabPageComponent | null>;
+    orderedTabPages: BsTabPageComponent[];
+    tabControlId$: BehaviorSubject<number>;
+    tabControlName$: Observable<string>;
+    topTabs$: Observable<boolean>;
+    bottomTabs$: Observable<boolean>;
+    disableDragDrop$: Observable<boolean>;
+    static tabControlCounter: number;
+    tabCounter: number;
+    selectFirstTab$: BehaviorSubject<boolean>;
+    get selectFirstTab(): boolean;
+    set selectFirstTab(value: boolean);
+    tabsPosition$: BehaviorSubject<BsTabsPosition>;
+    get tabsPosition(): BsTabsPosition;
+    set tabsPosition(value: BsTabsPosition);
+    allowDragDrop$: BehaviorSubject<boolean>;
+    get allowDragDrop(): boolean;
+    set allowDragDrop(value: boolean);
+    setActiveTab(tab: BsTabPageComponent): boolean;
+    startDragTab(ev: CdkDragStart<BsTabPageComponent>): void;
+    moveTab(ev: CdkDragDrop<QueryList<BsTabPageComponent> | null>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTabControlComponent, "bs-tab-control", never, { "border": { "alias": "border"; "required": false; }; "restrictDragging": { "alias": "restrictDragging"; "required": false; }; "selectFirstTab": { "alias": "selectFirstTab"; "required": false; }; "tabsPosition": { "alias": "tabsPosition"; "required": false; }; "allowDragDrop": { "alias": "allowDragDrop"; "required": false; }; }, {}, ["setTabPages"], ["*"], false, never>;
+}
+
+declare class BsTabControlModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTabControlModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsTabControlModule, [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective], [typeof i4.AsyncPipe, typeof i4.NgTemplateOutlet, typeof i5.DragDropModule, typeof i6.BsNoNoscriptDirective], [typeof BsTabControlComponent, typeof BsTabPageComponent, typeof BsTabPageHeaderDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsTabControlModule>;
+}
+
+export { BsTabControlComponent, BsTabControlModule, BsTabPageComponent, BsTabPageHeaderDirective };
+export type { BsTabsPosition };

package/table/index.d.ts

@@ -1 +1,18 @@
-export * from './src';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class BsTableComponent {
+    isResponsive$: BehaviorSubject<boolean>;
+    get isResponsive(): boolean;
+    set isResponsive(value: boolean);
+    striped$: BehaviorSubject<boolean>;
+    get striped(): boolean;
+    set striped(value: boolean);
+    hover$: BehaviorSubject<boolean>;
+    get hover(): boolean;
+    set hover(value: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTableComponent, "bs-table", never, { "isResponsive": { "alias": "isResponsive"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { BsTableComponent };

package/timepicker/index.d.ts

@@ -1 +1,33 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, NgZone, Renderer2, EventEmitter } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class BsTimepickerComponent {
+    private ref;
+    private zone;
+    private renderer;
+    private sanitizer;
+    constructor(ref: ChangeDetectorRef, zone: NgZone, renderer: Renderer2, sanitizer: DomSanitizer);
+    clock?: SafeHtml;
+    colors: typeof Color;
+    isOpen: boolean;
+    presetTimestamps: Date[];
+    isFocused: boolean;
+    selectAll(box: HTMLInputElement): void;
+    setNumber(event: Event, max: number, nextInput: HTMLInputElement | null): void;
+    setTime(time: Date): void;
+    private _selectedTime;
+    selectedTimeChange: EventEmitter<Date>;
+    get selectedTime(): Date;
+    set selectedTime(value: Date);
+    get hours(): number;
+    set hours(value: number);
+    get minutes(): number;
+    set minutes(value: number);
+    timesEqual(time1: Date, time2: Date): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTimepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTimepickerComponent, "bs-timepicker", never, { "selectedTime": { "alias": "selectedTime"; "required": false; }; }, { "selectedTimeChange": "selectedTimeChange"; }, never, never, true, never>;
+}
+
+export { BsTimepickerComponent };

package/toast/index.d.ts

@@ -1 +1,75 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { Injector, TemplateRef, PipeTransform } from '@angular/core';
+import * as i8 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { BehaviorSubject } from 'rxjs';
+import * as i7 from '@angular/common';
+import * as i9 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsToastComponent {
+    isVisible: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastComponent, "bs-toast", never, { "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsToastHeaderComponent {
+    toastClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastHeaderComponent, "bs-toast-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsToastBodyComponent {
+    toastClasses: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastBodyComponent, "bs-toast-body", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsToastService {
+    private overlayService;
+    private rootInjector;
+    private portalFactory;
+    constructor(overlayService: Overlay, rootInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<any>);
+    overlayRef: OverlayRef | null;
+    toasts$: BehaviorSubject<ToastItem[]>;
+    pushToast(toast: TemplateRef<any>, context?: Object): void;
+    close(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsToastService>;
+}
+interface ToastItem {
+    template: TemplateRef<any>;
+    context: Object | null;
+}
+
+declare class BsToastContainerComponent {
+    constructor(toastService: BsToastService);
+    toastService: BsToastService;
+    overflowY: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastContainerComponent, "bs-toast-container", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsToastCloseDirective {
+    private toast;
+    private toastService;
+    constructor(toast: BsToastComponent, toastService: BsToastService);
+    onClick(): void;
+    index: number | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsToastCloseDirective, "bs-close", never, { "index": { "alias": "index"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsAddPropertiesPipe implements PipeTransform {
+    transform(value: Object | null, toAdd: Object): Object;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAddPropertiesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsAddPropertiesPipe, "bsAddProperties", false>;
+}
+
+declare class BsToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsToastModule, [typeof BsToastComponent, typeof BsToastBodyComponent, typeof BsToastHeaderComponent, typeof BsToastContainerComponent, typeof BsToastCloseDirective, typeof BsAddPropertiesPipe], [typeof i7.AsyncPipe, typeof i8.OverlayModule, typeof i7.NgTemplateOutlet, typeof i9.BsHasOverlayComponent], [typeof BsToastComponent, typeof BsToastBodyComponent, typeof BsToastHeaderComponent, typeof BsToastContainerComponent, typeof BsToastCloseDirective, typeof BsAddPropertiesPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsToastModule>;
+}
+
+export { BsAddPropertiesPipe, BsToastBodyComponent, BsToastCloseDirective, BsToastComponent, BsToastContainerComponent, BsToastHeaderComponent, BsToastModule, BsToastService };

package/toggle-button/index.d.ts

@@ -1 +1,69 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { QueryList, AfterViewInit, ElementRef, EventEmitter, DestroyRef } from '@angular/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i4 from '@angular/common';
+
+declare class BsToggleButtonGroupDirective {
+    toggleButtons: QueryList<BsToggleButtonComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToggleButtonGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsToggleButtonGroupDirective, "[bsToggleButtonGroup]", ["bsToggleButtonGroup"], {}, {}, ["toggleButtons"], never, false, never>;
+}
+
+type BsCheckStyle = 'checkbox' | 'radio' | 'switch' | 'toggle_button' | 'radio_toggle_button';
+
+declare class BsToggleButtonComponent implements AfterViewInit {
+    constructor();
+    checkbox: ElementRef<HTMLInputElement>;
+    dInlineBlockClass: boolean;
+    disableAnimations: boolean;
+    mainCheckStyle$: Observable<string | null>;
+    isSwitch$: Observable<boolean>;
+    inputClass$: Observable<string>;
+    labelClass$: Observable<string>;
+    checkOrRadio$: Observable<'checkbox' | 'radio'>;
+    nameResult$: Observable<string | null>;
+    type$: BehaviorSubject<BsCheckStyle>;
+    get type(): BsCheckStyle;
+    set type(value: BsCheckStyle);
+    _isToggled: boolean | null;
+    isToggledChange: EventEmitter<boolean | null>;
+    get isToggled(): boolean | null;
+    set isToggled(value: boolean | null);
+    name$: BehaviorSubject<string | null>;
+    get name(): string | null;
+    set name(value: string | null);
+    value$: BehaviorSubject<string | null>;
+    get value(): string | null;
+    set value(value: string | null);
+    group$: BehaviorSubject<BsToggleButtonGroupDirective | null>;
+    get group(): BsToggleButtonGroupDirective | null;
+    set group(value: BsToggleButtonGroupDirective | null);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToggleButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToggleButtonComponent, "bs-toggle-button", never, { "type": { "alias": "type"; "required": false; }; "isToggled": { "alias": "isToggled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "group": { "alias": "group"; "required": false; }; }, { "isToggledChange": "isToggledChange"; }, never, ["*"], false, never>;
+}
+
+declare class BsToggleButtonValueAccessor implements ControlValueAccessor, AfterViewInit {
+    private host;
+    private destroy;
+    constructor(host: BsToggleButtonComponent, destroy: DestroyRef);
+    onValueChange?: (value: boolean | string | string[]) => void;
+    onTouched?: () => void;
+    ngAfterViewInit(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value: boolean | string | string[]): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToggleButtonValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsToggleButtonValueAccessor, "bs-toggle-button", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsToggleButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsToggleButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsToggleButtonModule, [typeof BsToggleButtonComponent, typeof BsToggleButtonValueAccessor, typeof BsToggleButtonGroupDirective], [typeof i4.CommonModule], [typeof BsToggleButtonComponent, typeof BsToggleButtonValueAccessor, typeof BsToggleButtonGroupDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsToggleButtonModule>;
+}
+
+export { BsToggleButtonComponent, BsToggleButtonGroupDirective, BsToggleButtonModule, BsToggleButtonValueAccessor };
+export type { BsCheckStyle };

package/tooltip/index.d.ts

@@ -1 +1,47 @@
-export * from './src';
+import * as i4 from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { OnDestroy, TemplateRef, Injector, ElementRef } from '@angular/core';
+import { Position } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i3 from '@angular/common';
+import * as i5 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsTooltipDirective implements OnDestroy {
+    private overlay;
+    private templateRef;
+    private parentInjector;
+    private parent;
+    constructor(overlay: Overlay, templateRef: TemplateRef<any>, parentInjector: Injector, parent: ElementRef);
+    bsTooltip: Position;
+    private injector;
+    private portal;
+    private overlayRef;
+    private onBlur;
+    showTooltip(): void;
+    hideTooltip(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTooltipDirective, [null, null, null, { host: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsTooltipDirective, "*[bsTooltip]", never, { "bsTooltip": { "alias": "bsTooltip"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsTooltipComponent {
+    constructor(content: TemplateRef<any>);
+    position$: BehaviorSubject<Position>;
+    get position(): Position;
+    set position(value: Position);
+    template: TemplateRef<any>;
+    positionClass$: Observable<string>;
+    marginClass$: Observable<string>;
+    positionRelative: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTooltipComponent, "bs-tooltip", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsTooltipModule, [typeof BsTooltipDirective, typeof BsTooltipComponent], [typeof i3.CommonModule, typeof i4.OverlayModule, typeof i5.BsHasOverlayComponent], [typeof BsTooltipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsTooltipModule>;
+}
+
+export { BsTooltipDirective, BsTooltipModule };

package/treeview/index.d.ts

@@ -1 +1,37 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i3 from '@angular/common';
+import * as i4 from '@mintplayer/ng-bootstrap/list-group';
+
+declare class BsTreeviewComponent {
+    constructor(parent: BsTreeviewComponent);
+    level$: BehaviorSubject<number>;
+    indentation$: Observable<number>;
+    isExpanded$: BehaviorSubject<boolean>;
+    isExpandedChange: EventEmitter<boolean>;
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTreeviewComponent, [{ optional: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTreeviewComponent, "bs-treeview", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; }, { "isExpandedChange": "isExpandedChange"; }, never, ["*"], false, never>;
+}
+
+declare class BsTreeviewItemComponent {
+    private sanitizer;
+    readonly parent: BsTreeviewComponent;
+    constructor(parent: BsTreeviewComponent, sanitizer: DomSanitizer);
+    childTree?: BsTreeviewComponent;
+    chevronRight?: SafeHtml;
+    onClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTreeviewItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTreeviewItemComponent, "bs-treeview-item", never, {}, {}, ["childTree"], ["*", "bs-treeview"], false, never>;
+}
+
+declare class BsTreeviewModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTreeviewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsTreeviewModule, [typeof BsTreeviewComponent, typeof BsTreeviewItemComponent], [typeof i3.CommonModule, typeof i4.BsListGroupModule], [typeof BsTreeviewComponent, typeof BsTreeviewItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsTreeviewModule>;
+}
+
+export { BsTreeviewComponent, BsTreeviewItemComponent, BsTreeviewModule };

package/trust-html/index.d.ts

@@ -1 +1,14 @@
-export * from './src/trust-html.pipe';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class BsTrustHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string): _angular_platform_browser.SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTrustHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsTrustHtmlPipe, "bsTrustHtml", true>;
+}
+
+export { BsTrustHtmlPipe };

package/typeahead/index.d.ts

@@ -1 +1,28 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, EventEmitter } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+declare class BsTypeaheadComponent {
+    isOpen: boolean;
+    suggestions$: BehaviorSubject<any[]>;
+    isLoading$: BehaviorSubject<boolean>;
+    showNoSuggestions$: Observable<boolean>;
+    textbox: ElementRef<HTMLInputElement>;
+    searchterm: string;
+    isLoadingText: string;
+    noSuggestionsText: string;
+    provideSuggestions: EventEmitter<string>;
+    suggestionSelected: EventEmitter<any>;
+    searchtermChange: EventEmitter<string>;
+    submitted: EventEmitter<string>;
+    constructor();
+    onProvideSuggestions(value: string): void;
+    set suggestions(value: any[]);
+    suggestionClicked(suggestion: any): void;
+    onSubmit(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTypeaheadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTypeaheadComponent, "bs-typeahead", never, { "searchterm": { "alias": "searchterm"; "required": false; }; "isLoadingText": { "alias": "isLoadingText"; "required": false; }; "noSuggestionsText": { "alias": "noSuggestionsText"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; }, { "provideSuggestions": "provideSuggestions"; "suggestionSelected": "suggestionSelected"; "searchtermChange": "searchtermChange"; "submitted": "submitted"; }, never, never, true, never>;
+}
+
+export { BsTypeaheadComponent };

package/uc-first/index.d.ts

@@ -1 +1,10 @@
-export * from './src/uc-first.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class BsUcFirstPipe implements PipeTransform {
+    transform(value: string, ...args: any[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsUcFirstPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsUcFirstPipe, "bsUcFirst", true>;
+}
+
+export { BsUcFirstPipe };

package/user-agent/index.d.ts

@@ -1 +1,28 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { AfterViewInit, EventEmitter } from '@angular/core';
+
+type BsWebbrowser = 'Chrome' | 'Firefox' | 'Safari' | 'Opera' | 'Edge';
+
+type BsOperatingSystem = 'Android' | 'iOS' | 'Windows';
+
+interface BsUserAgent {
+    os?: BsOperatingSystem;
+    webbrowser?: BsWebbrowser;
+}
+
+declare class BsUserAgentDirective implements AfterViewInit {
+    private platformId;
+    constructor(platformId: Object);
+    get isAndroid(): boolean;
+    get isIos(): boolean;
+    get isWindows(): boolean;
+    get browserClass(): string | null;
+    private getBrowser;
+    ngAfterViewInit(): void;
+    detected: EventEmitter<BsUserAgent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsUserAgentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsUserAgentDirective, "[bsUserAgent]", never, {}, { "detected": "detected"; }, never, never, true, never>;
+}
+
+export { BsUserAgentDirective };
+export type { BsOperatingSystem, BsUserAgent, BsWebbrowser };

package/word-count/index.d.ts

@@ -1 +1,10 @@
-export * from './src/word-count.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class BsWordCountPipe implements PipeTransform {
+    transform(value: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsWordCountPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsWordCountPipe, "bsWordCount", true>;
+}
+
+export { BsWordCountPipe };

package/accordion/src/accordion/accordion.component.d.ts

@@ -1,16 +0,0 @@
-import { QueryList } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { BsAccordionTabComponent } from '../accordion-tab/accordion-tab.component';
-import * as i0 from "@angular/core";
-export declare class BsAccordionComponent {
-    constructor();
-    tabPages: QueryList<BsAccordionTabComponent>;
-    disableAnimations: boolean;
-    highlightActiveTab: boolean;
-    accordionId$: BehaviorSubject<number>;
-    accordionName$: Observable<string>;
-    accordionTabCounter: number;
-    static accordionCounter: number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionComponent, "bs-accordion", never, { "highlightActiveTab": { "alias": "highlightActiveTab"; "required": false; }; }, {}, ["tabPages"], ["*"], false, never>;
-}

package/accordion/src/accordion-tab/accordion-tab.component.d.ts

@@ -1,20 +0,0 @@
-import { EventEmitter, QueryList } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { BsAccordionComponent } from '../accordion/accordion.component';
-import * as i0 from "@angular/core";
-export declare class BsAccordionTabComponent {
-    accordion: BsAccordionComponent;
-    accordionTabId$: BehaviorSubject<number>;
-    accordionTabName$: Observable<string>;
-    childAccordions: QueryList<BsAccordionComponent>;
-    constructor(accordion: BsAccordionComponent);
-    accordionItemClass: boolean;
-    dBlock: boolean;
-    noBorder: boolean;
-    isActiveChange: EventEmitter<boolean>;
-    private _isActive;
-    get isActive(): boolean;
-    set isActive(value: boolean);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionTabComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionTabComponent, "bs-accordion-tab", never, { "isActive": { "alias": "isActive"; "required": false; }; }, { "isActiveChange": "isActiveChange"; }, ["childAccordions"], ["bs-accordion-tab-header", "*"], false, never>;
-}

package/accordion/src/accordion-tab-header/accordion-tab-header.component.d.ts

@@ -1,9 +0,0 @@
-import { BsAccordionTabComponent } from '../accordion-tab/accordion-tab.component';
-import * as i0 from "@angular/core";
-export declare class BsAccordionTabHeaderComponent {
-    constructor(accordionTab: BsAccordionTabComponent);
-    accordionTab: BsAccordionTabComponent;
-    headerClicked(event: MouseEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionTabHeaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionTabHeaderComponent, "bs-accordion-tab-header", never, {}, {}, never, ["*"], false, never>;
-}

package/accordion/src/accordion.module.d.ts

@@ -1,11 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./accordion/accordion.component";
-import * as i2 from "./accordion-tab/accordion-tab.component";
-import * as i3 from "./accordion-tab-header/accordion-tab-header.component";
-import * as i4 from "@angular/common";
-import * as i5 from "@mintplayer/ng-bootstrap/no-noscript";
-export declare class BsAccordionModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsAccordionModule, [typeof i1.BsAccordionComponent, typeof i2.BsAccordionTabComponent, typeof i3.BsAccordionTabHeaderComponent], [typeof i4.AsyncPipe, typeof i5.BsNoNoscriptDirective], [typeof i1.BsAccordionComponent, typeof i2.BsAccordionTabComponent, typeof i3.BsAccordionTabHeaderComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsAccordionModule>;
-}