@mintplayer/ng-bootstrap 20.6.3 → 21.1.0

package/types/mintplayer-ng-bootstrap-tab-control.d.ts

@@ -0,0 +1,64 @@
+import * as _angular_core 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 * as i4 from '@angular/common';
+import * as i6 from '@mintplayer/ng-bootstrap/no-noscript';
+
+declare class BsTabPageHeaderDirective {
+    template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabPageHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsTabPageHeaderDirective, "[bsTabPageHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsTabPageComponent {
+    element: ElementRef<any>;
+    tabControl: BsTabControlComponent;
+    constructor();
+    tabId: _angular_core.WritableSignal<number>;
+    tabName: _angular_core.Signal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
+    headerTemplate: BsTabPageHeaderDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTabPageComponent, "bs-tab-page", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate"], ["*"], false, never>;
+}
+
+type BsTabsPosition = 'top' | 'bottom';
+
+declare class BsTabControlComponent {
+    element: ElementRef<any>;
+    constructor();
+    dBlock: boolean;
+    positionRelative: boolean;
+    set setTabPages(value: QueryList<BsTabPageComponent>);
+    border: _angular_core.InputSignal<boolean>;
+    restrictDragging: _angular_core.InputSignal<boolean>;
+    selectFirstTab: _angular_core.InputSignal<boolean>;
+    tabsPosition: _angular_core.InputSignal<BsTabsPosition>;
+    allowDragDrop: _angular_core.InputSignal<boolean>;
+    dragBoundarySelector: _angular_core.Signal<"ul" | "">;
+    tabPages: _angular_core.WritableSignal<QueryList<BsTabPageComponent> | null>;
+    activeTab: _angular_core.WritableSignal<BsTabPageComponent | null>;
+    orderedTabPages: BsTabPageComponent[];
+    tabControlId: _angular_core.WritableSignal<number>;
+    tabControlName: _angular_core.Signal<string>;
+    topTabs: _angular_core.Signal<boolean>;
+    bottomTabs: _angular_core.Signal<boolean>;
+    disableDragDrop: _angular_core.Signal<boolean>;
+    static tabControlCounter: number;
+    tabCounter: number;
+    setActiveTab(tab: BsTabPageComponent): boolean;
+    startDragTab(ev: CdkDragStart<BsTabPageComponent>): void;
+    moveTab(ev: CdkDragDrop<QueryList<BsTabPageComponent> | null>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTabControlComponent, "bs-tab-control", never, { "border": { "alias": "border"; "required": false; "isSignal": true; }; "restrictDragging": { "alias": "restrictDragging"; "required": false; "isSignal": true; }; "selectFirstTab": { "alias": "selectFirstTab"; "required": false; "isSignal": true; }; "tabsPosition": { "alias": "tabsPosition"; "required": false; "isSignal": true; }; "allowDragDrop": { "alias": "allowDragDrop"; "required": false; "isSignal": true; }; }, {}, ["setTabPages"], ["*"], false, never>;
+}
+
+declare class BsTabControlModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTabControlModule, never>;
+    static ɵmod: _angular_core.ɵɵ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: _angular_core.ɵɵInjectorDeclaration<BsTabControlModule>;
+}
+
+export { BsTabControlComponent, BsTabControlModule, BsTabPageComponent, BsTabPageHeaderDirective };
+export type { BsTabsPosition };

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

