import * as i0 from '@angular/core';
import { OnInit, OnDestroy, ChangeDetectorRef, EventEmitter, AfterViewInit } from '@angular/core';
import * as i10 from 'ngx-bootstrap/popover';
import { DatasourceComponent } from '@sowatech/shared/ds-datasource';
import { LoggerService } from '@sowatech/shared/logger';
import moment, { unitOfTime, Moment } from 'moment';
import * as i8 from 'ngx-scrollbar';
import { NgScrollbar } from 'ngx-scrollbar';
import { Subscription } from 'rxjs';
import * as i9 from '@sowatech/shared/swt-controls';
import { LoadingIndicatorComponent, DropDownContainerComponent } from '@sowatech/shared/swt-controls';
import { AvailbleBSPositions } from 'ngx-bootstrap/positioning';
import * as i6 from '@angular/common';
import * as i7 from '@angular/forms';

type TDestRowType = 'body' | 'header-month' | 'header-text' | 'header-name-of-day';

type TSchedulerVariantType = 'calendarMonth' | 'weekMonth' | 'isoWeekMonth' | 'isoWeek';

declare class MonthItem {
    constructor(monthMoment: moment.Moment, numOfSlots?: number);
    dateIso: string;
    name: string;
    class: string;
    numOfSlots: number;
}
declare class DayItem {
    constructor(dayMoment: moment.Moment, numOfSlots?: number, dayNameFormat?: string);
    dateOfDay: Date;
    dateIso: string;
    name: string;
    class: string;
    numOfSlots: number;
}
declare class TimeLineSlotHeader {
    timelineSlotUnitOfTime: unitOfTime.Diff;
    timeStart: Moment;
    timeEnd: Moment;
    slotSpan: number;
    text: string;
    timeInfoTitle: string;
    cssClass: string;
    cellInfoTitle: string;
    constructor(timeStart: Moment, timelineSlotUnitOfTime: unitOfTime.Diff, colspan?: number);
    appendCellData(cssClass: string, cellTitle: string): void;
    setNewEndTime(timeEnd: Moment): void;
    isEndOfDay(visibleHoursUntil: number): boolean;
    get title(): string;
}
declare class TimeLineSlot {
    private timelineSlotUnitOfTime;
    constructor(slotMoment: moment.Moment, timelineSlotUnitOfTime: moment.unitOfTime.Diff);
    private slotMoment;
    private get slotEndMoment();
    get date(): Date;
    isEndOfDay(visibleHoursUntil: number): boolean;
    isLastSlotCell(span: number): boolean;
    headerText: string;
    headerTitle: string;
    nameOfDay: string;
    class: string;
    slotDateTimeIso: string;
    slotDateIso: string;
    isFirstSlotCell: boolean;
    cells: object;
    getCell(lineId: any | 'HEADER' | 'ALL'): TimeLineSlotCell;
    getOrCreateCell(lineId: any | 'HEADER' | 'ALL'): TimeLineSlotCell;
    isSlotForDate(date: Date | string, timeLineVariant: TSchedulerVariantType): boolean;
    isSlotIntersectingDateInterval(dateFrom: Date | string, dateTo: Date | string): boolean;
    tryFillCellData(dataItems: Array<TimelineSlotDataItem>, timeLineVariant: TSchedulerVariantType, getSlotCellLineId: (timelineSlotDataItem: TimelineSlotDataItem) => any): void;
    headerCellTitle(): string;
    cellTitle(lineId?: any): string;
    headerCellClass(): string;
    cellClass(lineId?: any): string;
}
declare class TimeLineSlotCell {
    constructor(lineId: any, dataItem?: TimelineSlotDataItem);
    title: string;
    text: string;
    class: string;
    lineId: any;
    add(dataItem: TimelineSlotDataItem): void;
    dataItems: Array<TimelineSlotDataItem>;
    appointments?: Array<AppointmentModel>;
    addAppointment(scheduledItem: IScheduledItem): void;
}
declare class TimeSlotCellClickEvent {
    lineId: any;
    date: Date;
    dataItems: Array<TimelineSlotDataItem>;
}
declare class TimelineSlotDataItem {
    resourceId?: any;
    date: Date;
    class?: string;
    title?: string;
    text?: string;
}
interface IScheduledItem {
    start: Date | string;
    end: Date | string;
    resourceId?: string;
    text?: string;
    title?: string;
    class?: string;
    styles?: {
        [klass: string]: string;
    };
    ident?: string | number;
    bgColor?: string;
    bgStriped?: boolean;
    borderWidth?: string;
    borderColor?: string;
}
declare class ScheduledItemModel implements IScheduledItem {
    resourceId: string;
    left: number;
    width: number;
    height: number;
    top: number;
    start: Date | string;
    end: Date | string;
    text: string;
    title: string;
    class: string;
    styles: {
        [klasse: string]: string;
    };
    ident: string | number;
    cellRowIndex: number;
    bgColor?: string;
    bgStriped?: boolean;
    borderWidth?: string;
    borderColor?: string;
    get diffSeconds(): number;
    get diffDays(): number;
}
declare class ScheduledItemClickEvent {
    resourceId?: any;
    start: Date | string;
    end: Date | string;
    ident: any;
    text: string;
}
declare class ScheduledItemDragDropEvent {
    original: DragEvent;
    destRowType: TDestRowType;
    destResourceId?: any;
    destStart?: Date | string;
    destEnd?: Date | string;
    constructor(original: DragEvent, item: IScheduledItem, destRowType?: TDestRowType, destResourceId?: any, destStart?: Date | string, destEnd?: Date | string);
    ident: any;
    text: string;
    srcResourceId?: any;
    srcStart: Date | string;
    srcEnd: Date | string;
}
declare class AppointmentModel {
    constructor(scheduledItem: IScheduledItem, lineId: any);
    lineId: any;
    start: Date;
    end: Date;
    text: string;
    class: string;
    title: string;
    ident: string | number;
    resourceId?: string;
}

