@mintplayer/ng-bootstrap 14.10.1 → 15.0.0

package/popover/src/component/popover.component.d.ts

@@ -0,0 +1,19 @@
+import { TemplateRef } from '@angular/core';
+import { Position } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BsPopoverComponent {
+    constructor(content: TemplateRef<any>);
+    positions: typeof Position;
+    position$: BehaviorSubject<Position>;
+    get position(): Position;
+    set position(value: Position);
+    isVisible$: BehaviorSubject<boolean>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    marginClass$: Observable<string>;
+    template: TemplateRef<any>;
+    positionRelative: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsPopoverComponent, "bs-popover", never, { "position": "position"; "isVisible": "isVisible"; }, {}, never, never, false, never>;
+}

package/popover/src/directives/popover/popover.directive.d.ts

@@ -0,0 +1,27 @@
+import { ConnectedPosition, Overlay } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { AfterViewInit, ElementRef, Injector, OnDestroy, TemplateRef } from '@angular/core';
+import { Position } from '@mintplayer/ng-bootstrap';
+import * as i0 from "@angular/core";
+export 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);
+    private injector;
+    private portal;
+    private overlayRef;
+    private component;
+    position$: BehaviorSubject<Position>;
+    connectedPosition$: Observable<ConnectedPosition>;
+    isVisible$: BehaviorSubject<boolean>;
+    destroyed$: Subject<unknown>;
+    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": "bsPopover"; }, {}, never, never, false, never>;
+}

package/popover/src/directives/popover-body/popover-body.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class BsPopoverBodyDirective {
+    bodyClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverBodyDirective, "[bsPopoverBody]", never, {}, {}, never, never, false, never>;
+}

package/popover/src/directives/popover-header/popover-header.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class BsPopoverHeaderDirective {
+    headerClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsPopoverHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsPopoverHeaderDirective, "[bsPopoverHeader]", never, {}, {}, never, never, false, never>;
+}

package/progress-bar/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/progress-bar/src/progress/progress.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export 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": "height"; "isIndeterminate": "isIndeterminate"; }, {}, never, ["*"], false, never>;
+}

package/progress-bar/src/progress-bar/progress-bar.component.d.ts

@@ -0,0 +1,31 @@
+import { OnDestroy } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BsProgressBarComponent implements OnDestroy {
+    constructor();
+    destroyed$: Subject<unknown>;
+    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;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsProgressBarComponent, "bs-progress-bar", never, { "minimum": "minimum"; "maximum": "maximum"; "value": "value"; "color": "color"; "striped": "striped"; "animated": "animated"; }, {}, never, never, false, never>;
+}

package/range/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/range/src/component/range.component.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BsRangeComponent {
+    constructor();
+    slider: ElementRef<HTMLInputElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsRangeComponent, "bs-range", never, {}, {}, never, never, false, never>;
+}

package/range/src/value-accessor/range-value-accessor.d.ts

@@ -0,0 +1,20 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { BsRangeComponent } from '../component/range.component';
+import * as i0 from "@angular/core";
+export declare class BsRangeValueAccessor implements ControlValueAccessor, AfterViewInit, OnDestroy {
+    private host;
+    constructor(host: BsRangeComponent);
+    destroyed$: Subject<unknown>;
+    onValueChange?: (value: number) => void;
+    onTouched?: () => void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): 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>;
+}

package/rating/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/rating/src/rating.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BsRatingComponent implements OnDestroy {
+    constructor();
+    destroyed$: Subject<unknown>;
+    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);
+    ngOnDestroy(): void;
+    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": "maximum"; "value": "value"; }, { "valueChange": "valueChange"; "starsChange": "starsChange"; }, never, never, false, never>;
+}

package/scheduler/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/scheduler/src/components/resource-group-presenter/resource-group-presenter.component.d.ts

