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

package/offcanvas/index.d.ts

@@ -1 +1,112 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter, AfterViewInit, OnDestroy, Injector, DestroyRef, ComponentRef, ElementRef } from '@angular/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { Position } from '@mintplayer/ng-bootstrap';
+import * as i9 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { AnimationBuilder } from '@angular/animations';
+import * as i8 from '@angular/common';
+import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsOffcanvasComponent {
+    constructor(contentTemplate: TemplateRef<any>);
+    contentTemplate: TemplateRef<any>;
+    visibility$: Observable<string>;
+    disableTransition$: BehaviorSubject<boolean>;
+    offcanvasClass$: BehaviorSubject<string | null>;
+    overflowClass$: Observable<string | null>;
+    width$: Observable<number | null>;
+    height$: Observable<number | null>;
+    hasBackdrop$: BehaviorSubject<boolean>;
+    show$: Observable<boolean>;
+    showBackdrop$: Observable<boolean>;
+    position$: BehaviorSubject<Position>;
+    set position(value: Position);
+    get position(): Position;
+    size$: BehaviorSubject<number | null>;
+    set size(value: number | null);
+    get size(): number | null;
+    isVisible$: BehaviorSubject<boolean>;
+    isVisibleChange: EventEmitter<boolean>;
+    set isVisible(value: boolean);
+    get isVisible(): boolean;
+    backdropClick: EventEmitter<MouseEvent>;
+    onBackdropClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsOffcanvasComponent, "bs-offcanvas-holder", never, { "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, { "isVisibleChange": "isVisibleChange"; "backdropClick": "backdropClick"; }, never, never, false, never>;
+}
+
+declare class BsOffcanvasHostComponent implements AfterViewInit, OnDestroy {
+    private overlayService;
+    private rootInjector;
+    private destroy;
+    private portalFactory;
+    constructor(overlayService: Overlay, rootInjector: Injector, destroy: DestroyRef, portalFactory: (injector: Injector) => ComponentPortal<any>);
+    content: TemplateRef<any>;
+    overlayRef: OverlayRef;
+    component: ComponentRef<BsOffcanvasComponent>;
+    viewInited$: BehaviorSubject<boolean>;
+    isVisible$: BehaviorSubject<boolean>;
+    size$: BehaviorSubject<number | null>;
+    position$: BehaviorSubject<Position>;
+    hasBackdrop$: BehaviorSubject<boolean>;
+    backdropClick: EventEmitter<MouseEvent>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isVisibleChange: EventEmitter<boolean>;
+    set isVisible(value: boolean);
+    get isVisible(): boolean;
+    set position(value: Position);
+    get position(): Position;
+    set size(value: number | null);
+    get size(): number | null;
+    set hasBackdrop(value: boolean);
+    get hasBackdrop(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsOffcanvasHostComponent, "bs-offcanvas", never, { "isVisible": { "alias": "isVisible"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; }, { "backdropClick": "backdropClick"; "isVisibleChange": "isVisibleChange"; }, never, never, false, never>;
+}
+
+declare class BsOffcanvasContentDirective {
+    constructor(offcanvasHost: BsOffcanvasHostComponent, template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasContentDirective, "[bsOffcanvasContent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsOffcanvasCloseDirective {
+    private offcanvas;
+    constructor(offcanvas: BsOffcanvasHostComponent);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasCloseDirective, "[bsOffcanvasClose]", never, {}, {}, never, never, false, never>;
+}
+
+declare class OffcanvasHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OffcanvasHeaderComponent, "bs-offcanvas-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class OffcanvasBodyComponent {
+    noPadding: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OffcanvasBodyComponent, "bs-offcanvas-body", never, { "noPadding": { "alias": "noPadding"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsOffcanvasPushDirective {
+    private element;
+    private builder;
+    constructor(element: ElementRef<HTMLElement>, builder: AnimationBuilder);
+    private offcanvas$;
+    private initialOverflowX?;
+    set offcanvas(value: BsOffcanvasHostComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasPushDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasPushDirective, "[bsOffcanvasPush]", never, { "offcanvas": { "alias": "bsOffcanvasPush"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsOffcanvasModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsOffcanvasModule, [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective], [typeof i8.AsyncPipe, typeof i8.NgTemplateOutlet, typeof i9.OverlayModule, typeof i10.BsHasOverlayComponent], [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsOffcanvasModule>;
+}
+
+export { BsOffcanvasCloseDirective, BsOffcanvasComponent, BsOffcanvasContentDirective, BsOffcanvasHostComponent, BsOffcanvasModule, BsOffcanvasPushDirective, OffcanvasBodyComponent, OffcanvasHeaderComponent };

package/ordinal-number/index.d.ts

@@ -1 +1,13 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+declare class BsOrdinalNumberPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, ...args: string[]): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOrdinalNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsOrdinalNumberPipe, "ordinalNumber", true>;
+}
+
+export { BsOrdinalNumberPipe };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mintplayer/ng-bootstrap",
   "private": false,
-  "version": "19.0.0",
+  "version": "20.0.0-preview.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/MintPlayer/mintplayer-ng-bootstrap",
@@ -16,14 +16,14 @@
       "types": "./index.d.ts",
       "default": "./fesm2022/mintplayer-ng-bootstrap.mjs"
     },
-    "./accordion": {
-      "types": "./accordion/index.d.ts",
-      "default": "./fesm2022/mintplayer-ng-bootstrap-accordion.mjs"
-    },
     "./alert": {
       "types": "./alert/index.d.ts",
       "default": "./fesm2022/mintplayer-ng-bootstrap-alert.mjs"
     },
+    "./accordion": {
+      "types": "./accordion/index.d.ts",
+      "default": "./fesm2022/mintplayer-ng-bootstrap-accordion.mjs"
+    },
     "./async-host-binding": {
       "types": "./async-host-binding/index.d.ts",
       "default": "./fesm2022/mintplayer-ng-bootstrap-async-host-binding.mjs"
@@ -350,21 +350,21 @@
     }
   },
   "peerDependencies": {
-    "@angular/common": "^19.0.0",
-    "@angular/core": "^19.0.0",
-    "@angular/cdk": "^19.0.0",
-    "@angular/forms": "^19.0.0",
-    "@angular/router": "^19.0.0",
-    "@angular/platform-browser": "^19.0.0",
+    "@angular/common": "^20.0.0-rc.2",
+    "@angular/core": "^20.0.0-rc.2",
+    "@angular/cdk": "^20.0.0-rc.2",
+    "@angular/forms": "^20.0.0-rc.2",
+    "@angular/router": "^20.0.0-rc.2",
+    "@angular/platform-browser": "^20.0.0-rc.2",
     "rxjs": "^7.5.0",
     "bootstrap": "^5.3.0",
     "bootstrap-icons": "^1.7.2",
     "ngx-highlightjs": "^10.0.0",
-    "@mintplayer/ng-click-outside": "^19.0.0",
-    "@mintplayer/ng-animations": "^19.0.0",
+    "@mintplayer/ng-click-outside": "^20.0.0-preview.1",
+    "@mintplayer/ng-animations": "^20.0.0-preview.1",
     "@mintplayer/pagination": "^2.2.0",
-    "@mintplayer/ng-focus-on-load": "^19.0.0",
-    "@mintplayer/ng-swiper": "^19.0.0",
+    "@mintplayer/ng-focus-on-load": "^20.0.0-preview.1",
+    "@mintplayer/ng-swiper": "^20.0.0-preview.1",
     "@mintplayer/parentify": "^1.1.0"
   },
   "dependencies": {

package/pagination/index.d.ts

@@ -1 +1,56 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { Size } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+type PageNumberType = number | '...';
+
+interface PageWithSelection {
+    page: PageNumberType;
+    selected: boolean;
+}
+
+declare class BsPaginationComponent {
+    constructor();
+    /** All page numbers. */
+    pageNumbers$: BehaviorSubject<number[]>;
+    /** Page numbers to be displayed to the user. */
+    shownPageNumbers$: Observable<PageWithSelection[]>;
+    /** Selected number. */
+    selectedPageNumber$: BehaviorSubject<number>;
+    /** Number of boxes. */
+    numberOfBoxes$: BehaviorSubject<number>;
+    /** Display previous/next arrows. */
+    showArrows$: BehaviorSubject<boolean>;
+    /** Page number size. */
+    size$: BehaviorSubject<Size>;
+    /** Indicates if first value is selected. */
+    isFirstPage$: Observable<boolean>;
+    /** Indicates if last value is selected. */
+    isLastPage$: Observable<boolean>;
+    /** The number of boxes (excluding arrows) that's being shown on the pagination component. */
+    visibleNumberOfNumberBoxes$: Observable<number>;
+    /** Indicates whether there are too many numbers to the left-hand side of the current page. */
+    isLeftOverflow$: Observable<boolean>;
+    /** Indicates whether there are too many numbers to the right-hand side of the current page. */
+    isRightOverflow$: Observable<boolean>;
+    selectedPageNumberChange: EventEmitter<number>;
+    set selectedPageNumber(value: number);
+    get selectedPageNumber(): number;
+    set numberOfBoxes(value: number);
+    get numberOfBoxes(): number;
+    set pageNumbers(value: number[]);
+    get pageNumbers(): number[];
+    set showArrows(value: boolean);
+    get showArrows(): boolean;
+    set size(value: Size);
+    get size(): Size;
+    onSelectPage(event: MouseEvent, page: number): boolean;
+    onPrevious(): boolean;
+    onNext(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPaginationComponent, "bs-pagination", never, { "selectedPageNumber": { "alias": "selectedPageNumber"; "required": false; }; "numberOfBoxes": { "alias": "numberOfBoxes"; "required": false; }; "pageNumbers": { "alias": "pageNumbers"; "required": false; }; "showArrows": { "alias": "showArrows"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "selectedPageNumberChange": "selectedPageNumberChange"; }, never, never, true, never>;
+}
+
+export { BsPaginationComponent };
+export type { PageNumberType, PageWithSelection };

package/parallax/index.d.ts

@@ -1 +1,11 @@
-export * from './src/parallax.component';
+import * as _angular_core from '@angular/core';
+
+declare class BsParallaxComponent {
+    height: _angular_core.InputSignal<number>;
+    image: _angular_core.InputSignal<string>;
+    imageStyle: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsParallaxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsParallaxComponent, "bs-parallax", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BsParallaxComponent };

package/placeholder/index.d.ts

@@ -1 +1,32 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i3 from '@angular/common';
+
+declare class BsPlaceholderComponent {
+    isLoading$: BehaviorSubject<boolean>;
+    isLoadingChange: EventEmitter<boolean>;
+    get isLoading(): boolean;
+    set isLoading(value: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaceholderComponent, "bs-placeholder", never, { "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsPlaceholderFieldDirective {
+    private placeholder;
+    constructor(placeholder: BsPlaceholderComponent);
+    html?: string;
+    minWidth: number;
+    marginBottom: number;
+    placeholderClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPlaceholderFieldDirective, "[bsPlaceholderField]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsPlaceholderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaceholderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsPlaceholderModule, [typeof BsPlaceholderComponent, typeof BsPlaceholderFieldDirective], [typeof i3.CommonModule], [typeof BsPlaceholderComponent, typeof BsPlaceholderFieldDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsPlaceholderModule>;
+}
+
+export { BsPlaceholderComponent, BsPlaceholderFieldDirective, BsPlaceholderModule };

package/playlist-toggler/index.d.ts

@@ -1 +1,17 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+declare class BsPlaylistTogglerComponent {
+    constructor();
+    state$: BehaviorSubject<boolean>;
+    stateChange: EventEmitter<boolean>;
+    get state(): boolean;
+    set state(value: boolean);
+    toggleOnClick: boolean;
+    toggleState(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPlaylistTogglerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPlaylistTogglerComponent, "bs-playlist-toggler", never, { "state": { "alias": "state"; "required": false; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+export { BsPlaylistTogglerComponent };

package/popover/index.d.ts

@@ -1 +1,67 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, Injector, ElementRef } from '@angular/core';
+import { Position } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i6 from '@angular/cdk/overlay';
+import { Overlay, ConnectedPosition } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import * as i5 from '@angular/common';
+import * as i7 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsPopoverComponent {
+    constructor(content: TemplateRef<any>);
+    position$: BehaviorSubject<Position>;
+    get position(): Position;
+    set position(value: Position);
+    isVisible$: BehaviorSubject<boolean>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    marginClass$: Observable<string>;
+    positionClass$: Observable<string>;
+    template: TemplateRef<any>;
+    positionRelative: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPopoverComponent, "bs-popover", never, { "position": { "alias": "position"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsPopoverDirective implements AfterViewInit, OnDestroy {
+    private overlay;
+    private templateRef;
+    private parentInjector;
+    private portalFactory;
+    private parent;
+    constructor(overlay: Overlay, templateRef: TemplateRef<any>, parentInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<any>, parent: ElementRef);
+    set bsPopover(value: Position);
+    updatePosition: boolean;
+    private injector;
+    private portal;
+    private overlayRef;
+    private component;
+    position$: BehaviorSubject<Position>;
+    connectedPosition$: Observable<ConnectedPosition>;
+    isVisible$: BehaviorSubject<boolean>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverDirective, [null, null, null, null, { host: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverDirective, "*[bsPopover]", never, { "bsPopover": { "alias": "bsPopover"; "required": false; }; "updatePosition": { "alias": "updatePosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsPopoverBodyDirective {
+    bodyClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverBodyDirective, "[bsPopoverBody]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsPopoverHeaderDirective {
+    headerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverHeaderDirective, "[bsPopoverHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsPopoverModule, [typeof BsPopoverComponent, typeof BsPopoverDirective, typeof BsPopoverHeaderDirective, typeof BsPopoverBodyDirective], [typeof i5.AsyncPipe, typeof i5.NgTemplateOutlet, typeof i6.OverlayModule, typeof i7.BsHasOverlayComponent], [typeof BsPopoverDirective, typeof BsPopoverHeaderDirective, typeof BsPopoverBodyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsPopoverModule>;
+}
+
+export { BsPopoverBodyDirective, BsPopoverComponent, BsPopoverDirective, BsPopoverHeaderDirective, BsPopoverModule };

package/progress-bar/index.d.ts

@@ -1 +1,46 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i3 from '@angular/common';
+
+declare class BsProgressBarComponent {
+    constructor();
+    minimum$: BehaviorSubject<number>;
+    maximum$: BehaviorSubject<number>;
+    value$: BehaviorSubject<number>;
+    percentage$: Observable<number>;
+    width$: Observable<string>;
+    color$: BehaviorSubject<Color>;
+    colorClass$: Observable<string>;
+    set minimum(value: number);
+    set maximum(value: number);
+    set value(value: number);
+    set color(value: Color);
+    striped: boolean;
+    animated: boolean;
+    progressBar: boolean;
+    colorClass: string;
+    widthStyle: string;
+    role: string;
+    valueNow: number;
+    valueMin: number;
+    valueMax: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsProgressBarComponent, "bs-progress-bar", never, { "minimum": { "alias": "minimum"; "required": false; }; "maximum": { "alias": "maximum"; "required": false; }; "value": { "alias": "value"; "required": false; }; "color": { "alias": "color"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsProgressComponent {
+    height: number | null;
+    isIndeterminate: boolean;
+    private progressClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsProgressComponent, "bs-progress", never, { "height": { "alias": "height"; "required": false; }; "isIndeterminate": { "alias": "isIndeterminate"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsProgressBarModule, [typeof BsProgressBarComponent, typeof BsProgressComponent], [typeof i3.CommonModule], [typeof BsProgressBarComponent, typeof BsProgressComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsProgressBarModule>;
+}
+
+export { BsProgressBarComponent, BsProgressBarModule, BsProgressComponent };

package/range/index.d.ts

@@ -1 +1,36 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, DestroyRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i3 from '@angular/common';
+
+declare class BsRangeComponent {
+    slider: ElementRef<HTMLInputElement>;
+    min: number;
+    max: number;
+    step: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsRangeComponent, "bs-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsRangeValueAccessor implements ControlValueAccessor, AfterViewInit {
+    private host;
+    private destroy;
+    constructor(host: BsRangeComponent, destroy: DestroyRef);
+    onValueChange?: (value: number) => void;
+    onTouched?: () => void;
+    ngAfterViewInit(): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value?: number): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsRangeValueAccessor, "bs-range", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsRangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsRangeModule, [typeof BsRangeComponent, typeof BsRangeValueAccessor], [typeof i3.CommonModule], [typeof BsRangeComponent, typeof BsRangeValueAccessor]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsRangeModule>;
+}
+
+export { BsRangeComponent, BsRangeModule, BsRangeValueAccessor };

package/rating/index.d.ts

@@ -1 +1,23 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+declare class BsRatingComponent {
+    constructor();
+    maximum$: BehaviorSubject<number>;
+    value$: BehaviorSubject<number>;
+    previewValue$: BehaviorSubject<number | null>;
+    stars$: Observable<boolean[]>;
+    set maximum(value: number);
+    valueChange: EventEmitter<number>;
+    starsChange: EventEmitter<number>;
+    get value(): number;
+    set value(value: number);
+    hoverValue(index: number): void;
+    selectValue(index: number): void;
+    onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsRatingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsRatingComponent, "bs-rating", never, { "maximum": { "alias": "maximum"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "starsChange": "starsChange"; }, never, never, true, never>;
+}
+
+export { BsRatingComponent };

package/resizable/index.d.ts

@@ -1 +1,94 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, InjectionToken } from '@angular/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { Position } from '@mintplayer/ng-bootstrap';
+import * as i3 from '@angular/common';
+
+type ResizablePositioning = 'absolute' | 'inline';
+
+interface ResizeAction {
+    positioning: ResizablePositioning;
+    top?: ResizeActionSide;
+    start?: ResizeActionSide;
+    bottom?: ResizeActionSide;
+    end?: ResizeActionSide;
+}
+interface ResizeActionSide {
+    /** Fixed edge */
+    edge: number;
+    /** Initial margin at the fixed edge */
+    margin?: number;
+    /** Initial margin at the edge that's being dragged */
+    dragMargin?: number;
+    /** Initial size */
+    size: number;
+}
+
+interface PresetPosition {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+declare class BsResizableComponent {
+    constructor(element: ElementRef<HTMLElement>);
+    resizeAction?: ResizeAction;
+    element: ElementRef<HTMLElement>;
+    hostPosition$: Observable<string>;
+    wrapperPosition$: Observable<string[]>;
+    positioning$: BehaviorSubject<ResizablePositioning>;
+    get positioning(): ResizablePositioning;
+    set positioning(value: ResizablePositioning);
+    set presetPosition(value: PresetPosition);
+    marginLeft?: number;
+    marginRight?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    width?: number;
+    height?: number;
+    left?: number;
+    top?: number;
+    classes: boolean;
+    hostClass: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsResizableComponent, "bs-resizable", never, { "positioning": { "alias": "positioning"; "required": false; }; "presetPosition": { "alias": "presetPosition"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+interface PointerData {
+    clientX: number;
+    clientY: number;
+    preventDefault: () => void;
+}
+
+declare class BsResizeGlyphDirective {
+    private readonly resizable;
+    constructor(resizable: any);
+    positions: string;
+    glyphClass: boolean;
+    activeClass: boolean;
+    set bsResizeGlyph(value: Position[]);
+    onMouseDown(ev: MouseEvent): void;
+    onTouchStart(ev: TouchEvent): void;
+    onMouseMove(ev: MouseEvent): void;
+    onTouchMove(ev: TouchEvent): void;
+    onMouseUp(ev: Event): void;
+    onTouchEnd(ev: Event): void;
+    onPointerDown(): void;
+    private isBusy;
+    onPointerMove(ev: PointerData): void;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizeGlyphDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsResizeGlyphDirective, "[bsResizeGlyph]", never, { "bsResizeGlyph": { "alias": "bsResizeGlyph"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsResizableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsResizableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsResizableModule, [typeof BsResizableComponent, typeof BsResizeGlyphDirective], [typeof i3.CommonModule], [typeof BsResizableComponent, typeof BsResizeGlyphDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsResizableModule>;
+}
+
+declare const RESIZABLE: InjectionToken<BsResizableComponent>;
+
+export { BsResizableComponent, BsResizableModule, BsResizeGlyphDirective, RESIZABLE };
+export type { PointerData, PresetPosition, ResizablePositioning, ResizeAction, ResizeActionSide };