type TScheduledItemsDateFormat = 'dateTime' | 'date';

type THeaderSlotSpan = 1 | 2 | 3 | 4 | 6 | 8 | 12 | 24;
declare abstract class SchedulerTimelineBase implements OnInit, OnDestroy {
    protected logger: LoggerService;
    protected changeDetectorRef: ChangeDetectorRef;
    constructor(logger: LoggerService, changeDetectorRef: ChangeDetectorRef);
    protected subscriptions: Subscription[];
    protected onInitCompleted: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    refresh(): void;
    tableWidth: number;
    protected tableCustomColumnsWidth: number;
    headerHeight: number;
    private numOfHeaderRows;
    headerRowHeight: number;
    headerSlotSpan: number;
    showNameOfMonth: boolean;
    showNameOfDay: boolean;
    cellPadding: number;
    small: boolean;
    rowHeight: number;
    protected setVariant(value: TSchedulerVariantType): void;
    protected variant: TSchedulerVariantType;
    protected setSlotUnitOfTime(unit: moment.unitOfTime.Diff, visibleRangeFrom?: string, visibleRangeTo?: string): void;
    protected timelineSlotUnitOfTime: moment.unitOfTime.Diff;
    protected visibleHoursFrom: number;
    visibleHoursUntil: number;
    private timeLineDate;
    setTimeLineDate(value: Date | string): void;
    protected timeLineStartMoment: moment.Moment;
    protected timeLineEndMoment: moment.Moment;
    get timeLineStart(): Date;
    get timeLineEnd(): Date;
    monthItems: MonthItem[];
    dayItems: DayItem[];
    protected setSlotWidth(value: number): void;
    timeLineSlotWidth: number;
    get timeLineSlotOuterWidth(): number;
    timeLineSlotNumber: number;
    timeLineSlotHeaders: Array<TimeLineSlotHeader>;
    timeLineSlots: Array<TimeLineSlot>;
    private recalcTimeLine;
    protected recalcWidthsAndHeights(): void;
    setSlotDataItems(values: Array<TimelineSlotDataItem>): void;
    private _slotDataItems;
    timelineSlotsRefreshed: EventEmitter<void>;
    refreshTimelineSlots(): void;
    private buildDayItems;
    private buildMonthItems;
    private buildTimelineSlotMoments;
    protected isVisibleSlotMoment(slotMoment: moment.Moment): boolean;
    cellClick: EventEmitter<TimeSlotCellClickEvent>;
    onCellClick(event: MouseEvent, lineId: any, slot: TimeLineSlot): void;
    protected findTimeLineSlot(arg: Date | string): TimeLineSlot;
    protected findTimeLineSlots(argFrom: Date | string, argTo: Date | string): TimeLineSlot[];
    protected findTimeLineSlotCell(date: Date | string, lineId: string | number): TimeLineSlotCell;
    protected getDateOfCell(slot: TimeLineSlot, lineId: string | number): Date;
    cellClass(slot: TimeLineSlot, lineId: string | number): string;
    protected abstract getSlotCellLineId(timelineSlotDataItem: TimelineSlotDataItem): string | number;
    protected abstract getSlotCellLineId(scheduledItem: IScheduledItem): string | number;
    scheduledItemsDateFormat: TScheduledItemsDateFormat;
    protected formatScheduledItemsDate(src: Date | string): Date | string;
    scheduledItemsAsAppointments: boolean;
    setScheduledItems(values: Array<IScheduledItem>): void;
    protected scheduledDataItems: Array<IScheduledItem>;
    items: Array<ScheduledItemModel>;
    private assertFixedSlotWidth;
    refreshItems(): void;
    protected refreshScheduledItems(): void;
    protected abstract createScheduledItemModel(value: IScheduledItem): ScheduledItemModel;
    itemClick: EventEmitter<ScheduledItemClickEvent>;
    onItemClick(event: Event, item: ScheduledItemModel): void;
    setItemActive(itemIdent: any): any;
    setItemActive(item: ScheduledItemModel): any;
    removeItemActive(item: ScheduledItemModel): void;
    clearItemActive(): void;
    itemDrop: EventEmitter<ScheduledItemDragDropEvent>;
    itemDragStart: EventEmitter<ScheduledItemDragDropEvent>;
    itemDragOver: EventEmitter<ScheduledItemDragDropEvent>;
    allowDragItems: boolean;
    onItemDragStart(event: DragEvent, item: ScheduledItemModel): void;
    private dataTransferDragItemDummy;
    onItemDragOver(event: DragEvent): void;
    onItemDrop(event: DragEvent): void;
    private createScheduledItemDragDropEventData;
    private getDropTargetAttr;
    protected refreshCellAppointments(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerTimelineBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SchedulerTimelineBase, never, never, {}, {}, never, never, true, never>;
}

type UnitOfTimeWithRange = `${moment.unitOfTime.Diff}:${number}-${number}`;
declare class SchedulerTimelineComponent extends SchedulerTimelineBase implements OnInit, OnDestroy, AfterViewInit {
    constructor(logger: LoggerService, changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    headerHeight: number;
    headerSlotSpan: THeaderSlotSpan;
    small: boolean;
    rowHeight: number;
    showNameOfMonth: boolean;
    showNameOfDay: boolean;
    maxHeight: string;
    stickyHeader: boolean;
    set _variant(value: TSchedulerVariantType);
    set _timeLineDate(value: Date | string);
    /**standard="days"; alternative: "hours", "hours:9-18" */
    set _slotUnitOfTime(value: moment.unitOfTime.Diff | UnitOfTimeWithRange);
    scheduledItemRoundFraction: number;
    protected get timelineSecondsPerSlot(): number;
    set _slotWidth(value: number);
    set _slotItems(values: Array<TimelineSlotDataItem>);
    cellClick: EventEmitter<TimeSlotCellClickEvent>;
    itemClick: EventEmitter<ScheduledItemClickEvent>;
    itemDrop: EventEmitter<ScheduledItemDragDropEvent>;
    itemDragStart: EventEmitter<ScheduledItemDragDropEvent>;
    itemDragOver: EventEmitter<ScheduledItemDragDropEvent>;
    set _scheduledItems(values: Array<IScheduledItem>);
    scheduledItemsDateFormat: TScheduledItemsDateFormat;
    scheduledItemMarginHorizontal: number;
    scheduledItemMarginLeft: number;
    allowDragItems: boolean;
    showResourceColumn: boolean;
    resourceHeaderText: string;
    set setResourceColWidthTotal(value: number);
    private resourceColOuterWidth;
    resourceColWidth: number;
    protected recalcWidthsAndHeights(): void;
    scrolledToPosition: EventEmitter<ScrollEvent>;
    scroll(event: any): void;
    scrollbar: NgScrollbar;
    private scrollEventBlocked;
    scrollToPosition(posX: number, posY: number): void;
    resourceIdField: string;
    resourceNameField: string;
    set setListDatasource(value: DatasourceComponent);
    resourceDatasource: DatasourceComponent;
    protected refreshScheduledItems(): void;
    private cellRowInfos;
    private getScheduledItemCellRowInfos;
    protected createScheduledItemModel(scheduledItem: IScheduledItem): ScheduledItemModel;
    private calculateScheduledItemLeftEnd;
    private calculateScheduledItemRightEnd;
    private buildScheduledItemCssClassOpen;
    private date2Px;
    private seconds2Px;
    private roundPxToSlotWidth;
    private get timeLineSecondPerPx();
    private calculateHiddenSeconds;
    protected getSlotCellLineId(scheduledItem: IScheduledItem): any;
    protected getSlotCellLineId(timelineSlotDataItem: TimelineSlotDataItem): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerTimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerTimelineComponent, "scheduler-timeline", never, { "headerHeight": { "alias": "headerHeight"; "required": false; }; "headerSlotSpan": { "alias": "headerSlotSpan"; "required": false; }; "small": { "alias": "small"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "showNameOfMonth": { "alias": "showNameOfMonth"; "required": false; }; "showNameOfDay": { "alias": "showNameOfDay"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "_variant": { "alias": "variant"; "required": false; }; "_timeLineDate": { "alias": "date"; "required": false; }; "_slotUnitOfTime": { "alias": "slotUnitOfTime"; "required": false; }; "scheduledItemRoundFraction": { "alias": "scheduledItemRoundFraction"; "required": false; }; "_slotWidth": { "alias": "slotWidth"; "required": false; }; "_slotItems": { "alias": "slotItems"; "required": false; }; "_scheduledItems": { "alias": "scheduledItems"; "required": false; }; "scheduledItemsDateFormat": { "alias": "scheduledItemsDateFormat"; "required": false; }; "scheduledItemMarginHorizontal": { "alias": "scheduledItemMarginHorizontal"; "required": false; }; "scheduledItemMarginLeft": { "alias": "scheduledItemMarginLeft"; "required": false; }; "allowDragItems": { "alias": "allowDragItems"; "required": false; }; "showResourceColumn": { "alias": "showResourceColumn"; "required": false; }; "resourceHeaderText": { "alias": "resourceHeaderText"; "required": false; }; "setResourceColWidthTotal": { "alias": "resourceColWidth"; "required": false; }; "resourceIdField": { "alias": "idfield"; "required": false; }; "resourceNameField": { "alias": "resourceNameField"; "required": false; }; "setListDatasource": { "alias": "datasource"; "required": false; }; }, { "cellClick": "cellClick"; "itemClick": "itemClick"; "itemDrop": "itemDrop"; "itemDragStart": "itemDragStart"; "itemDragOver": "itemDragOver"; "scrolledToPosition": "scrolledToPosition"; }, never, never, false, never>;
}
declare class ScrollEvent {
    posX: number;
    posY: number;
}

declare class SchedulerCalendarComponent extends SchedulerTimelineBase implements OnInit, OnDestroy {
    constructor(logger: LoggerService, changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    loadingIndicator: LoadingIndicatorComponent;
    headerHeight: number;
    small: boolean;
    rowHeight: number;
    showNameOfMonth: boolean;
    showNameOfDay: boolean;
    set _variant(value: TSchedulerVariantType);
    set _timeLineDate(value: Date | string);
    set _slotWidth(value: number);
    set _slotItems(values: Array<TimelineSlotDataItem>);
    cellClick: EventEmitter<TimeSlotCellClickEvent>;
    itemClick: EventEmitter<ScheduledItemClickEvent>;
    timelineSlotsRefreshed: EventEmitter<void>;
    set _scheduledItems(values: Array<IScheduledItem>);
    scheduledItemsAsAppointments: boolean;
    protected recalcWidthsAndHeights(): void;
    resourceHeaderText: string;
    protected createScheduledItemModel(value: IScheduledItem): ScheduledItemModel;
    showTimeIntervalColumn: boolean;
    set _timeIntervalColOuterWidth(value: number);
    private timeIntervalColOuterWidth;
    timeIntervalColWidth: number;
    set _timeIntervalMinutes(value: number);
    private timeIntervalMinutes;
    set _timeRangeStartHour(value: number);
    private timeRangeStartHour;
    set _timeRangeEndHour(value: number);
    private timeRangeEndHour;
    timeIntervals: TimeInterval[];
    private createTimeIntervals;
    private findTimeInterval;
    protected getSlotCellLineId(scheduledItem: IScheduledItem): any;
    protected getSlotCellLineId(timelineSlotDataItem: TimelineSlotDataItem): any;
    protected getDateOfCell(slot: TimeLineSlot, lineId: any): Date;
    dateTime2TimeValue(date: Date | string): number;
    timeValue2DateTime(timeValue: number, dateOfDay: Date): Date;
    getTimeIntervalsForDate(date: Date): Date[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerCalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerCalendarComponent, "scheduler-calendar", never, { "headerHeight": { "alias": "headerHeight"; "required": false; }; "small": { "alias": "small"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "showNameOfMonth": { "alias": "showNameOfMonth"; "required": false; }; "showNameOfDay": { "alias": "showNameOfDay"; "required": false; }; "_variant": { "alias": "variant"; "required": false; }; "_timeLineDate": { "alias": "date"; "required": false; }; "_slotWidth": { "alias": "slotWidth"; "required": false; }; "_slotItems": { "alias": "slotItems"; "required": false; }; "_scheduledItems": { "alias": "scheduledItems"; "required": false; }; "scheduledItemsAsAppointments": { "alias": "scheduledItemsAsAppointments"; "required": false; }; "showTimeIntervalColumn": { "alias": "showTimeIntervalColumn"; "required": false; }; "_timeIntervalColOuterWidth": { "alias": "timeIntervalColWidth"; "required": false; }; "_timeIntervalMinutes": { "alias": "timeIntervalMinutes"; "required": false; }; "_timeRangeStartHour": { "alias": "timeRangeStartHour"; "required": false; }; "_timeRangeEndHour": { "alias": "timeRangeEndHour"; "required": false; }; }, { "cellClick": "cellClick"; "itemClick": "itemClick"; "timelineSlotsRefreshed": "timelineSlotsRefreshed"; }, never, never, false, never>;
}
declare class TimeInterval {
    constructor(minute: number);
    hour: number;
    hourMinute: number;
    ident: number;
    text: string;
}

declare class SchedulerMonthSelectorComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    months: Array<MonthsViewModel>;
    onChanged: EventEmitter<SelectedMonth>;
    set selectedMonth(value: SelectedMonth);
    get selectedMonth(): SelectedMonth;
    private _selectedMonth;
    private _date;
    get date(): Date;
    selectMonth(monthIndex: TMonth$1, year?: number): void;
    increaseYear(): void;
    decreaseYear(): void;
    private selectedMonthChanged;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerMonthSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerMonthSelectorComponent, "scheduler-month-selector", never, { "selectedMonth": { "alias": "selectedMonth"; "required": false; }; }, { "onChanged": "onChanged"; }, never, never, false, never>;
}
declare enum TMonth$1 {
    Jan = 0,
    Feb = 1,
    Mar = 2,
    Apr = 3,
    May = 4,
    Jun = 5,
    Jul = 6,
    Aug = 7,
    Sep = 8,
    Oct = 9,
    Nov = 10,
    Dec = 11
}
declare class MonthsViewModel {
    constructor(text: string, value: number);
    text: string;
    monthIndex: number;
    cssClass: string;
}
declare class SelectedMonth {
    constructor(date: Date);
    constructor(monthIndex?: TMonth$1, year?: number);
    monthIndex: number;
    year: number;
    get date(): Date;
    get dateEndOfMonth(): Date;
}

declare class SchedulerWeekSelectorComponent implements OnInit {
    private logger;
    constructor(logger: LoggerService);
    ngOnInit(): void;
    selectedMonth: any;
    private onInitFinished;
    private month;
    private year;
    selectedDateInterval: Date;
    weeks: Array<WeekViewModel>;
    monthOverview: MonthOverviewModel;
    invalidDate: boolean;
    previousMonthWidth: number;
    nextMonthWidth: number;
    onChanged: EventEmitter<SelectedWeek>;
    datedropdown: DropDownContainerComponent;
    showDate: boolean;
    showCW: boolean;
    dateFormat: string;
    calendarPlacement: AvailbleBSPositions;
    set date(value: Date);
    get date(): Date;
    setDate(value: Date): void;
    selectedDateIntervalChanged(dateIso: Date | string): void;
    inputValueChanged(dateIso: string): void;
    getMonthOfIsoweek(year: number, isoWeek: number): TMonth;
    getFirstIsoWeekOfMonth(year: number, month: TMonth): number;
    getIsoWeeksOfMonth(year: number, month: TMonth): Array<number>;
    initWeeks(selectIsoWeek: number): void;
    clickWeek(week: WeekViewModel): void;
    getDayWidthPercent(amountOfWeeksInMonth: number): number;
    getNumOfDaysOfIsoWeekNotInMonth(isoWeek: number, month: TMonth): number;
    initMonthDisplay(amountOfWeeks: number): void;
    selectedWeek: SelectedWeek;
    selectWeek(year: number, isoWeek: number): void;
    nextMonth(): void;
    previousMonth(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerWeekSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerWeekSelectorComponent, "scheduler-week-selector", never, { "showDate": { "alias": "showDate"; "required": false; }; "showCW": { "alias": "showCW"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "calendarPlacement": { "alias": "calendarPlacement"; "required": false; }; "date": { "alias": "date"; "required": false; }; }, { "onChanged": "onChanged"; }, never, never, false, never>;
}
declare enum TMonth {
    Jan = 0,
    Feb = 1,
    Mar = 2,
    Apr = 3,
    May = 4,
    Jun = 5,
    Jul = 6,
    Aug = 7,
    Sep = 8,
    Oct = 9,
    Nov = 10,
    Dec = 11
}
declare class WeekViewModel {
    constructor(year: number, isoWeek: number);
    isoWeek: number;
    year: number;
    date: Date;
    private setDate;
}
declare class SelectedWeek {
    constructor(year?: number, isoWeek?: number);
    isoWeek: number;
    year: number;
    get month(): number;
    get date(): Date;
    get dateEndOfWeek(): Date;
}
declare class MonthOverviewModel {
    constructor(year: number, month: TMonth);
    month: Date;
    previousMonth: Date;
    nextMonth: Date;
    dateFormatPM: string;
    dateFormatNM: string;
}

declare class SchedulerDateSelectorComponent implements OnInit {
    private logger;
    dateOfStartTimeFrame: Date;
    dateOfEndTimeFrame: Date;
    showDate: boolean;
    showCW: boolean;
    dateFormat: string;
    selector: 'week' | 'month';
    calendarPlacement: AvailbleBSPositions;
    allowUserSwitch: boolean;
    showTodayButton: boolean;
    set date(value: Date);
    get date(): Date;
    private dateSignal;
    private _selectedMonth;
    set selectedMonth(value: SelectedMonth);
    get selectedMonth(): SelectedMonth;
    onChangedDate: EventEmitter<SelectedMonth | SelectedWeek>;
    onChangedSelector: EventEmitter<"month" | "week">;
    protected weekSelector: SchedulerWeekSelectorComponent;
    constructor(logger: LoggerService);
    ngOnInit(): void;
    private initDateTimeFrames;
    private setSelectedMonth;
    private setSelectedDate;
    protected setDateToToday(): void;
    protected isToday: i0.Signal<boolean>;
    toggleSelector(): void;
    private setDateTimeFrames;
    onChangedWeek(selectedWeek: SelectedWeek): void;
    onChangedMonth(selectedMonth: SelectedMonth): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerDateSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerDateSelectorComponent, "scheduler-date-selector", never, { "showDate": { "alias": "showDate"; "required": false; }; "showCW": { "alias": "showCW"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "selector": { "alias": "selector"; "required": false; }; "calendarPlacement": { "alias": "calendarPlacement"; "required": false; }; "allowUserSwitch": { "alias": "allowUserSwitch"; "required": false; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; }; "date": { "alias": "date"; "required": false; }; "selectedMonth": { "alias": "selectedMonth"; "required": false; }; }, { "onChangedDate": "onChangedDate"; "onChangedSelector": "onChangedSelector"; }, never, never, false, never>;
    static ngAcceptInputType_showTodayButton: unknown;
}

declare class SchedulerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SchedulerModule, [typeof SchedulerTimelineComponent, typeof SchedulerCalendarComponent, typeof SchedulerMonthSelectorComponent, typeof SchedulerWeekSelectorComponent, typeof SchedulerDateSelectorComponent], [typeof i6.CommonModule, typeof i7.FormsModule, typeof i8.NgScrollbarModule, typeof i9.SwtControlsModule, typeof i10.PopoverModule], [typeof SchedulerTimelineComponent, typeof SchedulerCalendarComponent, typeof SchedulerMonthSelectorComponent, typeof SchedulerWeekSelectorComponent, typeof SchedulerDateSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SchedulerModule>;
}

export { ScheduledItemClickEvent, ScheduledItemDragDropEvent, SchedulerCalendarComponent, SchedulerDateSelectorComponent, SchedulerModule, SchedulerMonthSelectorComponent, SchedulerTimelineBase, SchedulerTimelineComponent, SchedulerWeekSelectorComponent, ScrollEvent, SelectedMonth, SelectedWeek, TimeInterval, TimeSlotCellClickEvent, TimelineSlotDataItem };
export type { IScheduledItem, THeaderSlotSpan, TSchedulerVariantType };