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

package/accordion/index.d.ts

@@ -1 +1,51 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { QueryList, EventEmitter } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i5 from '@mintplayer/ng-bootstrap/no-noscript';
+
+declare class BsAccordionTabComponent {
+    accordion: BsAccordionComponent;
+    accordionTabId$: BehaviorSubject<number>;
+    accordionTabName$: Observable<string>;
+    childAccordions: QueryList<BsAccordionComponent>;
+    constructor(accordion: BsAccordionComponent);
+    accordionItemClass: boolean;
+    dBlock: boolean;
+    noBorder: boolean;
+    isActiveChange: EventEmitter<boolean>;
+    private _isActive;
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionTabComponent, "bs-accordion-tab", never, { "isActive": { "alias": "isActive"; "required": false; }; }, { "isActiveChange": "isActiveChange"; }, ["childAccordions"], ["bs-accordion-tab-header", "*"], false, never>;
+}
+
+declare class BsAccordionComponent {
+    constructor();
+    tabPages: QueryList<BsAccordionTabComponent>;
+    disableAnimations: boolean;
+    highlightActiveTab: boolean;
+    accordionId$: BehaviorSubject<number>;
+    accordionName$: Observable<string>;
+    accordionTabCounter: number;
+    static accordionCounter: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionComponent, "bs-accordion", never, { "highlightActiveTab": { "alias": "highlightActiveTab"; "required": false; }; }, {}, ["tabPages"], ["*"], false, never>;
+}
+
+declare class BsAccordionTabHeaderComponent {
+    constructor(accordionTab: BsAccordionTabComponent);
+    accordionTab: BsAccordionTabComponent;
+    headerClicked(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionTabHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsAccordionTabHeaderComponent, "bs-accordion-tab-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsAccordionModule, [typeof BsAccordionComponent, typeof BsAccordionTabComponent, typeof BsAccordionTabHeaderComponent], [typeof i4.AsyncPipe, typeof i5.BsNoNoscriptDirective], [typeof BsAccordionComponent, typeof BsAccordionTabComponent, typeof BsAccordionTabHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsAccordionModule>;
+}
+
+export { BsAccordionComponent, BsAccordionModule, BsAccordionTabComponent, BsAccordionTabHeaderComponent };

package/alert/index.d.ts

@@ -1 +1,32 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class BsAlertComponent {
+    type: Color;
+    colors: typeof Color;
+    private _isVisible;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    isVisibleChange: EventEmitter<boolean>;
+    afterOpenedOrClosed: EventEmitter<any>;
+    onAfterOpenedOrClosed(isVisible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsAlertComponent, "bs-alert", never, { "type": { "alias": "type"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, { "isVisibleChange": "isVisibleChange"; "afterOpenedOrClosed": "afterOpenedOrClosed"; }, never, ["*"], false, never>;
+}
+
+declare class BsAlertCloseComponent {
+    private alert;
+    constructor(alert: BsAlertComponent);
+    closeAlert(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAlertCloseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsAlertCloseComponent, "bs-alert-close", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsAlertModule, [typeof BsAlertComponent, typeof BsAlertCloseComponent], never, [typeof BsAlertComponent, typeof BsAlertCloseComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsAlertModule>;
+}
+
+export { BsAlertCloseComponent, BsAlertComponent, BsAlertModule };

package/async-host-binding/index.d.ts

@@ -1 +1,13 @@
-export * from './src';
+import { Provider } from '@angular/core';
+import { EventManager } from '@angular/platform-browser';
+
+declare function provideAsyncHostBindings(): Provider[];
+
+declare class BsBindEventPlugin {
+    manager: EventManager;
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string): () => void;
+    private getMethod;
+}
+
+export { BsBindEventPlugin, provideAsyncHostBindings };

package/badge/index.d.ts

@@ -1 +1,16 @@
-export * from './src';
+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/breadcrumb/index.d.ts

@@ -1 +1,20 @@
-export * from './src';
+import * as i0 from '@angular/core';
+
+declare class BsBreadcrumbComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsBreadcrumbComponent, "bs-breadcrumb", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsBreadcrumbItemComponent {
+    classes: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsBreadcrumbItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsBreadcrumbItemComponent, "bs-breadcrumb-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsBreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsBreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsBreadcrumbModule, [typeof BsBreadcrumbComponent, typeof BsBreadcrumbItemComponent], never, [typeof BsBreadcrumbComponent, typeof BsBreadcrumbItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsBreadcrumbModule>;
+}
+
+export { BsBreadcrumbComponent, BsBreadcrumbItemComponent, BsBreadcrumbModule };

package/button-group/index.d.ts

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

package/button-type/index.d.ts

@@ -1 +1,12 @@
-export * from './src';
+import { Color } from '@mintplayer/ng-bootstrap';
+import * as i0 from '@angular/core';
+
+declare class BsButtonTypeDirective {
+    btnClass: boolean;
+    buttonClass: string;
+    set color(value: Color);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsButtonTypeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsButtonTypeDirective, "button[color],input[type=\"button\"][color],input[type=\"submit\"][color],a[color]", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { BsButtonTypeDirective };

package/calendar/index.d.ts

@@ -1 +1,32 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { 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;
+    constructor(sanitizer: DomSanitizer, calendarMonthService: BsCalendarMonthService);
+    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/calendar-month/index.d.ts

@@ -1 +1,54 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+interface DateDayOfMonth {
+    date: Date;
+    dayOfMonth: number;
+    isInMonth: boolean;
+}
+
+interface Week {
+    number: number;
+    days: (DateDayOfMonth | null)[];
+}
+
+interface FirstAndLastDate {
+    first: Date;
+    last: Date;
+}
+
+declare class BsCalendarMonthService {
+    getWeeks(month: Date): Week[];
+    generateList(count: number): number[];
+    dayOfWeekMondayBased(date: Date): number;
+    weekOfYear(date: Date): number;
+    getFirstAndLastDayOfMonth(date: Date): FirstAndLastDate;
+    dateDiff(date1: Date, date2: Date): number;
+    dayOfYear(date: Date): number;
+    toUTC(date: Date): number;
+    chunk<T>(items: T[], size: number): T[][];
+    getMondayBefore(date: Date): Date;
+    getSundayAfter(date: Date): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCalendarMonthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsCalendarMonthService>;
+}
+
+interface WeekDay {
+    short: string;
+    long: string;
+}
+
+declare class BsMonthNamePipe implements PipeTransform {
+    transform(date: Date | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsMonthNamePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsMonthNamePipe, "monthName", true>;
+}
+
+declare class BsWeekdayNamePipe implements PipeTransform {
+    transform(date: Date): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsWeekdayNamePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsWeekdayNamePipe, "weekdayName", true>;
+}
+
+export { BsCalendarMonthService, BsMonthNamePipe, BsWeekdayNamePipe };
+export type { DateDayOfMonth, FirstAndLastDate, Week, WeekDay };

package/card/index.d.ts

@@ -1 +1,22 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import * as i3 from '@angular/common';
+
+declare class BsCardComponent {
+    rounded: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsCardComponent, "bs-card", never, { "rounded": { "alias": "rounded"; "required": false; }; }, {}, never, ["bs-card-header", "*"], false, never>;
+}
+
+declare class BsCardHeaderComponent {
+    noPadding: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCardHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsCardHeaderComponent, "bs-card-header", never, { "noPadding": { "alias": "noPadding"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsCardModule, [typeof BsCardComponent, typeof BsCardHeaderComponent], [typeof i3.CommonModule], [typeof BsCardComponent, typeof BsCardHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsCardModule>;
+}
+
+export { BsCardComponent, BsCardHeaderComponent, BsCardModule };

package/carousel/index.d.ts

@@ -1 +1,64 @@
-export * from './src';
+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;
+    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; }; "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/close/index.d.ts

@@ -1 +1,11 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+declare class BsCloseComponent {
+    click: EventEmitter<any>;
+    onClose(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCloseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsCloseComponent, "bs-close", never, {}, { "click": "click"; }, never, never, true, never>;
+}
+
+export { BsCloseComponent };

package/code-snippet/index.d.ts

@@ -1 +1,20 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter } from '@angular/core';
+import { HighlightResult } from 'highlight.js';
+import { BehaviorSubject } from 'rxjs';
+
+declare class BsCodeSnippetComponent {
+    constructor();
+    offcanvasVisible: boolean;
+    codeToCopy: string;
+    language: i0.InputSignal<string>;
+    copiedTemplate: TemplateRef<any>;
+    detectedLanguage: EventEmitter<string>;
+    language$: BehaviorSubject<string>;
+    copiedHtml(): void;
+    onHighlighted(result: HighlightResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCodeSnippetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsCodeSnippetComponent, "bs-code-snippet", never, { "codeToCopy": { "alias": "codeToCopy"; "required": false; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; }, { "detectedLanguage": "detectedLanguage"; }, never, never, true, never>;
+}
+
+export { BsCodeSnippetComponent };

package/color-picker/index.d.ts

@@ -1,5 +1,196 @@
-export * from './color-picker.module';
-export * from './components';
-export * from './directives';
-export * from './interfaces';
-export * from './types';
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, EventEmitter, DestroyRef, 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;
+    constructor(element: ElementRef<HTMLElement>);
+    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 };

package/container/index.d.ts

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

package/context-menu/index.d.ts

@@ -1 +1,30 @@
-export * from './src';
+import * as i4 from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { TemplateRef, ViewContainerRef, ElementRef } from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsContextMenuDirective {
+    private overlay;
+    private templateRef;
+    private viewContainerRef;
+    private element;
+    constructor(overlay: Overlay, templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, element: ElementRef);
+    private overlayRef;
+    private templatePortal;
+    clickAnywhere(ev: MouseEvent): void;
+    private onBlur;
+    private close;
+    private checkAndCloseExisting;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsContextMenuDirective, [null, null, null, { host: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsContextMenuDirective, "[bsContextMenu]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsContextMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsContextMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsContextMenuModule, [typeof BsContextMenuDirective], [typeof i2.CommonModule, typeof i3.BsHasOverlayComponent, typeof i4.OverlayModule], [typeof BsContextMenuDirective, typeof i3.BsHasOverlayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsContextMenuModule>;
+}
+
+export { BsContextMenuDirective, BsContextMenuModule };

package/copy/index.d.ts

@@ -1 +1,14 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+declare class BsCopyDirective {
+    private doc;
+    constructor(doc: any);
+    bsCopy: string | null;
+    bsCopied: EventEmitter<string>;
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsCopyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsCopyDirective, "[bsCopy]", never, { "bsCopy": { "alias": "bsCopy"; "required": false; }; }, { "bsCopied": "bsCopied"; }, never, never, true, never>;
+}
+
+export { BsCopyDirective };