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

package/scheduler/index.d.ts

@@ -1 +1,231 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { QueryList, ElementRef, EventEmitter, PipeTransform } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BsCalendarMonthService } from '@mintplayer/ng-bootstrap/calendar-month';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i7 from '@angular/common';
+
+declare enum ESchedulerMode {
+    week = 0,
+    timeline = 1
+}
+
+declare enum EDragOperation {
+    none = 0,
+    createEvent = 1,
+    resizeEvent = 2,
+    moveEvent = 3
+}
+
+interface SchedulerEvent {
+    start: Date;
+    end: Date;
+    color: string;
+    description: string;
+}
+
+interface DragOperation {
+    operation: EDragOperation;
+    event: SchedulerEvent;
+    meta: any;
+}
+
+interface PreviewEvent {
+    start: Date;
+    end: Date;
+}
+
+interface SchedulerEventPart {
+    start: Date;
+    end: Date;
+    event: SchedulerEvent | null;
+}
+
+interface SchedulerEventWithParts {
+    event: SchedulerEvent;
+    parts: SchedulerEventPart[];
+}
+
+interface TimeSlot {
+    start: Date;
+    end: Date;
+}
+
+interface TimelineTrack {
+    index: number;
+    events: SchedulerEvent[];
+}
+
+declare class BsTimelineService {
+    splitInParts(event: SchedulerEvent | PreviewEvent): SchedulerEventWithParts;
+    private dateEquals;
+    getTimeline(events: SchedulerEvent[]): TimelineTrack[];
+    private getTimestamps;
+    private trackIsFreeAt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTimelineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsTimelineService>;
+}
+
+interface Resource {
+    description: string;
+    events: SchedulerEvent[];
+}
+
+interface ResourceGroup {
+    description: string;
+    children: (ResourceGroup | Resource)[];
+}
+
+interface SchedulerStampWithSlots {
+    /** Some meta information, eg. the date or time that all timeslots have in common. */
+    stamp: Date;
+    slots: TimeSlot[];
+}
+
+interface WeekOptions {
+    unitHeight: number;
+}
+
+interface TimelineOptions {
+    unitWidth: number;
+}
+
+declare class BsSchedulerComponent {
+    private sanitizer;
+    private calendarMonthService;
+    private timelineService;
+    constructor(sanitizer: DomSanitizer, calendarMonthService: BsCalendarMonthService, timelineService: BsTimelineService);
+    chevronLeft?: SafeHtml;
+    chevronRight?: SafeHtml;
+    resources$: BehaviorSubject<(Resource | ResourceGroup)[]>;
+    events$: Observable<SchedulerEvent[]>;
+    eventParts$: Observable<SchedulerEventWithParts[]>;
+    eventPartsForThisWeek$: Observable<SchedulerEventPart[]>;
+    timelinedEventPartsForThisWeek$: Observable<{
+        total: number;
+        parts: {
+            part: SchedulerEventPart;
+            index: number;
+        }[];
+    }>;
+    weekOptions$: BehaviorSubject<WeekOptions>;
+    timelineOptions$: BehaviorSubject<TimelineOptions>;
+    previewEvent$: BehaviorSubject<PreviewEvent | null>;
+    previewEventParts$: Observable<SchedulerEventWithParts | null>;
+    previewEventPartsForThisWeek$: Observable<SchedulerEventPart[]>;
+    currentWeekOrMonth$: BehaviorSubject<Date>;
+    shownDays$: Observable<Date[]>;
+    daysOfWeekWithTimestamps$: Observable<{
+        start: number;
+        end: number;
+    }>;
+    timeSlotDuration$: BehaviorSubject<number>;
+    timeSlots$: BehaviorSubject<SchedulerStampWithSlots[]>;
+    mouseState$: BehaviorSubject<boolean>;
+    hoveredTimeSlot$: BehaviorSubject<TimeSlot | null>;
+    hoveredEvent$: BehaviorSubject<SchedulerEvent | null>;
+    resourceGroupPresenterCounter: number;
+    timeSlotElements: QueryList<ElementRef<HTMLDivElement>>;
+    createTimeslot(date: Date, index: number, duration: number): TimeSlot;
+    getResourcesForGroup(resourceOrGroup: Resource | ResourceGroup): Resource[];
+    modes: typeof ESchedulerMode;
+    mode$: BehaviorSubject<ESchedulerMode>;
+    modeChange: EventEmitter<ESchedulerMode>;
+    get mode(): ESchedulerMode;
+    set mode(value: ESchedulerMode);
+    weekOptionsChange: EventEmitter<WeekOptions>;
+    get weekOptions(): WeekOptions;
+    set weekOptions(value: WeekOptions);
+    timelineOptionsChange: EventEmitter<TimelineOptions>;
+    get timelineOptions(): TimelineOptions;
+    set timelineOptions(value: TimelineOptions);
+    maxInnerHeight: number | null;
+    get resources(): (Resource | ResourceGroup)[];
+    set resources(value: (Resource | ResourceGroup)[]);
+    private addDays;
+    onPreviousWeekOrMonth(): void;
+    onNextWeekOrMonth(): void;
+    private onChangeWeekOrMonth;
+    onHoverEvent(ev: SchedulerEvent | null): void;
+    onLeaveEvent(ev: SchedulerEvent | null): void;
+    operation: DragOperation | null;
+    dragStartTimeslot: TimeSlot | null;
+    onCreateEvent(ev: MouseEvent, slot: TimeSlot): void;
+    randomColor(): string;
+    randomChannel(brightness: number): string;
+    onStartDragEvent(eventPart: SchedulerEventPart, ev: MouseEvent): void;
+    onStartResizeEvent(event: SchedulerEvent | null, position: 'top' | 'bottom'): void;
+    private getHoveredTimeslot;
+    onMousemove(ev: MouseEvent): void;
+    onMouseUp(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSchedulerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSchedulerComponent, "bs-scheduler", never, { "mode": { "alias": "mode"; "required": false; }; "weekOptions": { "alias": "weekOptions"; "required": false; }; "timelineOptions": { "alias": "timelineOptions"; "required": false; }; "maxInnerHeight": { "alias": "maxInnerHeight"; "required": false; }; "resources": { "alias": "resources"; "required": false; }; }, { "modeChange": "modeChange"; "weekOptionsChange": "weekOptionsChange"; "timelineOptionsChange": "timelineOptionsChange"; }, never, never, false, never>;
+}
+
+interface ResourceOrGroup {
+    resource: Resource | null;
+    resourceGroup: ResourceGroup | null;
+}
+
+declare class ResourceGroupPresenterComponent {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    chevronDown?: SafeHtml;
+    chevronRight?: SafeHtml;
+    level: number;
+    resourceOrGroup$: BehaviorSubject<Resource | ResourceGroup | null>;
+    timeSlots$: BehaviorSubject<SchedulerStampWithSlots[]>;
+    isExpanded$: BehaviorSubject<boolean>;
+    data$: Observable<ResourceOrGroup>;
+    colSpan$: Observable<number>;
+    get resourceOrGroup(): Resource | ResourceGroup | null;
+    set resourceGroup(value: Resource | ResourceGroup | null);
+    get timeSlots(): SchedulerStampWithSlots[];
+    set timeSlots(value: SchedulerStampWithSlots[]);
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    toggleExpanded(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceGroupPresenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceGroupPresenterComponent, "bs-resource-group-presenter", never, { "level": { "alias": "level"; "required": false; }; "resourceGroup": { "alias": "resourceGroup"; "required": false; }; "timeSlots": { "alias": "timeSlots"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface SchedulerScale {
+    time: number;
+    pixels: number;
+    markerSize: number;
+}
+
+declare const availableScales: SchedulerScale[];
+
+declare class BsSecondsTimespanPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSecondsTimespanPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsSecondsTimespanPipe, "bsSecondsTimespan", false>;
+}
+
+declare class BsSecondsTodayOffsetPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSecondsTodayOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsSecondsTodayOffsetPipe, "bsSecondsTodayOffset", false>;
+}
+
+declare class DateOffsetPipe implements PipeTransform {
+    transform(value: SchedulerEventPart): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateOffsetPipe, "dateOffset", false>;
+}
+
+declare class DayOfWeekPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayOfWeekPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DayOfWeekPipe, "dayOfWeek", false>;
+}
+
+declare class BsSchedulerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSchedulerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSchedulerModule, [typeof BsSchedulerComponent, typeof BsSecondsTimespanPipe, typeof BsSecondsTodayOffsetPipe, typeof DateOffsetPipe, typeof DayOfWeekPipe, typeof ResourceGroupPresenterComponent], [typeof i7.CommonModule], [typeof BsSchedulerComponent, typeof ResourceGroupPresenterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSchedulerModule>;
+}
+
+export { BsSchedulerComponent, BsSchedulerModule, ESchedulerMode, ResourceGroupPresenterComponent, availableScales };
+export type { Resource, ResourceGroup, SchedulerEvent, TimelineOptions, WeekOptions };

package/scrollspy/index.d.ts

@@ -1 +1,46 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, AfterContentInit, NgZone, QueryList } from '@angular/core';
+import { ExtraOptions } from '@angular/router';
+
+declare class BsScrollOffsetService {
+    private routerConfig;
+    constructor(routerConfig: ExtraOptions);
+    getScrollOffset(): [number, number];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollOffsetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsScrollOffsetService>;
+}
+
+declare class BsScrollspyDirective {
+    constructor(element: ElementRef);
+    element: ElementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsScrollspyDirective, "[bsScrollspy]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
+    private scrollOffsetService;
+    private zone;
+    constructor(scrollOffsetService: BsScrollOffsetService, document: any, zone: NgZone);
+    private viewInit$;
+    private contentInit$;
+    directives: QueryList<BsScrollspyDirective>;
+    anchors: QueryList<ElementRef<HTMLSpanElement>>;
+    doc: Document;
+    activeDirective: BsScrollspyDirective | null;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    onWindowScroll(): void;
+    setActiveDirective(): void;
+    scrollToCurrentInSpy(): void;
+    scrollToHeader(directive: BsScrollspyDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsScrollspyComponent, "bs-scrollspy", never, {}, {}, ["directives"], ["*"], false, never>;
+}
+
+declare class BsScrollspyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsScrollspyModule, [typeof BsScrollspyComponent, typeof BsScrollspyDirective], never, [typeof BsScrollspyComponent, typeof BsScrollspyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsScrollspyModule>;
+}
+
+export { BsScrollOffsetService, BsScrollspyComponent, BsScrollspyDirective, BsScrollspyModule };

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