@mintplayer/ng-bootstrap 18.5.0 → 20.0.0-preview.1

package/searchbox/index.d.ts

@@ -1,3 +1,78 @@
-export * from './src/searchbox.module';
-export * from './src/searchbox/searchbox.component';
-export * from './src/directives';
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, EventEmitter } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { BsFormComponent } from '@mintplayer/ng-bootstrap/form';
+import { HasId } from '@mintplayer/ng-bootstrap/has-id';
+import { BehaviorSubject } from 'rxjs';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i5 from '@angular/forms';
+import * as i6 from '@angular/common';
+import * as i7 from '@mintplayer/ng-focus-on-load';
+import * as i8 from '@mintplayer/ng-bootstrap/dropdown';
+import * as i9 from '@mintplayer/ng-bootstrap/dropdown-menu';
+import * as i10 from '@mintplayer/ng-bootstrap/button-type';
+import * as i11 from '@mintplayer/ng-bootstrap/progress-bar';
+import * as i12 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsEnterSearchTermTemplateDirective<T extends HasId<U>, U> {
+    constructor(searchbox: BsSearchboxComponent<T, U>, template: TemplateRef<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsEnterSearchTermTemplateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsEnterSearchTermTemplateDirective<any, any>, "[bsEnterSearchTermTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsNoResultsTemplateDirective<T extends HasId<U>, U> {
+    constructor(searchbox: BsSearchboxComponent<T, U>, template: TemplateRef<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNoResultsTemplateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNoResultsTemplateDirective<any, any>, "[bsNoResultsTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsSuggestionTemplateDirective<TData extends HasId<U>, U> {
+    private searchbox;
+    constructor(searchbox: BsSearchboxComponent<TData, U>, template: TemplateRef<BsSuggestionTemplateContext<TData, U>>);
+    static ngTemplateContextGuard<TData extends HasId<U>, U>(dir: BsSuggestionTemplateDirective<TData, U>, ctx: any): ctx is BsSuggestionTemplateContext<Exclude<TData, false | 0 | '' | null | undefined>, U>;
+    set bsSuggestionTemplateOf(value: TData[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BsSuggestionTemplateContext<TData extends HasId<U>, U> {
+    $implicit: TData;
+    searchbox: BsSearchboxComponent<TData, U>;
+}
+
+declare class BsSearchboxComponent<T extends HasId<U>, U> {
+    constructor(bsForm: BsFormComponent, sanitizer: DomSanitizer);
+    caretUpFill?: SafeHtml;
+    caretDownFill?: SafeHtml;
+    colors: typeof Color;
+    isBusy$: BehaviorSubject<boolean>;
+    textbox: ElementRef<HTMLInputElement>;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(value: boolean);
+    private _suggestions;
+    get suggestions(): T[];
+    set suggestions(value: T[]);
+    private _selectedItem?;
+    get selectedItem(): T | undefined;
+    set selectedItem(value: T | undefined);
+    selectedItemChange: EventEmitter<T | undefined>;
+    searchterm$: BehaviorSubject<string>;
+    get searchterm(): string;
+    set searchterm(value: string);
+    suggestionTemplate?: TemplateRef<BsSuggestionTemplateContext<T, U>>;
+    enterSearchtermTemplate?: TemplateRef<T>;
+    noResultsTemplate?: TemplateRef<T>;
+    provideSuggestions: EventEmitter<string>;
+    onSearchtermChange(searchterm: string): void;
+    onSuggestionClicked(suggestion: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSearchboxComponent<any, any>, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSearchboxComponent<any, any>, "bs-searchbox", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "searchterm": { "alias": "searchterm"; "required": false; }; }, { "selectedItemChange": "selectedItemChange"; "provideSuggestions": "provideSuggestions"; }, never, ["*"], false, never>;
+}
+
+declare class BsSearchboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSearchboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSearchboxModule, [typeof BsSearchboxComponent, typeof BsEnterSearchTermTemplateDirective, typeof BsSuggestionTemplateDirective, typeof BsNoResultsTemplateDirective], [typeof i5.FormsModule, typeof i6.AsyncPipe, typeof i6.NgTemplateOutlet, typeof i7.FocusOnLoadDirective, typeof i8.BsDropdownModule, typeof i9.BsDropdownMenuModule, typeof i10.BsButtonTypeDirective, typeof i11.BsProgressBarModule, typeof i12.BsHasOverlayComponent], [typeof BsSearchboxComponent, typeof BsEnterSearchTermTemplateDirective, typeof BsSuggestionTemplateDirective, typeof BsNoResultsTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSearchboxModule>;
+}
+
+export { BsEnterSearchTermTemplateDirective, BsNoResultsTemplateDirective, BsSearchboxComponent, BsSearchboxModule, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };

package/select/index.d.ts

@@ -1 +1,80 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { OnInit, Renderer2, ElementRef, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i3 from '@angular/common';
+
+type BsSelectSize = 'sm' | 'md' | 'lg';
+
+declare class BsSelectComponent implements OnInit {
+    private renderer;
+    constructor(renderer: Renderer2);
+    identifier: number;
+    selectBox: ElementRef<HTMLSelectElement>;
+    ngOnInit(): void;
+    size$: BehaviorSubject<BsSelectSize>;
+    get size(): BsSelectSize;
+    set size(value: BsSelectSize);
+    multiple$: BehaviorSubject<boolean>;
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    numberVisible$: BehaviorSubject<number | null>;
+    get numberVisible(): number | null;
+    set numberVisible(value: number | null);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    sizeClass$: Observable<string | null>;
+    multipleValue$: Observable<boolean | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelectComponent, "bs-select", never, { "identifier": { "alias": "identifier"; "required": false; }; "size": { "alias": "size"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "numberVisible": { "alias": "numberVisible"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsSelectValueAccessor implements ControlValueAccessor {
+    private _renderer;
+    private _elementRef;
+    private selectBox;
+    constructor(_renderer: Renderer2, _elementRef: ElementRef, selectBox: BsSelectComponent);
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    registerOnChange(fn: (p: any) => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected setProperty(key: string, value: any): void;
+    hostOnChange(ev: InputEvent): void;
+    hostBlur(ev: Event): void;
+    value: any;
+    optionMap: Map<string, any>;
+    idCounter: number;
+    private compareWithFunction;
+    set compareWith(value: (value1: any, value2: any) => boolean);
+    buildValueString(id: string | null, value: any): string;
+    extractId(valueString: string): string;
+    writeValue(value: any): void;
+    registerOption(): string;
+    getOptionId(value: any): string | null;
+    getOptionValue(valueString: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectValueAccessor, "bs-select", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BsSelectOption implements OnDestroy {
+    private element;
+    private renderer;
+    private select;
+    constructor(element: ElementRef, renderer: Renderer2, select: BsSelectValueAccessor);
+    id: string;
+    set ngValue(value: any);
+    set value(value: any);
+    setElementValue(value: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectOption, [null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSelectModule, [typeof BsSelectComponent, typeof BsSelectValueAccessor, typeof BsSelectOption], [typeof i3.CommonModule], [typeof BsSelectComponent, typeof BsSelectValueAccessor, typeof BsSelectOption]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSelectModule>;
+}
+
+export { BsSelectComponent, BsSelectModule, BsSelectOption, BsSelectValueAccessor };
+export type { BsSelectSize };

package/select2/index.d.ts

@@ -1 +1,68 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, EventEmitter } from '@angular/core';
+import { HasId } from '@mintplayer/ng-bootstrap/has-id';
+import { BehaviorSubject } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i5 from '@angular/forms';
+import * as i6 from '@mintplayer/ng-bootstrap/dropdown';
+import * as i7 from '@mintplayer/ng-bootstrap/dropdown-menu';
+import * as i8 from '@mintplayer/ng-bootstrap/has-overlay';
+import * as i9 from '@mintplayer/ng-bootstrap/in-list';
+
+declare class BsSelect2Component<T extends HasId<U>, U> {
+    isOpen: boolean;
+    suggestions$: BehaviorSubject<T[]>;
+    isLoading$: BehaviorSubject<boolean>;
+    defaultItemTemplate: TemplateRef<any>;
+    searchBox: ElementRef<HTMLInputElement>;
+    itemsBox: ElementRef<HTMLDivElement>;
+    searchterm: string;
+    suggestions: T[];
+    provideSuggestions: EventEmitter<string>;
+    selectedItems: T[];
+    isFocused: boolean;
+    private charWidth;
+    searchWidth: number;
+    itemTemplate?: TemplateRef<T>;
+    suggestionTemplate?: TemplateRef<T>;
+    onProvideSuggestions(value: string): void;
+    onSuggestionClicked(suggestion: T): void;
+    onRemoveItem(item: T, event: MouseEvent): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Component<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelect2Component<any, any>, "bs-select2", never, { "searchterm": { "alias": "searchterm"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; }, { "provideSuggestions": "provideSuggestions"; }, never, never, false, never>;
+}
+
+declare class BsItemTemplateDirective<T extends HasId<U>, U> {
+    private select2component;
+    constructor(select2component: BsSelect2Component<T, U>, templateRef: TemplateRef<T>);
+    static ngTemplateContextGuard<T extends HasId<U>, U>(dir: BsItemTemplateDirective<T, U>, ctx: any): ctx is BsItemTemplateContext<Exclude<T, false | 0 | '' | null | undefined>, U>;
+    set bsItemTemplateOf(value: T[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsItemTemplateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsItemTemplateDirective<any, any>, "[bsItemTemplate]", never, { "bsItemTemplateOf": { "alias": "bsItemTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BsItemTemplateContext<T extends HasId<U>, U> {
+    $implicit: T;
+    select2: BsSelect2Component<T, U>;
+}
+
+declare class BsSuggestionTemplateDirective<T extends HasId<U>, U> {
+    private select2component;
+    constructor(select2component: BsSelect2Component<T, U>, templateRef: TemplateRef<T>);
+    static ngTemplateContextGuard<T extends HasId<U>, U>(dir: BsSuggestionTemplateDirective<T, U>, ctx: any): ctx is BsSuggestionTemplateContext<Exclude<T, false | 0 | '' | null | undefined>, U>;
+    set bsSuggestionTemplateOf(value: T[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSuggestionTemplateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSuggestionTemplateDirective<any, any>, "[bsSuggestionTemplate]", never, { "bsSuggestionTemplateOf": { "alias": "bsSuggestionTemplateOf"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BsSuggestionTemplateContext<T extends HasId<U>, U> {
+    $implicit: T;
+    select2: BsSelect2Component<T, U>;
+}
+
+declare class BsSelect2Module {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Module, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSelect2Module, [typeof BsSelect2Component, typeof BsItemTemplateDirective, typeof BsSuggestionTemplateDirective], [typeof i4.NgTemplateOutlet, typeof i5.FormsModule, typeof i6.BsDropdownModule, typeof i7.BsDropdownMenuModule, typeof i8.BsHasOverlayComponent, typeof i9.BsInListPipe], [typeof BsSelect2Component, typeof BsItemTemplateDirective, typeof BsSuggestionTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSelect2Module>;
+}
+
+export { BsItemTemplateContext, BsItemTemplateDirective, BsSelect2Component, BsSelect2Module, BsSuggestionTemplateContext, BsSuggestionTemplateDirective };

package/shell/index.d.ts

@@ -1,4 +1,39 @@
-export * from './src/shell.module';
-export * from './src/shell/shell.component';
-export * from './src/shell-sidebar/shell-sidebar.directive';
-export * from './src/shell-state';
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Breakpoint } from '@mintplayer/ng-bootstrap';
+import * as i3 from '@angular/common';
+
+type BsShellState = 'auto' | 'show' | 'hide';
+
+declare class BsShellComponent {
+    constructor();
+    sidebarTemplate: TemplateRef<any> | null;
+    rootElement: ElementRef<HTMLDivElement>;
+    set state(value: BsShellState);
+    set breakpoint(value: Breakpoint);
+    state$: BehaviorSubject<BsShellState>;
+    breakpoint$: BehaviorSubject<Breakpoint>;
+    stateClass$: Observable<string | null>;
+    breakpointClass$: Observable<string>;
+    setSize(size: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsShellComponent, "bs-shell", never, { "state": { "alias": "state"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsShellSidebarDirective {
+    private shell;
+    private template;
+    constructor(shell: BsShellComponent, template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsShellSidebarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsShellSidebarDirective, "[bsShellSidebar]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsShellModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsShellModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsShellModule, [typeof BsShellComponent, typeof BsShellSidebarDirective], [typeof i3.CommonModule], [typeof BsShellComponent, typeof BsShellSidebarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsShellModule>;
+}
+
+export { BsShellComponent, BsShellModule, BsShellSidebarDirective };
+export type { BsShellState };

package/signature-pad/index.d.ts

@@ -1 +1,41 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { AfterViewInit, EventEmitter, ElementRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface Stroke {
+    points: Point[];
+}
+
+interface Signature {
+    strokes: Stroke[];
+}
+
+declare class BsSignaturePadComponent implements AfterViewInit {
+    constructor();
+    signature$: BehaviorSubject<Signature>;
+    signatureChange: EventEmitter<Signature>;
+    get signature(): Signature;
+    set signature(value: Signature);
+    width: number;
+    height: number;
+    classes: boolean;
+    isDrawing: boolean;
+    canvas: ElementRef<HTMLCanvasElement>;
+    context: CanvasRenderingContext2D | null;
+    ngAfterViewInit(): void;
+    minHeight: number;
+    onTouchMove(ev: TouchEvent): void;
+    onPointerStart(ev: PointerEvent): void;
+    onPointerMove(ev: PointerEvent): void;
+    onPointerEnd(ev: PointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSignaturePadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSignaturePadComponent, "bs-signature-pad", never, { "signature": { "alias": "signature"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "signatureChange": "signatureChange"; }, never, never, true, never>;
+}
+
+export { BsSignaturePadComponent };
+export type { Point, Signature, Stroke };

package/slugify/index.d.ts

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

package/spinner/index.d.ts

@@ -1 +1,22 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { Observable, BehaviorSubject } from 'rxjs';
+
+declare class BsSpinnerComponent implements OnInit {
+    constructor();
+    spinnerClass$: Observable<string>;
+    colorClass$: Observable<string>;
+    colors: typeof Color;
+    ngOnInit(): void;
+    type$: BehaviorSubject<"border" | "grow">;
+    get type(): "border" | "grow";
+    set type(value: 'border' | 'grow');
+    color$: BehaviorSubject<Color>;
+    get color(): Color;
+    set color(value: Color);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSpinnerComponent, "bs-spinner", never, { "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { BsSpinnerComponent };

package/split-string/index.d.ts

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

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 };