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

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 };

package/scheduler/index.d.ts

@@ -1 +1,231 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { QueryList, ElementRef, EventEmitter, PipeTransform } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BsCalendarMonthService } from '@mintplayer/ng-bootstrap/calendar-month';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i7 from '@angular/common';
+
+declare enum ESchedulerMode {
+    week = 0,
+    timeline = 1
+}
+
+declare enum EDragOperation {
+    none = 0,
+    createEvent = 1,
+    resizeEvent = 2,
+    moveEvent = 3
+}
+
+interface SchedulerEvent {
+    start: Date;
+    end: Date;
+    color: string;
+    description: string;
+}
+
+interface DragOperation {
+    operation: EDragOperation;
+    event: SchedulerEvent;
+    meta: any;
+}
+
+interface PreviewEvent {
+    start: Date;
+    end: Date;
+}
+
+interface SchedulerEventPart {
+    start: Date;
+    end: Date;
+    event: SchedulerEvent | null;
+}
+
+interface SchedulerEventWithParts {
+    event: SchedulerEvent;
+    parts: SchedulerEventPart[];
+}
+
+interface TimeSlot {
+    start: Date;
+    end: Date;
+}
+
+interface TimelineTrack {
+    index: number;
+    events: SchedulerEvent[];
+}
+
+declare class BsTimelineService {
+    splitInParts(event: SchedulerEvent | PreviewEvent): SchedulerEventWithParts;
+    private dateEquals;
+    getTimeline(events: SchedulerEvent[]): TimelineTrack[];
+    private getTimestamps;
+    private trackIsFreeAt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsTimelineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsTimelineService>;
+}
+
+interface Resource {
+    description: string;
+    events: SchedulerEvent[];
+}
+
+interface ResourceGroup {
+    description: string;
+    children: (ResourceGroup | Resource)[];
+}
+
+interface SchedulerStampWithSlots {
+    /** Some meta information, eg. the date or time that all timeslots have in common. */
+    stamp: Date;
+    slots: TimeSlot[];
+}
+
+interface WeekOptions {
+    unitHeight: number;
+}
+
+interface TimelineOptions {
+    unitWidth: number;
+}
+
+declare class BsSchedulerComponent {
+    private sanitizer;
+    private calendarMonthService;
+    private timelineService;
+    constructor(sanitizer: DomSanitizer, calendarMonthService: BsCalendarMonthService, timelineService: BsTimelineService);
+    chevronLeft?: SafeHtml;
+    chevronRight?: SafeHtml;
+    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>;
+    resourceGroupPresenterCounter: number;
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSchedulerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsSchedulerComponent, "bs-scheduler", never, { "mode": { "alias": "mode"; "required": false; }; "weekOptions": { "alias": "weekOptions"; "required": false; }; "timelineOptions": { "alias": "timelineOptions"; "required": false; }; "maxInnerHeight": { "alias": "maxInnerHeight"; "required": false; }; "resources": { "alias": "resources"; "required": false; }; }, { "modeChange": "modeChange"; "weekOptionsChange": "weekOptionsChange"; "timelineOptionsChange": "timelineOptionsChange"; }, never, never, false, never>;
+}
+
+interface ResourceOrGroup {
+    resource: Resource | null;
+    resourceGroup: ResourceGroup | null;
+}
+
+declare class ResourceGroupPresenterComponent {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    chevronDown?: SafeHtml;
+    chevronRight?: SafeHtml;
+    level: number;
+    resourceOrGroup$: BehaviorSubject<Resource | ResourceGroup | null>;
+    timeSlots$: BehaviorSubject<SchedulerStampWithSlots[]>;
+    isExpanded$: BehaviorSubject<boolean>;
+    data$: Observable<ResourceOrGroup>;
+    colSpan$: Observable<number>;
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceGroupPresenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceGroupPresenterComponent, "bs-resource-group-presenter", never, { "level": { "alias": "level"; "required": false; }; "resourceGroup": { "alias": "resourceGroup"; "required": false; }; "timeSlots": { "alias": "timeSlots"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface SchedulerScale {
+    time: number;
+    pixels: number;
+    markerSize: number;
+}
+
+declare const availableScales: SchedulerScale[];
+
+declare class BsSecondsTimespanPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSecondsTimespanPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsSecondsTimespanPipe, "bsSecondsTimespan", false>;
+}
+
+declare class BsSecondsTodayOffsetPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSecondsTodayOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsSecondsTodayOffsetPipe, "bsSecondsTodayOffset", false>;
+}
+
+declare class DateOffsetPipe implements PipeTransform {
+    transform(value: SchedulerEventPart): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateOffsetPipe, "dateOffset", false>;
+}
+
+declare class DayOfWeekPipe implements PipeTransform {
+    transform(value: SchedulerEventPart | SchedulerEvent): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayOfWeekPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DayOfWeekPipe, "dayOfWeek", false>;
+}
+
+declare class BsSchedulerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsSchedulerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSchedulerModule, [typeof BsSchedulerComponent, typeof BsSecondsTimespanPipe, typeof BsSecondsTodayOffsetPipe, typeof DateOffsetPipe, typeof DayOfWeekPipe, typeof ResourceGroupPresenterComponent], [typeof i7.CommonModule], [typeof BsSchedulerComponent, typeof ResourceGroupPresenterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsSchedulerModule>;
+}
+
+export { BsSchedulerComponent, BsSchedulerModule, ESchedulerMode, ResourceGroupPresenterComponent, availableScales };
+export type { Resource, ResourceGroup, SchedulerEvent, TimelineOptions, WeekOptions };

package/scrollspy/index.d.ts

@@ -1 +1,46 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, AfterContentInit, NgZone, QueryList } from '@angular/core';
+import { ExtraOptions } from '@angular/router';
+
+declare class BsScrollOffsetService {
+    private routerConfig;
+    constructor(routerConfig: ExtraOptions);
+    getScrollOffset(): [number, number];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollOffsetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsScrollOffsetService>;
+}
+
+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>;
+}
+
+declare class BsScrollspyComponent implements AfterViewInit, AfterContentInit {
+    private scrollOffsetService;
+    private zone;
+    constructor(scrollOffsetService: BsScrollOffsetService, document: any, zone: NgZone);
+    private viewInit$;
+    private contentInit$;
+    directives: QueryList<BsScrollspyDirective>;
+    anchors: QueryList<ElementRef<HTMLSpanElement>>;
+    doc: Document;
+    activeDirective: BsScrollspyDirective | null;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): 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>;
+}
+
+declare class BsScrollspyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsScrollspyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsScrollspyModule, [typeof BsScrollspyComponent, typeof BsScrollspyDirective], never, [typeof BsScrollspyComponent, typeof BsScrollspyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsScrollspyModule>;
+}
+
+export { BsScrollOffsetService, BsScrollspyComponent, BsScrollspyDirective, BsScrollspyModule };