@@ -0,0 +1,26 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Resource, ResourceGroup } from '../../interfaces';
+import { ResourceOrGroup } from '../../interfaces/resource-or-group';
+import { SchedulerStampWithSlots } from '../../interfaces/scheduler-stamp-with-slots';
+import * as i0 from "@angular/core";
+export declare class ResourceGroupPresenterComponent implements OnDestroy {
+    constructor();
+    level: number;
+    resourceOrGroup$: BehaviorSubject<Resource | ResourceGroup | null>;
+    timeSlots$: BehaviorSubject<SchedulerStampWithSlots[]>;
+    isExpanded$: BehaviorSubject<boolean>;
+    data$: Observable<ResourceOrGroup>;
+    colSpan$: Observable<number>;
+    destroyed$: Subject<unknown>;
+    get resourceOrGroup(): Resource | ResourceGroup | null;
+    set resourceGroup(value: Resource | ResourceGroup | null);
+    get timeSlots(): SchedulerStampWithSlots[];
+    set timeSlots(value: SchedulerStampWithSlots[]);
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    toggleExpanded(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceGroupPresenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceGroupPresenterComponent, "bs-resource-group-presenter", never, { "level": "level"; "resourceGroup": "resourceGroup"; "timeSlots": "timeSlots"; "isExpanded": "isExpanded"; }, {}, never, never, false, never>;
+}

package/scheduler/src/components/scheduler/scheduler.component.d.ts

@@ -0,0 +1,86 @@
+import { ElementRef, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { BsCalendarMonthService } from '@mintplayer/ng-bootstrap';
+import { ESchedulerMode } from '../../enums/scheduler-mode';
+import { DragOperation } from '../../interfaces/drag-operation';
+import { PreviewEvent } from '../../interfaces/preview-event';
+import { SchedulerEvent } from '../../interfaces/scheduler-event';
+import { SchedulerEventPart } from '../../interfaces/scheduler-event-part';
+import { SchedulerEventWithParts } from '../../interfaces/scheduler-event-with-parts';
+import { TimeSlot } from '../../interfaces/time-slot';
+import { BsTimelineService } from '../../services/timeline/timeline.service';
+import { ResourceGroup } from '../../interfaces/resource-group';
+import { Resource } from '../../interfaces/resource';
+import { SchedulerStampWithSlots } from '../../interfaces/scheduler-stamp-with-slots';
+import { WeekOptions } from '../../interfaces/week-options';
+import { TimelineOptions } from '../../interfaces/timeline-options';
+import * as i0 from "@angular/core";
+export declare class BsSchedulerComponent implements OnDestroy {
+    private calendarMonthService;
+    private timelineService;
+    constructor(calendarMonthService: BsCalendarMonthService, timelineService: BsTimelineService);
+    resources$: BehaviorSubject<(Resource | ResourceGroup)[]>;
+    events$: Observable<SchedulerEvent[]>;
+    eventParts$: Observable<SchedulerEventWithParts[]>;
+    eventPartsForThisWeek$: Observable<SchedulerEventPart[]>;
+    timelinedEventPartsForThisWeek$: Observable<{
+        total: number;
+        parts: {
+            part: SchedulerEventPart;
+            index: number;
+        }[];
+    }>;
+    weekOptions$: BehaviorSubject<WeekOptions>;
+    timelineOptions$: BehaviorSubject<TimelineOptions>;
+    previewEvent$: BehaviorSubject<PreviewEvent | null>;
+    previewEventParts$: Observable<SchedulerEventWithParts | null>;
+    previewEventPartsForThisWeek$: Observable<SchedulerEventPart[]>;
+    currentWeekOrMonth$: BehaviorSubject<Date>;
+    shownDays$: Observable<Date[]>;
+    daysOfWeekWithTimestamps$: Observable<{
+        start: number;
+        end: number;
+    }>;
+    timeSlotDuration$: BehaviorSubject<number>;
+    timeSlots$: BehaviorSubject<SchedulerStampWithSlots[]>;
+    mouseState$: BehaviorSubject<boolean>;
+    hoveredTimeSlot$: BehaviorSubject<TimeSlot | null>;
+    hoveredEvent$: BehaviorSubject<SchedulerEvent | null>;
+    destroyed$: Subject<unknown>;
+    timeSlotElements: QueryList<ElementRef<HTMLDivElement>>;
+    createTimeslot(date: Date, index: number, duration: number): TimeSlot;
+    getResourcesForGroup(resourceOrGroup: Resource | ResourceGroup): Resource[];
+    modes: typeof ESchedulerMode;
+    mode$: BehaviorSubject<ESchedulerMode>;
+    modeChange: EventEmitter<ESchedulerMode>;
+    get mode(): ESchedulerMode;
+    set mode(value: ESchedulerMode);
+    weekOptionsChange: EventEmitter<WeekOptions>;
+    get weekOptions(): WeekOptions;
+    set weekOptions(value: WeekOptions);
+    timelineOptionsChange: EventEmitter<TimelineOptions>;
+    get timelineOptions(): TimelineOptions;
+    set timelineOptions(value: TimelineOptions);
+    maxInnerHeight: number | null;
+    get resources(): (Resource | ResourceGroup)[];
+    set resources(value: (Resource | ResourceGroup)[]);
+    private addDays;
+    onPreviousWeekOrMonth(): void;
+    onNextWeekOrMonth(): void;
+    private onChangeWeekOrMonth;
+    onHoverEvent(ev: SchedulerEvent | null): void;
+    onLeaveEvent(ev: SchedulerEvent | null): void;
+    operation: DragOperation | null;
+    dragStartTimeslot: TimeSlot | null;
+    onCreateEvent(ev: MouseEvent, slot: TimeSlot): void;
+    randomColor(): string;
+    randomChannel(brightness: number): string;
+    onStartDragEvent(eventPart: SchedulerEventPart, ev: MouseEvent): void;
+    onStartResizeEvent(event: SchedulerEvent | null, position: 'top' | 'bottom'): void;
+    private getHoveredTimeslot;
+    onMousemove(ev: MouseEvent): void;
+    onMouseUp(ev: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSchedulerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSchedulerComponent, "bs-scheduler", never, { "mode": "mode"; "weekOptions": "weekOptions"; "timelineOptions": "timelineOptions"; "maxInnerHeight": "maxInnerHeight"; "resources": "resources"; }, { "modeChange": "modeChange"; "weekOptionsChange": "weekOptionsChange"; "timelineOptionsChange": "timelineOptionsChange"; }, never, never, false, never>;
+}

package/scrollspy/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/scrollspy/src/component/scrollspy.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterContentInit, AfterViewInit, ElementRef, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { BsScrollOffsetService } from '@mintplayer/ng-bootstrap';
+import { BsScrollspyDirective } from '../directives/scrollspy.directive';
+import * as i0 from "@angular/core";
+export declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit, OnDestroy {
+    private scrollOffsetService;
+    private zone;
+    constructor(scrollOffsetService: BsScrollOffsetService, document: any, zone: NgZone);
+    private destroyed$;
+    private viewInit$;
+    private contentInit$;
+    directives: QueryList<BsScrollspyDirective>;
+    anchors: QueryList<ElementRef<HTMLSpanElement>>;
+    doc: Document;
+    activeDirective: BsScrollspyDirective | null;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onWindowScroll(): void;
+    setActiveDirective(): void;
+    scrollToCurrentInSpy(): void;
+    scrollToHeader(directive: BsScrollspyDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsScrollspyComponent, "bs-scrollspy", never, {}, {}, ["directives"], ["*"], false, never>;
+}

package/scrollspy/src/directives/scrollspy.directive.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BsScrollspyDirective {
+    constructor(element: ElementRef);
+    element: ElementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsScrollspyDirective, "[bsScrollspy]", never, {}, {}, never, never, false, never>;
+}

package/select/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/select/src/component/select.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BsSelectSize } from '../types/select-size';
+import * as i0 from "@angular/core";
+export declare class BsSelectComponent implements OnInit {
+    private renderer;
+    constructor(renderer: Renderer2);
+    identifier: number;
+    selectBox: ElementRef<HTMLSelectElement>;
+    ngOnInit(): void;
+    size$: BehaviorSubject<BsSelectSize>;
+    get size(): BsSelectSize;
+    set size(value: BsSelectSize);
+    multiple$: BehaviorSubject<boolean>;
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    numberVisible$: BehaviorSubject<number | null>;
+    get numberVisible(): number | null;
+    set numberVisible(value: number | null);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    sizeClass$: Observable<string | null>;
+    multipleValue$: Observable<boolean | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelectComponent, "bs-select", never, { "identifier": "identifier"; "size": "size"; "multiple": "multiple"; "numberVisible": "numberVisible"; "disabled": "disabled"; }, {}, never, ["*"], false, never>;
+}

package/select/src/value-accessors/select-value-accessor.d.ts

@@ -0,0 +1,44 @@
+import { ElementRef, OnDestroy, Renderer2 } from "@angular/core";
+import { ControlValueAccessor } from "@angular/forms";
+import { BsSelectComponent } from "../component/select.component";
+import * as i0 from "@angular/core";
+export declare class BsSelectValueAccessor implements ControlValueAccessor {
+    private _renderer;
+    private _elementRef;
+    private selectBox;
+    constructor(_renderer: Renderer2, _elementRef: ElementRef, selectBox: BsSelectComponent);
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    registerOnChange(fn: (p: any) => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected setProperty(key: string, value: any): void;
+    hostOnChange(ev: InputEvent): void;
+    hostBlur(ev: Event): void;
+    value: any;
+    optionMap: Map<string, any>;
+    idCounter: number;
+    private compareWithFunction;
+    set compareWith(value: (value1: any, value2: any) => boolean);
+    buildValueString(id: string | null, value: any): string;
+    extractId(valueString: string): string;
+    writeValue(value: any): void;
+    registerOption(): string;
+    getOptionId(value: any): string | null;
+    getOptionValue(valueString: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectValueAccessor, "bs-select", never, { "compareWith": "compareWith"; }, {}, never, never, false, never>;
+}
+export declare class BsSelectOption implements OnDestroy {
+    private element;
+    private renderer;
+    private select;
+    constructor(element: ElementRef, renderer: Renderer2, select: BsSelectValueAccessor);
+    id: string;
+    set ngValue(value: any);
+    set value(value: any);
+    setElementValue(value: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelectOption, [null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSelectOption, "option", never, { "ngValue": "ngValue"; "value": "value"; }, {}, never, never, false, never>;
+}

package/select2/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/select2/src/component/select2.component.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BsSelect2Component {
+    isOpen: boolean;
+    suggestions$: BehaviorSubject<any[]>;
+    isLoading$: BehaviorSubject<boolean>;
+    defaultItemTemplate: TemplateRef<any>;
+    searchBox: ElementRef<HTMLInputElement>;
+    itemsBox: ElementRef<HTMLDivElement>;
+    searchterm: string;
+    suggestions: any[];
+    provideSuggestions: EventEmitter<string>;
+    selectedItems: any[];
+    isFocused: boolean;
+    private charWidth;
+    searchWidth: number;
+    itemTemplate?: TemplateRef<any>;
+    onProvideSuggestions(value: string): void;
+    onSuggestionClicked(suggestion: any): void;
+    onRemoveItem(item: any, event: MouseEvent): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSelect2Component, "bs-select2", never, { "searchterm": "searchterm"; "suggestions": "suggestions"; "selectedItems": "selectedItems"; }, { "provideSuggestions": "provideSuggestions"; }, never, never, false, never>;
+}

package/select2/src/directive/item-template.directive.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import { BsSelect2Component } from '../component/select2.component';
+import * as i0 from "@angular/core";
+export declare class BsItemTemplateDirective {
+    private select2component;
+    constructor(select2component: BsSelect2Component, templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsItemTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsItemTemplateDirective, "[bsItemTemplate]", never, {}, {}, never, never, false, never>;
+}

package/select2/src/select2.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component/select2.component";
+import * as i2 from "./directive/item-template.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@mintplayer/ng-bootstrap/dropdown";
+import * as i6 from "@mintplayer/ng-bootstrap/dropdown-menu";
+import * as i7 from "@mintplayer/ng-bootstrap";
+export declare class BsSelect2Module {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSelect2Module, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSelect2Module, [typeof i1.BsSelect2Component, typeof i2.BsItemTemplateDirective], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i5.BsDropdownModule, typeof i6.BsDropdownMenuModule, typeof i7.BsInListModule], [typeof i1.BsSelect2Component, typeof i2.BsItemTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSelect2Module>;
+}

package/snackbar/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/snackbar/src/component/snackbar.component.d.ts

@@ -0,0 +1,15 @@
+import { AnimationEvent } from '@angular/animations';
+import { EventEmitter, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BsSnackbarComponent {
+    constructor(content: TemplateRef<any>);
+    displayBlock: boolean;
+    width100: boolean;
+    content: TemplateRef<any>;
+    private instance;
+    animationState: string;
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    onAnimationChanged(event: AnimationEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSnackbarComponent, "bs-snackbar", never, {}, {}, never, never, false, never>;
+}

package/snackbar/src/directives/snackbar-close/snackbar-close.directive.d.ts

@@ -0,0 +1,11 @@
+import { BsSnackbarService } from '../../service/snackbar.service';
+import { BsSnackbarComponent } from '../../component/snackbar.component';
+import * as i0 from "@angular/core";
+export declare class BsSnackbarCloseDirective {
+    private snackbarService;
+    constructor(snackbarService: BsSnackbarService);
+    bsSnackbarClose: BsSnackbarComponent;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSnackbarCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsSnackbarCloseDirective, "[bsSnackbarClose]", never, { "bsSnackbarClose": "bsSnackbarClose"; }, {}, never, never, false, never>;
+}