@@ -0,0 +1,11 @@
+import * as _angular_core from '@angular/core';
+
+declare class BsTableComponent {
+    isResponsive: _angular_core.InputSignal<boolean>;
+    striped: _angular_core.InputSignal<boolean>;
+    hover: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTableComponent, "bs-table", never, { "isResponsive": { "alias": "isResponsive"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { BsTableComponent };

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

@@ -0,0 +1,26 @@
+import * as _angular_core from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class BsTimepickerComponent {
+    private sanitizer;
+    constructor();
+    clock: _angular_core.WritableSignal<SafeHtml | undefined>;
+    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;
+    selectedTime: _angular_core.ModelSignal<Date>;
+    get hours(): number;
+    set hours(value: number);
+    get minutes(): number;
+    set minutes(value: number);
+    timesEqual(time1: Date, time2: Date): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTimepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTimepickerComponent, "bs-timepicker", never, { "selectedTime": { "alias": "selectedTime"; "required": false; "isSignal": true; }; }, { "selectedTime": "selectedTimeChange"; }, never, never, true, never>;
+}
+
+export { BsTimepickerComponent };

package/{toast/index.d.ts → types/mintplayer-ng-bootstrap-toast.d.ts}

@@ -1,16 +1,14 @@
 import * as i0 from '@angular/core';
-import { Injector, TemplateRef, PipeTransform } from '@angular/core';
+import { 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 { OverlayRef } from '@angular/cdk/overlay';
 import * as i7 from '@angular/common';
 import * as i9 from '@mintplayer/ng-bootstrap/has-overlay';
 
 declare class BsToastComponent {
-    isVisible: boolean;
+    isVisible: i0.InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastComponent, "bs-toast", never, { "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsToastComponent, "bs-toast", never, { "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }
 
 declare class BsToastHeaderComponent {
@@ -29,9 +27,8 @@ 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[]>;
+    toasts: i0.WritableSignal<ToastItem[]>;
     pushToast(toast: TemplateRef<any>, context?: Object): void;
     close(index: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastService, never>;
@@ -43,7 +40,6 @@ interface ToastItem {
 }
 
 declare class BsToastContainerComponent {
-    constructor(toastService: BsToastService);
     toastService: BsToastService;
     overflowY: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastContainerComponent, never>;
@@ -53,7 +49,6 @@ declare class BsToastContainerComponent {
 declare class BsToastCloseDirective {
     private toast;
     private toastService;
-    constructor(toast: BsToastComponent, toastService: BsToastService);
     onClick(): void;
     index: number | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsToastCloseDirective, never>;

package/types/mintplayer-ng-bootstrap-toggle-button.d.ts

@@ -0,0 +1,55 @@
+import * as _angular_core from '@angular/core';
+import { QueryList, AfterViewInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i4 from '@angular/common';
+
+declare class BsToggleButtonGroupDirective {
+    toggleButtons: QueryList<BsToggleButtonComponent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsToggleButtonGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsToggleButtonGroupDirective, "[bsToggleButtonGroup]", ["bsToggleButtonGroup"], {}, {}, ["toggleButtons"], never, false, never>;
+}
+
+type BsCheckStyle = 'checkbox' | 'radio' | 'switch' | 'toggle_button' | 'radio_toggle_button';
+
+declare class BsToggleButtonComponent implements AfterViewInit {
+    checkbox: ElementRef<HTMLInputElement>;
+    dInlineBlockClass: boolean;
+    disableAnimations: boolean;
+    type: _angular_core.InputSignal<BsCheckStyle>;
+    isToggled: _angular_core.ModelSignal<boolean | null>;
+    name: _angular_core.InputSignal<string | null>;
+    value: _angular_core.InputSignal<string | null>;
+    group: _angular_core.InputSignal<BsToggleButtonGroupDirective | null>;
+    mainCheckStyle: _angular_core.Signal<"form-check" | null>;
+    isSwitch: _angular_core.Signal<boolean>;
+    inputClass: _angular_core.Signal<"form-check-input" | "btn-check">;
+    labelClass: _angular_core.Signal<"form-check-label" | "btn btn-primary" | "btn btn-secondary">;
+    checkOrRadio: _angular_core.Signal<"checkbox" | "radio">;
+    nameResult: _angular_core.Signal<string | null>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsToggleButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsToggleButtonComponent, "bs-toggle-button", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "isToggled": { "alias": "isToggled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; }, { "isToggled": "isToggledChange"; }, never, ["*"], false, never>;
+}
+
+declare class BsToggleButtonValueAccessor implements ControlValueAccessor, AfterViewInit {
+    private host;
+    private destroy;
+    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: _angular_core.ɵɵFactoryDeclaration<BsToggleButtonValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsToggleButtonValueAccessor, "bs-toggle-button", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsToggleButtonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsToggleButtonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BsToggleButtonModule, [typeof BsToggleButtonComponent, typeof BsToggleButtonValueAccessor, typeof BsToggleButtonGroupDirective], [typeof i4.CommonModule], [typeof BsToggleButtonComponent, typeof BsToggleButtonValueAccessor, typeof BsToggleButtonGroupDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BsToggleButtonModule>;
+}
+
+export { BsToggleButtonComponent, BsToggleButtonGroupDirective, BsToggleButtonModule, BsToggleButtonValueAccessor };
+export type { BsCheckStyle };

package/{tooltip/index.d.ts → types/mintplayer-ng-bootstrap-tooltip.d.ts}

@@ -3,7 +3,6 @@ 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';
 
@@ -17,7 +16,7 @@ declare class BsTooltipDirective implements OnDestroy {
     private injector;
     private portal;
     private overlayRef;
-    private onBlur;
+    onBlur(): void;
     showTooltip(): void;
     hideTooltip(): void;
     ngOnDestroy(): void;
@@ -27,15 +26,13 @@ declare class BsTooltipDirective implements OnDestroy {
 
 declare class BsTooltipComponent {
     constructor(content: TemplateRef<any>);
-    position$: BehaviorSubject<Position>;
-    get position(): Position;
-    set position(value: Position);
+    position: i0.InputSignal<Position>;
     template: TemplateRef<any>;
-    positionClass$: Observable<string>;
-    marginClass$: Observable<string>;
+    positionClass: i0.Signal<string>;
+    marginClass: i0.Signal<"me-1" | "ms-1" | "mb-1" | "mt-1">;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTooltipComponent, "bs-tooltip", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
 }
 
 declare class BsTooltipModule {

package/{treeview/index.d.ts → types/mintplayer-ng-bootstrap-treeview.d.ts}

@@ -1,28 +1,23 @@
 import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { 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>;
+    private parent;
+    level: i0.Signal<number>;
+    indentation: i0.Signal<number>;
+    isExpanded: i0.ModelSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTreeviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsTreeviewComponent, "bs-treeview", never, { "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; }, { "isExpanded": "isExpandedChange"; }, never, ["*"], false, never>;
 }
 
 declare class BsTreeviewItemComponent {
-    private sanitizer;
     readonly parent: BsTreeviewComponent;
-    constructor(parent: BsTreeviewComponent, sanitizer: DomSanitizer);
+    private sanitizer;
     childTree?: BsTreeviewComponent;
-    chevronRight?: SafeHtml;
+    chevronRight: i0.WritableSignal<SafeHtml | undefined>;
+    constructor();
     onClick(ev: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BsTreeviewItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BsTreeviewItemComponent, "bs-treeview-item", never, {}, {}, ["childTree"], ["*", "bs-treeview"], false, never>;

package/{trust-html/index.d.ts → types/mintplayer-ng-bootstrap-trust-html.d.ts}

@@ -1,11 +1,9 @@
 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>;

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

@@ -0,0 +1,25 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class BsTypeaheadComponent {
+    isOpen: _angular_core.WritableSignal<boolean>;
+    suggestions: _angular_core.InputSignal<any[]>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    showNoSuggestions: _angular_core.Signal<boolean>;
+    textbox: ElementRef<HTMLInputElement>;
+    searchterm: _angular_core.ModelSignal<string>;
+    isLoadingText: _angular_core.InputSignal<string>;
+    noSuggestionsText: _angular_core.InputSignal<string>;
+    provideSuggestions: _angular_core.OutputEmitterRef<string>;
+    suggestionSelected: _angular_core.OutputEmitterRef<any>;
+    submitted: _angular_core.OutputEmitterRef<string>;
+    constructor();
+    onProvideSuggestions(value: string): void;
+    suggestionClicked(suggestion: any): void;
+    onSubmit(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTypeaheadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTypeaheadComponent, "bs-typeahead", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "searchterm": { "alias": "searchterm"; "required": false; "isSignal": true; }; "isLoadingText": { "alias": "isLoadingText"; "required": false; "isSignal": true; }; "noSuggestionsText": { "alias": "noSuggestionsText"; "required": false; "isSignal": true; }; }, { "searchterm": "searchtermChange"; "provideSuggestions": "provideSuggestions"; "suggestionSelected": "suggestionSelected"; "submitted": "submitted"; }, never, never, true, never>;
+}
+
+export { BsTypeaheadComponent };

package/badge/index.d.ts

@@ -1,16 +0,0 @@
-import { BehaviorSubject, Observable } from 'rxjs';
-import { Color } from '@mintplayer/ng-bootstrap';
-import * as i0 from '@angular/core';
-
-declare class BsBadgeComponent {
-    constructor();
-    colors: typeof Color;
-    type$: BehaviorSubject<Color>;
-    get type(): Color;
-    set type(value: Color);
-    colorClass$: Observable<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsBadgeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsBadgeComponent, "bs-badge", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], true, never>;
-}
-
-export { BsBadgeComponent };

package/calendar/index.d.ts

@@ -1,33 +0,0 @@
-import * as i0 from '@angular/core';
-import { DestroyRef, EventEmitter } from '@angular/core';
-import { Observable, BehaviorSubject } from 'rxjs';
-import { BsCalendarMonthService, Week, WeekDay, DateDayOfMonth } from '@mintplayer/ng-bootstrap/calendar-month';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
-
-declare class BsCalendarComponent {
-    private sanitizer;
-    private calendarMonthService;
-    private destroy;
-    constructor(sanitizer: DomSanitizer, calendarMonthService: BsCalendarMonthService, destroy: DestroyRef);
-    chevronLeft?: SafeHtml;
-    chevronRight?: SafeHtml;
-    weeks$: Observable<Week[]>;
-    shownDays$: Observable<WeekDay[]>;
-    currentMonth$: BehaviorSubject<Date>;
-    currentMonthChange: EventEmitter<Date>;
-    get currentMonth(): Date;
-    set currentMonth(value: Date);
-    selectedDate$: BehaviorSubject<Date>;
-    selectedDateChange: EventEmitter<Date>;
-    get selectedDate(): Date;
-    set selectedDate(value: Date);
-    disableDateFn?: (date: Date) => boolean;
-    previousMonth(): boolean;
-    nextMonth(): boolean;
-    isSameDate(date1: Date | null, date2: Date | null): boolean;
-    goto(day: DateDayOfMonth | null): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsCalendarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsCalendarComponent, "bs-calendar", never, { "currentMonth": { "alias": "currentMonth"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "disableDateFn": { "alias": "disableDateFn"; "required": false; }; }, { "currentMonthChange": "currentMonthChange"; "selectedDateChange": "selectedDateChange"; }, never, never, true, never>;
-}
-
-export { BsCalendarComponent };

package/carousel/index.d.ts

@@ -1,67 +0,0 @@
-import * as i0 from '@angular/core';
-import { TemplateRef, ElementRef, AfterViewInit, OnDestroy, ChangeDetectorRef, QueryList } from '@angular/core';
-import { Color } from '@mintplayer/ng-bootstrap';
-import * as i5 from '@mintplayer/ng-swiper/swiper';
-import { BsSwipeContainerDirective } from '@mintplayer/ng-swiper/swiper';
-import { BehaviorSubject, Observable } from 'rxjs';
-import * as i4 from '@angular/common';
-import * as i6 from '@mintplayer/ng-bootstrap/no-noscript';
-
-declare class BsCarouselImageDirective {
-    private templateRef;
-    private element;
-    itemTemplate: TemplateRef<any>;
-    constructor(templateRef: TemplateRef<any>, carousel: BsCarouselComponent, element: ElementRef<HTMLElement>);
-    id: number;
-    isFirst: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsCarouselImageDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsCarouselImageDirective, "*[bsCarouselImage]", never, {}, {}, never, never, false, never>;
-}
-
-declare class BsCarouselComponent implements AfterViewInit, OnDestroy {
-    private cdRef;
-    constructor(platformId: any, cdRef: ChangeDetectorRef);
-    colors: typeof Color;
-    isServerSide: boolean;
-    currentImageIndex: number;
-    images$: BehaviorSubject<QueryList<BsCarouselImageDirective> | null>;
-    imageCount$: Observable<number>;
-    firstImageTemplate$: Observable<TemplateRef<any> | null>;
-    lastImageTemplate$: Observable<TemplateRef<any> | null>;
-    resizeObserver?: ResizeObserver;
-    indicators: boolean;
-    keyboardEvents: boolean;
-    private _orientation;
-    set orientation(value: 'horizontal' | 'vertical');
-    get orientation(): "horizontal" | "vertical";
-    innerElement: ElementRef<HTMLDivElement>;
-    swipeContainer: BsSwipeContainerDirective;
-    set images(value: QueryList<BsCarouselImageDirective>);
-    animationsDisabled: boolean;
-    private _animation;
-    set animation(value: 'fade' | 'slide');
-    get animation(): "fade" | "slide";
-    onKeyPress(ev: KeyboardEvent): void;
-    previousImage(): void;
-    nextImage(): void;
-    imageCounter: number;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsCarouselComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsCarouselComponent, "bs-carousel", never, { "indicators": { "alias": "indicators"; "required": false; }; "keyboardEvents": { "alias": "keyboardEvents"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, ["images"], never, false, never>;
-}
-
-declare class BsCarouselImgDirective {
-    constructor(image: BsCarouselImageDirective);
-    fetchPriority: 'high' | 'low' | 'auto';
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsCarouselImgDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsCarouselImgDirective, "img", never, {}, {}, never, never, false, never>;
-}
-
-declare class BsCarouselModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsCarouselModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsCarouselModule, [typeof BsCarouselComponent, typeof BsCarouselImageDirective, typeof BsCarouselImgDirective], [typeof i4.AsyncPipe, typeof i4.NgTemplateOutlet, typeof i5.BsSwiperModule, typeof i6.BsNoNoscriptDirective], [typeof BsCarouselComponent, typeof BsCarouselImageDirective, typeof BsCarouselImgDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsCarouselModule>;
-}
-
-export { BsCarouselComponent, BsCarouselImageDirective, BsCarouselImgDirective, BsCarouselModule };

package/color-picker/index.d.ts

@@ -1,197 +0,0 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, ElementRef, DestroyRef, EventEmitter, NgZone } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
-import * as i8 from '@angular/forms';
-import { ControlValueAccessor } from '@angular/forms';
-import * as i7 from '@angular/common';
-
-interface HS {
-    hue: number;
-    saturation: number;
-}
-
-declare class BsColorWheelComponent implements AfterViewInit {
-    private element;
-    private destroy;
-    constructor(element: ElementRef<HTMLElement>, destroy: DestroyRef);
-    positionRelative: boolean;
-    set diameterRatio(value: number);
-    set width(value: number);
-    set height(value: number);
-    canvas: ElementRef<HTMLCanvasElement>;
-    hs$: BehaviorSubject<HS>;
-    hsChange: EventEmitter<HS>;
-    get hs(): HS;
-    set hs(value: HS);
-    luminosity$: BehaviorSubject<number>;
-    get luminosity(): number;
-    set luminosity(value: number);
-    private canvasContext;
-    private isPointerDown;
-    width$: BehaviorSubject<number>;
-    height$: BehaviorSubject<number>;
-    diameterRatio$: BehaviorSubject<number>;
-    squareSize$: Observable<number | null>;
-    shiftX$: Observable<number | null>;
-    shiftY$: Observable<number | null>;
-    innerRadius$: Observable<number | null>;
-    outerRadius$: Observable<number | null>;
-    markerPosition$: Observable<{
-        x: number;
-        y: number;
-    }>;
-    disabled$: BehaviorSubject<boolean>;
-    viewInited$: BehaviorSubject<boolean>;
-    ngAfterViewInit(): void;
-    onPointerDown(ev: MouseEvent | TouchEvent): void;
-    onPointerMove(ev: MouseEvent | TouchEvent): void;
-    onMouseMove(ev: MouseEvent): void;
-    onPointerUp(ev: MouseEvent | TouchEvent): void;
-    private updateColor;
-    private isInsideCircle;
-    private position2color;
-    private color2position;
-    private rgb2Hsl;
-    /**
-     * Divide 1 to n, handling floating point errors.
-     * Ensures that the value is in between 0 and 1.
-     **/
-    private bound01;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsColorWheelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsColorWheelComponent, "bs-color-wheel", never, { "diameterRatio": { "alias": "diameterRatio"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "hs": { "alias": "hs"; "required": false; }; "luminosity": { "alias": "luminosity"; "required": false; }; }, { "hsChange": "hsChange"; }, never, never, false, never>;
-}
-
-declare class BsColorPickerComponent {
-    constructor();
-    colorWheel: BsColorWheelComponent;
-    set size(value: number);
-    set allowAlpha(value: boolean);
-    size$: BehaviorSubject<number>;
-    disabled$: BehaviorSubject<boolean>;
-    allowAlpha$: BehaviorSubject<boolean>;
-    hs$: BehaviorSubject<HS>;
-    luminosity$: BehaviorSubject<number>;
-    alpha$: BehaviorSubject<number>;
-    alphaChange: EventEmitter<number>;
-    get alpha(): number;
-    set alpha(value: number);
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsColorPickerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsColorPickerComponent, "bs-color-picker", never, { "size": { "alias": "size"; "required": false; }; "allowAlpha": { "alias": "allowAlpha"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; }, { "alphaChange": "alphaChange"; }, never, never, false, never>;
-}
-
-interface RgbColor {
-    r: number;
-    g: number;
-    b: number;
-}
-
-declare class BsColorPickerValueAccessor implements AfterViewInit, ControlValueAccessor {
-    private host;
-    private destroy;
-    constructor(host: BsColorPickerComponent, destroy: DestroyRef);
-    ngAfterViewInit(): void;
-    hsl2rgb(h: number, s: number, l: number): RgbColor;
-    onValueChange?: (value: string) => void;
-    onTouched?: () => void;
-    registerOnChange(fn: (_: any) => void): void;
-    registerOnTouched(fn: () => void): void;
-    writeValue(value: string | null): void;
-    setDisabledState(isDisabled: boolean): void;
-    private rgb2hex;
-    private hex2rgb;
-    /**
-     * Divide 1 to n, handling floating point errors.
-     * Ensures that the value is in between 0 and 1.
-     **/
-    private bound01;
-    private rgb2Hsl;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsColorPickerValueAccessor, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsColorPickerValueAccessor, "bs-color-picker", ["bsColorPicker"], {}, {}, never, never, false, never>;
-}
-
-declare class BsLuminosityStripComponent implements AfterViewInit {
-    constructor();
-    hs$: BehaviorSubject<HS>;
-    get hs(): HS;
-    set hs(value: HS);
-    luminosity$: BehaviorSubject<number>;
-    luminosityChange: EventEmitter<number>;
-    get luminosity(): number;
-    set luminosity(value: number);
-    private canvasContext;
-    canvas: ElementRef<HTMLCanvasElement>;
-    ngAfterViewInit(): void;
-    resultBackground$: Observable<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsLuminosityStripComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsLuminosityStripComponent, "bs-luminosity-strip", never, { "hs": { "alias": "hs"; "required": false; }; "luminosity": { "alias": "luminosity"; "required": false; }; }, { "luminosityChange": "luminosityChange"; }, never, never, false, never>;
-}
-
-declare class BsSliderComponent {
-    private element;
-    private zone;
-    constructor(element: ElementRef<HTMLElement>, zone: NgZone);
-    dBlock: boolean;
-    positionRelative: boolean;
-    thumbMarginLeft$: Observable<number>;
-    track: ElementRef<HTMLDivElement>;
-    thumb: ElementRef<HTMLDivElement>;
-    value$: BehaviorSubject<number>;
-    valueChange: EventEmitter<number>;
-    get value(): number;
-    set value(value: number);
-    private isPointerDown$;
-    cursorClass$: Observable<string>;
-    onPointerDown(ev: MouseEvent | TouchEvent): void;
-    onPointerMove(ev: MouseEvent | TouchEvent): void;
-    onPointerUp(ev: MouseEvent | TouchEvent): void;
-    private updateColor;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsSliderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsSliderComponent, "bs-slider", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["[bsTrack]", "[bsThumb]"], false, never>;
-}
-declare class BsThumbDirective {
-    thumbClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsThumbDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsThumbDirective, "[bsThumb]", never, {}, {}, never, never, false, never>;
-}
-declare class BsTrackDirective {
-    trackClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsTrackDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BsTrackDirective, "[bsTrack]", never, {}, {}, never, never, false, never>;
-}
-
-declare class BsAlphaStripComponent implements AfterViewInit {
-    constructor();
-    hs$: BehaviorSubject<HS>;
-    get hs(): HS;
-    set hs(value: HS);
-    luminosity$: BehaviorSubject<number>;
-    get luminosity(): number;
-    set luminosity(value: number);
-    alpha$: BehaviorSubject<number>;
-    alphaChange: EventEmitter<number>;
-    get alpha(): number;
-    set alpha(value: number);
-    private canvasContext;
-    canvas: ElementRef<HTMLCanvasElement>;
-    ngAfterViewInit(): void;
-    resultBackground$: Observable<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsAlphaStripComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BsAlphaStripComponent, "bs-alpha-strip", never, { "hs": { "alias": "hs"; "required": false; }; "luminosity": { "alias": "luminosity"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; }, { "alphaChange": "alphaChange"; }, never, never, false, never>;
-}
-
-declare class BsColorPickerModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BsColorPickerModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BsColorPickerModule, [typeof BsColorPickerComponent, typeof BsColorPickerValueAccessor, typeof BsColorWheelComponent, typeof BsLuminosityStripComponent, typeof BsSliderComponent, typeof BsThumbDirective, typeof BsTrackDirective, typeof BsAlphaStripComponent], [typeof i7.AsyncPipe, typeof i8.FormsModule], [typeof BsColorPickerComponent, typeof BsColorPickerValueAccessor, typeof BsColorWheelComponent, typeof BsLuminosityStripComponent, typeof BsSliderComponent, typeof BsThumbDirective, typeof BsTrackDirective, typeof BsAlphaStripComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BsColorPickerModule>;
-}
-
-interface HslColor {
-    hue: number;
-    saturation: number;
-    luminosity: number;
-}
-
-type HtmlColor = `#${string}`;
-
-export { BsAlphaStripComponent, BsColorPickerComponent, BsColorPickerModule, BsColorPickerValueAccessor, BsColorWheelComponent, BsLuminosityStripComponent, BsSliderComponent, BsThumbDirective, BsTrackDirective };
-export type { HS, HslColor, HtmlColor, RgbColor };