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

package/floating-labels/index.d.ts

@@ -1 +1,10 @@
-export * from './src';
+import { BsFormComponent } from '@mintplayer/ng-bootstrap/form';
+import * as i0 from '@angular/core';
+
+declare class BsFloatingLabelComponent {
+    constructor(bsForm: BsFormComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFloatingLabelComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsFloatingLabelComponent, "bs-floating-label", never, {}, {}, never, ["input", "label"], true, never>;
+}
+
+export { BsFloatingLabelComponent };

package/font-color/index.d.ts

@@ -1 +1,10 @@
-export * from './src/font-color.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class BsFontColorPipe implements PipeTransform {
+    transform(color_hex: any, defaultColor?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFontColorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsFontColorPipe, "bsFontColor", true>;
+}
+
+export { BsFontColorPipe };

package/for/index.d.ts

@@ -1 +1,13 @@
-export * from './src';
+import * as i0 from '@angular/core';
+
+declare class BsForDirective {
+    defaultCursor: boolean;
+    static counter: number;
+    private target;
+    set bsFor(value: any);
+    forValue?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsForDirective, "label[bsFor]", never, { "bsFor": { "alias": "bsFor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { BsForDirective };

package/form/index.d.ts

@@ -1 +1,33 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i4 from '@angular/common';
+
+declare class BsFormComponent {
+    action?: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    submitted: EventEmitter<Event>;
+    onSubmit(ev: Event): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsFormComponent, "bs-form", never, { "action": { "alias": "action"; "required": false; }; "method": { "alias": "method"; "required": false; }; }, { "submitted": "submitted"; }, never, ["*"], false, never>;
+}
+
+declare class BsFormControlDirective {
+    constructor(form?: BsFormComponent);
+    formControlClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormControlDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormControlDirective, "bs-form input:not(.no-form-control), bs-form textarea:not(.no-form-control)", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsFormGroupDirective {
+    formGroupClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFormGroupDirective, "[bsFormGroup]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsFormModule, [typeof BsFormComponent, typeof BsFormControlDirective, typeof BsFormGroupDirective], [typeof i4.CommonModule], [typeof BsFormComponent, typeof BsFormControlDirective, typeof BsFormGroupDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsFormModule>;
+}
+
+export { BsFormComponent, BsFormControlDirective, BsFormGroupDirective, BsFormModule };

package/grid/index.d.ts

@@ -1 +1,74 @@
-export * from './src';
+import { Breakpoint } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { DestroyRef } from '@angular/core';
+import * as i5 from '@angular/common';
+import * as i6 from '@mintplayer/ng-bootstrap/container';
+
+declare class BsGridComponent {
+    constructor();
+    stopFullWidthAt$: BehaviorSubject<Breakpoint | "never">;
+    get stopFullWidthAt(): Breakpoint | "never";
+    set stopFullWidthAt(value: Breakpoint | 'never');
+    containerClass$: Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsGridComponent, "bs-grid", never, { "stopFullWidthAt": { "alias": "stopFullWidthAt"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsGridRowDirective {
+    rowClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridRowDirective, "[bsRow]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsGridColumnDirective {
+    constructor(destroy: DestroyRef);
+    classList: string | null;
+    xxs$: BehaviorSubject<number | undefined>;
+    xs$: BehaviorSubject<number | undefined>;
+    sm$: BehaviorSubject<number | undefined>;
+    md$: BehaviorSubject<number | undefined>;
+    lg$: BehaviorSubject<number | undefined>;
+    xl$: BehaviorSubject<number | undefined>;
+    xxl$: BehaviorSubject<number | undefined>;
+    set xxs(value: number | undefined);
+    set xs(value: number | undefined);
+    set sm(value: number | undefined);
+    set md(value: number | undefined);
+    set lg(value: number | undefined);
+    set xl(value: number | undefined);
+    set xxl(value: number | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColumnDirective, "[xxs],[xs],[sm],[md],[lg],[xl],[xxl]", never, { "xxs": { "alias": "xxs"; "required": false; }; "xs": { "alias": "xs"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; "md": { "alias": "md"; "required": false; }; "lg": { "alias": "lg"; "required": false; }; "xl": { "alias": "xl"; "required": false; }; "xxl": { "alias": "xxl"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BsGridColDirective {
+    colClass: boolean;
+    set col(value: undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridColDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsGridColDirective, "[col]", never, { "col": { "alias": "col"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsColFormLabelDirective {
+    colFormLabelClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsColFormLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsColFormLabelDirective, "[bsColFormLabel]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsGridModule, [typeof BsGridComponent, typeof BsGridRowDirective, typeof BsGridColumnDirective, typeof BsGridColDirective, typeof BsColFormLabelDirective], [typeof i5.CommonModule, typeof i6.BsContainerComponent], [typeof BsGridComponent, typeof BsGridRowDirective, typeof BsGridColumnDirective, typeof BsGridColDirective, typeof BsColFormLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsGridModule>;
+}
+
+interface BsColumnDefinition {
+    _?: number;
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    xxl?: number;
+}
+
+export { BsColFormLabelDirective, BsGridColDirective, BsGridColumnDirective, BsGridComponent, BsGridModule, BsGridRowDirective };
+export type { BsColumnDefinition };

package/has-id/index.d.ts

@@ -1 +1,5 @@
-export * from './src/has-id';
+interface HasId<T> {
+    id: T;
+}
+
+export type { HasId };

package/has-overlay/index.d.ts

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

package/has-property/index.d.ts

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

package/in-list/index.d.ts

@@ -1 +1,11 @@
-export * from './src/in-list.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { HasId } from '@mintplayer/ng-bootstrap/has-id';
+
+declare class BsInListPipe<T> implements PipeTransform {
+    transform(items: HasId<T>[], parameter: T): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInListPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsInListPipe<any>, "bsInList", true>;
+}
+
+export { BsInListPipe };

package/index.d.ts

@@ -1,3 +1,31 @@
-export * from './lib/enums';
-export * from './lib/providers';
-export * from './lib/types';
+import { InjectionToken } from '@angular/core';
+
+declare enum Color {
+    primary = 0,
+    secondary = 1,
+    success = 2,
+    danger = 3,
+    warning = 4,
+    info = 5,
+    light = 6,
+    dark = 7,
+    body = 8,
+    white = 9,
+    transparent = 10
+}
+
+/**
+ * Register this provider with a **true** value to enable Development mode for ng-bootstrap.
+ * This will make the overlays, which usually close when clicking outside of them,
+ * to stay open.
+ **/
+declare const BS_DEVELOPMENT: InjectionToken<boolean>;
+
+type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+
+type Position = 'top' | 'end' | 'bottom' | 'start';
+
+type Size = 'small' | 'medium' | 'large';
+
+export { BS_DEVELOPMENT, Color };
+export type { Breakpoint, Position, Size };

package/input-group/index.d.ts

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

package/instance-of/index.d.ts

@@ -1 +1,81 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { PipeTransform, ViewContainerRef, TemplateRef, DoCheck } from '@angular/core';
+import * as i5 from '@angular/common';
+
+type AbstractType<T> = abstract new (...args: any[]) => T;
+
+declare class BsInstanceofPipe implements PipeTransform {
+    transform<V, R>(value: V, type: AbstractType<R>): R | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsInstanceofPipe, "bsInstanceof", false>;
+}
+
+declare class BsInstanceOfContext<T = unknown> {
+    $implicit: T;
+    bsInstanceofCase: T;
+}
+
+declare class SwitchView<T = unknown> {
+    private _viewContainerRef;
+    private _templateRef;
+    private _created;
+    private _context;
+    constructor(_viewContainerRef: ViewContainerRef, _templateRef: TemplateRef<BsInstanceOfContext<T>>);
+    enforceState(result?: T): void;
+    private create;
+    private destroy;
+}
+
+declare class BsInstanceOfDirective {
+    private _defaultViews;
+    private _defaultUsed;
+    private _caseCount;
+    private _lastCaseCheckIndex;
+    private _lastCasesMatched;
+    private _instanceof;
+    set bsInstanceof(newValue: any);
+    /** @internal */
+    _addCase(): number;
+    /** @internal */
+    _addDefault(view: SwitchView): void;
+    /** @internal */
+    _matchCase<T>(type: AbstractType<T>): T | undefined;
+    private _updateDefaultCases;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDirective, "[bsInstanceof]", never, { "bsInstanceof": { "alias": "bsInstanceof"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsInstanceofCaseDirective<T> implements DoCheck {
+    private bsInstanceof;
+    bsInstanceofCase: AbstractType<T>;
+    private _view;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext<T>>, bsInstanceof: BsInstanceOfDirective);
+    /**
+     * Asserts the correct type of the context for the template that `InstanceofCaseDirective` will render.
+     *
+     * The presence of this method is a signal to the Ivy template type-check compiler that the
+     * `InstanceofCaseDirective` structural directive renders its template with a specific context type.
+     * Magic happens here!
+     */
+    static ngTemplateContextGuard<T>(dir: BsInstanceofCaseDirective<T>, ctx: any): ctx is BsInstanceOfContext<Exclude<T, false | 0 | '' | null | undefined>>;
+    ngDoCheck(): void;
+    throwError(directiveName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceofCaseDirective<any>, [null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceofCaseDirective<any>, "[bsInstanceofCase]", never, { "bsInstanceofCase": { "alias": "bsInstanceofCase"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsInstanceOfDefaultDirective {
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsInstanceOfContext>, bsInstanceof: BsInstanceOfDirective);
+    throwError(directiveName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfDefaultDirective, [null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsInstanceOfDefaultDirective, "[bsInstanceofDefault]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsInstanceOfModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsInstanceOfModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsInstanceOfModule, [typeof BsInstanceofPipe, typeof BsInstanceOfDirective, typeof BsInstanceofCaseDirective, typeof BsInstanceOfDefaultDirective], [typeof i5.CommonModule], [typeof BsInstanceofPipe, typeof BsInstanceOfDirective, typeof BsInstanceofCaseDirective, typeof BsInstanceOfDefaultDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsInstanceOfModule>;
+}
+
+export { BsInstanceOfContext, BsInstanceOfDefaultDirective, BsInstanceOfDirective, BsInstanceOfModule, BsInstanceofCaseDirective, BsInstanceofPipe, SwitchView };
+export type { AbstractType };

package/let/index.d.ts

@@ -1,2 +1,45 @@
-export * from './directive/let.directive';
-export * from './interfaces';
+import * as i0 from '@angular/core';
+import { ViewContainerRef, TemplateRef } from '@angular/core';
+
+interface BsLetContext<T> {
+    /**
+     * using `bsLet` to enable `as` syntax: `*bsLet="foo as bar"`
+     */
+    bsLet: T;
+    /**
+     * using `$implicit` to enable `let` syntax: `*bsLet="foo; let bar"`
+     */
+    $implicit: T;
+}
+
+declare class BsLetDirective<T> {
+    private viewContainer;
+    private templateRef;
+    private context;
+    private hasView;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<BsLetContext<T>>);
+    set bsLet(value: T);
+    /** @internal */
+    static bsLetUseIfTypeGuard: void;
+    /**
+     * Assert the correct type of the expression bound to the `NgLet` input within the template.
+     *
+     * The presence of this static field is a signal to the Ivy template type check compiler that
+     * when the `NgLet` structural directive renders its template, the type of the expression bound
+     * to `NgLet` should be narrowed in some way. For `NgLet`, the binding expression itself is used to
+     * narrow its type, which allows the strictNullChecks feature of TypeScript to work with `NgLet`.
+     */
+    static ngTemplateGuard_bsLet: 'binding';
+    /**
+     * Asserts the correct type of the context for the template that `NgLet` will render.
+     *
+     * The presence of this method is a signal to the Ivy template type-check compiler that the
+     * `NgLet` structural directive renders its template with a specific context type.
+     */
+    static ngTemplateContextGuard<T>(dir: BsLetDirective<T>, ctx: any): ctx is BsLetContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsLetDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsLetDirective<any>, "[bsLet]", never, { "bsLet": { "alias": "bsLet"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { BsLetDirective };
+export type { BsLetContext };

package/linify/index.d.ts

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

package/list-group/index.d.ts

@@ -1 +1,23 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { QueryList } from '@angular/core';
+import * as i3 from '@angular/common';
+
+declare class BsListGroupItemComponent {
+    classes: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupItemComponent, "bs-list-group-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BsListGroupComponent {
+    items: QueryList<BsListGroupItemComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsListGroupComponent, "bs-list-group", never, {}, {}, ["items"], ["*"], false, never>;
+}
+
+declare class BsListGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsListGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsListGroupModule, [typeof BsListGroupComponent, typeof BsListGroupItemComponent], [typeof i3.CommonModule], [typeof BsListGroupComponent, typeof BsListGroupItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsListGroupModule>;
+}
+
+export { BsListGroupComponent, BsListGroupItemComponent, BsListGroupModule };

package/markdown/index.d.ts

@@ -1,4 +1,37 @@
-export * from './src/bold/bold.pipe';
-export * from './src/italic/italic.pipe';
-export * from './src/strikethrough/strikethrough.pipe';
-export * from './src/underline/underline.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+declare class BsBoldPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsBoldPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsBoldPipe, "bsBold", true>;
+}
+
+declare class BsItalicPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfStars?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsItalicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsItalicPipe, "bsItalic", true>;
+}
+
+declare class BsStrikethroughPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, numberOfTildes?: number, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsStrikethroughPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsStrikethroughPipe, "bsStrikethrough", true>;
+}
+
+declare class BsUnderlinePipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, classList?: string[]): SafeHtml | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsUnderlinePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsUnderlinePipe, "bsUnderline", true>;
+}
+
+export { BsBoldPipe, BsItalicPipe, BsStrikethroughPipe, BsUnderlinePipe };

package/marquee/index.d.ts

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

package/modal/index.d.ts

@@ -1 +1,76 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, Injector, ComponentFactoryResolver, ComponentRef, EventEmitter } from '@angular/core';
+import * as i9 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import * as i8 from '@angular/common';
+import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsModalComponent {
+    constructor(template: TemplateRef<any>);
+    isOpen: boolean;
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalComponent, "bs-modal-content", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalHostComponent implements AfterViewInit, OnDestroy {
+    private overlay;
+    private parentInjector;
+    private portalFactory;
+    private componentFactoryResolver;
+    constructor(overlay: Overlay, parentInjector: Injector, portalFactory: (injector: Injector) => ComponentPortal<BsModalComponent>, componentFactoryResolver: ComponentFactoryResolver);
+    overlayRef: OverlayRef;
+    componentInstance?: ComponentRef<BsModalComponent>;
+    template: TemplateRef<any>;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(value: boolean);
+    isOpenChange: EventEmitter<boolean>;
+    closeOnEscape: boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private onKeyDown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsModalHostComponent, "bs-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, never, false, never>;
+}
+
+declare class BsModalDirective {
+    constructor(template: TemplateRef<any>, host: BsModalHostComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalDirective, "[bsModal]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalHeaderDirective {
+    headerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalHeaderDirective, "[bsModalHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalBodyDirective {
+    bodyClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalBodyDirective, "[bsModalBody]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalFooterDirective {
+    footerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalFooterDirective, "[bsModalFooter]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalCloseDirective {
+    private host;
+    constructor(host: BsModalHostComponent);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsModalCloseDirective, "[bsModalClose]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsModalModule, [typeof BsModalHeaderDirective, typeof BsModalBodyDirective, typeof BsModalFooterDirective, typeof BsModalDirective, typeof BsModalCloseDirective, typeof BsModalComponent, typeof BsModalHostComponent], [typeof i8.NgTemplateOutlet, typeof i9.OverlayModule, typeof i10.BsHasOverlayComponent], [typeof BsModalHeaderDirective, typeof BsModalBodyDirective, typeof BsModalFooterDirective, typeof BsModalDirective, typeof BsModalCloseDirective, typeof BsModalComponent, typeof BsModalHostComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsModalModule>;
+}
+
+export { BsModalBodyDirective, BsModalCloseDirective, BsModalComponent, BsModalDirective, BsModalFooterDirective, BsModalHeaderDirective, BsModalHostComponent, BsModalModule };

package/multiselect/index.d.ts

@@ -1 +1,53 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import * as i5 from '@angular/common';
+import * as i6 from '@angular/forms';
+import * as i7 from '@mintplayer/ng-bootstrap/dropdown';
+import * as i8 from '@mintplayer/ng-bootstrap/toggle-button';
+import * as i9 from '@mintplayer/ng-bootstrap/button-type';
+import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
+import * as i11 from '@mintplayer/ng-focus-on-load';
+
+declare class BsMultiselectComponent<T> {
+    headerTemplate: TemplateRef<any>;
+    footerTemplate: TemplateRef<any>;
+    buttonTemplate: TemplateRef<any>;
+    colors: typeof Color;
+    items: T[];
+    selectedItems: T[];
+    defaultButtonTemplate: TemplateRef<any>;
+    itemChange(item: T, value: boolean | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsMultiselectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsMultiselectComponent<any>, "bs-multiselect", never, { "items": { "alias": "items"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsHeaderTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsHeaderTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsHeaderTemplateDirective<any>, "[bsHeaderTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsFooterTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsFooterTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsFooterTemplateDirective<any>, "[bsFooterTemplate]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsButtonTemplateDirective<T> {
+    constructor(template: TemplateRef<any>, multiselect: BsMultiselectComponent<T>);
+    static ngTemplateContextGuard<TData>(dir: BsButtonTemplateDirective<TData>, ctx: any): ctx is BsRButtonTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsButtonTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsButtonTemplateDirective<any>, "[bsButtonTemplate]", never, {}, {}, never, never, false, never>;
+}
+declare class BsRButtonTemplateContext {
+    $implicit: number;
+}
+
+declare class BsMultiselectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsMultiselectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsMultiselectModule, [typeof BsMultiselectComponent, typeof BsHeaderTemplateDirective, typeof BsFooterTemplateDirective, typeof BsButtonTemplateDirective], [typeof i5.NgTemplateOutlet, typeof i6.FormsModule, typeof i7.BsDropdownModule, typeof i8.BsToggleButtonModule, typeof i9.BsButtonTypeDirective, typeof i10.BsHasOverlayComponent, typeof i11.FocusOnLoadDirective], [typeof BsMultiselectComponent, typeof BsHeaderTemplateDirective, typeof BsFooterTemplateDirective, typeof BsButtonTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsMultiselectModule>;
+}
+
+export { BsButtonTemplateDirective, BsFooterTemplateDirective, BsHeaderTemplateDirective, BsMultiselectComponent, BsMultiselectModule, BsRButtonTemplateContext };