import * as i0 from '@angular/core';
import { OnInit, OnChanges, OnDestroy, TemplateRef, EventEmitter, ChangeDetectorRef, AfterContentChecked, ElementRef, AfterViewInit, SimpleChanges, PipeTransform, InjectionToken, ModuleWithProviders } from '@angular/core';
import { MediaMatcher } from '@angular/cdk/layout';
import { Subject, Subscription } from 'rxjs';
import { EventColor, WeekViewHourSegment, WeekViewHour } from 'calendar-utils';
import { ResizeEvent } from 'angular-resizable-element';
import * as i11 from 'angular-calendar';
import { CalendarEventTimesChangedEventType, DateAdapter, CalendarEventTitleFormatter, CalendarDateFormatter, DateFormatterParams, CalendarView } from 'angular-calendar';
import { DropEvent, DragMoveEvent, DragEndEvent } from 'angular-draggable-droppable';
import * as i10 from '@angular/common';

/**
 * Auth configuration.
 */
declare class SchedulerConfig {
    locale?: string;
    headerDateFormat?: 'weekNumber' | 'daysRange';
    logEnabled?: boolean;
    constructor(config?: SchedulerConfig);
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchedulerConfig>;
}

interface CalendarSchedulerEvent {
    id: string;
    start: Date;
    end?: Date;
    title: string;
    content?: string;
    color: EventColor;
    actions?: CalendarSchedulerEventAction[];
    status?: CalendarSchedulerEventStatus;
    cssClass?: string;
    isDisabled?: boolean;
    isClickable?: boolean;
    isCancelled?: boolean;
    resizable?: {
        beforeStart?: boolean;
        afterEnd?: boolean;
    };
    draggable?: boolean;
}
type CalendarSchedulerEventStatus = 'ok' | 'warning' | 'danger';
interface CalendarSchedulerEventAction {
    when?: 'enabled' | 'disabled' | 'cancelled';
    label: string;
    title: string;
    cssClass?: string;
    onClick(event: CalendarSchedulerEvent): void;
}

interface SchedulerEventTimesChangedEvent {
    event: CalendarSchedulerEvent;
    newStart: Date;
    newEnd?: Date;
    type?: CalendarEventTimesChangedEventType;
}

interface SchedulerViewEvent {
    event: CalendarSchedulerEvent;
    top?: number;
    height?: number;
    left?: number;
    width?: number;
    startsBeforeDay?: boolean;
    endsAfterDay?: boolean;
}

interface SchedulerViewHourSegment {
    segment: WeekViewHourSegment;
    date: Date;
    events: SchedulerViewEvent[];
    isDisabled: boolean;
    isCancelled: boolean;
    backgroundColor?: string;
    cssClass?: string;
}

interface SchedulerViewHour {
    hour: WeekViewHour;
    date: Date;
    events: SchedulerViewEvent[];
    segments: SchedulerViewHourSegment[];
    backgroundColor?: string;
    cssClass?: string;
}

interface SchedulerViewDay {
    date: Date;
    events: SchedulerViewEvent[];
    isPast: boolean;
    isToday: boolean;
    isFuture: boolean;
    isWeekend: boolean;
    inMonth: boolean;
    backgroundColor?: string;
    cssClass?: string;
    hours: SchedulerViewHour[];
}

interface SchedulerView {
    days: SchedulerViewDay[];
    period: SchedulerViewPeriod;
}
interface SchedulerViewPeriod {
    start: Date;
    end: Date;
    events: CalendarSchedulerEvent[];
}

declare enum DAYS_OF_WEEK {
    SUNDAY = 0,
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6
}
declare const DAYS_IN_WEEK: number;
declare const HOURS_IN_DAY: number;
declare const MINUTES_IN_HOUR: number;
declare const SECONDS_IN_DAY: number;
declare const DEFAULT_HOUR_SEGMENT_HEIGHT_PX = 40;
declare const DEFAULT_EVENT_WIDTH = 1;
declare const DEFAULT_HOUR_SEGMENTS = 2;
interface Time {
    hour: number;
    minute: number;
}
interface GetSchedulerViewHourGridArgs {
    viewDate: Date;
    hourSegments: number;
    dayStart: Time;
    dayEnd: Time;
}
declare function getSchedulerViewHourGrid(dateAdapter: DateAdapter, { viewDate, hourSegments, dayStart, dayEnd }: GetSchedulerViewHourGridArgs): WeekViewHour[];
interface GetSchedulerViewArgs {
    events?: CalendarSchedulerEvent[];
    viewDate: Date;
    viewDays: number;
    hourSegments: 1 | 2 | 4 | 6;
    weekStartsOn: number;
    startsWithToday: boolean;
    dayStart: Time;
    dayEnd: Time;
    weekendDays?: number[];
    excluded?: number[];
    eventWidth: number;
    hourSegmentHeight: number;
    logEnabled?: boolean;
}
declare function getSchedulerView(dateAdapter: DateAdapter, moment: any, { events, viewDate, viewDays, weekStartsOn, startsWithToday, excluded, hourSegments, dayStart, dayEnd, weekendDays, hourSegmentHeight, eventWidth, logEnabled, }: GetSchedulerViewArgs): SchedulerView;
interface GetSchedulerViewDaysArgs {
    viewDate: Date;
    viewDays: number;
    weekStartsOn: number;
    startsWithToday: boolean;
    excluded?: number[];
    weekendDays?: number[];
}
declare function getSchedulerViewDays(dateAdapter: DateAdapter, { viewDate, viewDays, weekStartsOn, startsWithToday, excluded, weekendDays }: GetSchedulerViewDaysArgs): SchedulerViewDay[];
interface GetEventsInPeriodArgs {
    events: CalendarSchedulerEvent[];
    periodStart: Date;
    periodEnd: Date;
}
interface GetSchedulerEventsInPeriodArgs {
    events: SchedulerViewEvent[];
    periodStart: Date;
    periodEnd: Date;
}

declare class CalendarSchedulerUtils {
    private dateAdapter;
    protected moment: any;
    constructor(dateAdapter: DateAdapter, moment: any);
    getSchedulerViewHourGrid(args: GetSchedulerViewHourGridArgs): WeekViewHour[];
    getSchedulerViewDays(args: GetSchedulerViewDaysArgs): SchedulerViewDay[];
    getSchedulerView(args: GetSchedulerViewArgs): SchedulerView;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerUtils, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarSchedulerUtils>;
}

/**
 *  [ngClass]="getPositioningClasses(event)"
 *
 *  [style.top.px]="event.top"
 *  [style.height.px]="event.height"
 *  [style.left.%]="event.left"
 *  [style.width.%]="event.width"
 *
 *  DRAG & DROP & RESIZE -> https://github.com/mattlewis92/angular-calendar/blob/main/projects/angular-calendar/src/modules/week/calendar-week-view.component.ts
 *  FLEXBOX -> https://css-tricks.com/snippets/css/a-guide-to-flexbox/
 */
declare class CalendarSchedulerViewComponent implements OnInit, OnChanges, OnDestroy {
    private cdr;
    private config;
    private utils;
    private dateAdapter;
    private media;
    private changeDetectorRef;
    /**
     * Number of days shown. This value will be always normalized to DAYS_IN_WEEK (7)
     */
    _viewDays: number;
    get viewDays(): number;
    set viewDays(value: number);
    /**
     * The current view date
     */
    viewDate: Date;
    /**
     * Specify if the calendar must be resposive on window resize, changing the days showed automatically
     */
    responsive: boolean;
    /**
     * An array of events to display on view
     */
    events: CalendarSchedulerEvent[];
    /**
     * The number of segments in an hour. Must be one of 1, 2, 4, 6
     */
    hourSegments: 1 | 2 | 4 | 6;
    /**
    * The height in pixels of each hour segment
    */
    hourSegmentHeight: number;
    /**
     * An array of day indexes (0 = sunday, 1 = monday etc) that will be hidden on the view
     */
    excludeDays: number[];
    /**
     * Specify if the first day of current scheduler view has to be today or the first day of the week
     */
    startsWithToday: boolean;
    /**
     * Specify if content must be shown or not
     */
    showEventContent: boolean;
    /**
     * Specify if actions must be shown or not
     */
    showEventActions: boolean;
    /**
     * Specify if status must be shown or not
     */
    showEventStatus: boolean;
    /**
     * Specify if hour must be shown on segment or not
     */
    showSegmentHour: boolean;
    /**
     * Specify if event must zoom on mouse hover or not
     */
    zoomEventOnHover: boolean;
    /**
     * A function that will be called before each cell is rendered. The first argument will contain the calendar (day, hour or segment) cell.
     * If you add the `cssClass` property to the cell it will add that class to the cell in the template
     */
    dayModifier: Function;
    hourModifier: Function;
    segmentModifier: Function;
    eventModifier: Function;
    /**
     * An observable that when emitted on will re-render the current view
     */
    refresh: Subject<any>;
    /**
     * The locale used to format dates
     */
    locale: string;
    /**
     * The grid size to snap resizing and dragging of events to
     */
    eventSnapSize: number;
    /**
    * Whether to snap events to a grid when dragging
    */
    snapDraggedEvents: boolean;
    /**
     * The start number of the week
     */
    weekStartsOn: number;
    /**
     * A custom template to use to replace the header
     */
    headerTemplate: TemplateRef<any>;
    /**
     * A custom template to use to replace the day cell
     */
    cellTemplate: TemplateRef<any>;
    /**
     * A custom template to use for week view events
     */
    eventTemplate: TemplateRef<any>;
    /**
     * A custom template to use for event titles
     */
    eventTitleTemplate: TemplateRef<any>;
    /**
     * A custom template to use for all day events
     */
    allDayEventTemplate: TemplateRef<any>;
    /**
     * An array of day indexes (0 = sunday, 1 = monday etc) that indicate which days are weekends
     */
    weekendDays: number[];
    /**
     * The day start hours in 24 hour time. Must be 0-23
     */
    dayStartHour: number;
    /**
     * The day start minutes. Must be 0-59
     */
    dayStartMinute: number;
    /**
     * The day end hours in 24 hour time. Must be 0-23
     */
    dayEndHour: number;
    /**
     * The day end minutes. Must be 0-59
     */
    dayEndMinute: number;
    /**
     * Called when view days value changes
     */
    viewDaysChanged: EventEmitter<number>;
    /**
     * Called when a header week day is clicked
     */
    dayHeaderClicked: EventEmitter<{
        day: SchedulerViewDay;
    }>;
    /**
     * Called when the hour is clicked
     */
    hourClicked: EventEmitter<{
        hour: SchedulerViewHour;
    }>;
    /**
     * Called when the segment is clicked
     */
    segmentClicked: EventEmitter<{
        segment: SchedulerViewHourSegment;
    }>;
    /**
     * Called when the event is clicked
     */
    eventClicked: EventEmitter<{
        event: CalendarSchedulerEvent;
    }>;
    /**
     * Called when an event is resized or dragged and dropped
     */
    eventTimesChanged: EventEmitter<SchedulerEventTimesChangedEvent>;
    /**
     * @hidden
     */
    view: SchedulerView;
    /**
     * @hidden
     */
    refreshSubscription: Subscription;
    /**
     * @hidden
     */
    days: SchedulerViewDay[];
    /**
     * @hidden
     */
    hours: WeekViewHour[];
    /**
     * @hidden
     */
    resizes: Map<CalendarSchedulerEvent, ResizeEvent>;
    /**
     * @hidden
     */
    eventDragEnter: number;
    /**
     * @hidden
     */
    dragActive: boolean;
    /**
     * @hidden
     */
    dragAlreadyMoved: boolean;
    /**
     * @hidden
     */
    validateResize: (args: any) => boolean;
    /**
     * @hidden
     */
    validateDrag: (args: any) => boolean;
    /**
     * @hidden
     */
    dayColumnWidth: number;
    /**
     * @hidden
     */
    calendarId: symbol;
    /**
     * @hidden
     */
    rtl: boolean;
    /**
     * @hidden
     */
    trackByHourColumn: (index: number, day: SchedulerViewDay) => string | SchedulerViewDay;
    /**
     * @hidden
     */
    trackByDayOrEvent: (index: number, event: SchedulerViewEvent) => string | CalendarSchedulerEvent;
    /**
     * @hidden
     */
    trackByHour: (index: number, hour: WeekViewHour | SchedulerViewHour) => string;
    /**
     * @hidden
     */
    trackByHourSegment: (index: number, segment: SchedulerViewHourSegment) => string;
    mobileQueryXs: MediaQueryList;
    mobileQuerySm: MediaQueryList;
    mobileQueryListener: (this: MediaQueryList, ev: MediaQueryListEvent) => any;
    onResize(event: any): void;
    /**
     * @hidden
     */
    constructor(cdr: ChangeDetectorRef, locale: string, config: SchedulerConfig, utils: CalendarSchedulerUtils, dateAdapter: DateAdapter, media: MediaMatcher, changeDetectorRef: ChangeDetectorRef);
    /**
     * @hidden
     */
    ngOnInit(): void;
    /**
     * @hidden
     */
    ngOnChanges(changes: any): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    setViewDays(viewDays: number): void;
    protected adjustViewDays(): void;
    protected getPositioningClasses(day: SchedulerViewDay, event: CalendarSchedulerEvent): string;
    private getDayClass;
    private getTimeClass;
    private getLengthClass;
    private refreshHourGrid;
    private refreshHeader;
    private refreshBody;
    private refreshAll;
    private getSchedulerView;
    /**
     * @hidden
     */
    resizeStarted(eventsContainer: HTMLElement, event: SchedulerViewEvent, resizeEvent: ResizeEvent): void;
    /**
     * @hidden
     */
    resizing(event: SchedulerViewEvent, resizeEvent: ResizeEvent): void;
    /**
     * @hidden
     */
    resizeEnded(event: SchedulerViewEvent): void;
    private getResizedEventDates;
    /**
     * @hidden
     */
    eventDropped(dropEvent: DropEvent<{
        event?: CalendarSchedulerEvent;
        calendarId?: symbol;
    }>, date: Date): void;
    /**
     * @hidden
     */
    dragStarted(eventsContainer: HTMLElement, eventContainer: HTMLElement, event?: SchedulerViewEvent): void;
    /**
     * @hidden
     */
    dragMove(event: SchedulerViewEvent, dragEvent: DragMoveEvent): void;
    dragEnded(event: SchedulerViewEvent, dragEndEvent: DragEndEvent, dayWidth: number, useY?: boolean): void;
    private getDragMovedEventTimes;
    private restoreOriginalEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerViewComponent, "calendar-scheduler-view", never, { "viewDays": { "alias": "viewDays"; "required": false; }; "viewDate": { "alias": "viewDate"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "events": { "alias": "events"; "required": false; }; "hourSegments": { "alias": "hourSegments"; "required": false; }; "hourSegmentHeight": { "alias": "hourSegmentHeight"; "required": false; }; "excludeDays": { "alias": "excludeDays"; "required": false; }; "startsWithToday": { "alias": "startsWithToday"; "required": false; }; "showEventContent": { "alias": "showEventContent"; "required": false; }; "showEventActions": { "alias": "showEventActions"; "required": false; }; "showEventStatus": { "alias": "showEventStatus"; "required": false; }; "showSegmentHour": { "alias": "showSegmentHour"; "required": false; }; "zoomEventOnHover": { "alias": "zoomEventOnHover"; "required": false; }; "dayModifier": { "alias": "dayModifier"; "required": false; }; "hourModifier": { "alias": "hourModifier"; "required": false; }; "segmentModifier": { "alias": "segmentModifier"; "required": false; }; "eventModifier": { "alias": "eventModifier"; "required": false; }; "refresh": { "alias": "refresh"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "eventSnapSize": { "alias": "eventSnapSize"; "required": false; }; "snapDraggedEvents": { "alias": "snapDraggedEvents"; "required": false; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; "eventTemplate": { "alias": "eventTemplate"; "required": false; }; "eventTitleTemplate": { "alias": "eventTitleTemplate"; "required": false; }; "allDayEventTemplate": { "alias": "allDayEventTemplate"; "required": false; }; "weekendDays": { "alias": "weekendDays"; "required": false; }; "dayStartHour": { "alias": "dayStartHour"; "required": false; }; "dayStartMinute": { "alias": "dayStartMinute"; "required": false; }; "dayEndHour": { "alias": "dayEndHour"; "required": false; }; "dayEndMinute": { "alias": "dayEndMinute"; "required": false; }; }, { "viewDaysChanged": "viewDaysChanged"; "dayHeaderClicked": "dayHeaderClicked"; "hourClicked": "hourClicked"; "segmentClicked": "segmentClicked"; "eventClicked": "eventClicked"; "eventTimesChanged": "eventTimesChanged"; }, never, never, false, never>;
}

declare class CalendarSchedulerHourSegmentComponent implements OnInit {
    protected moment: any;
    title: string;
    day: SchedulerViewDay;
    segment: SchedulerViewHourSegment;
    locale: string;
    customTemplate: TemplateRef<any>;
    hourSegmentHeight: number;
    showHour: boolean;
    segmentClicked: EventEmitter<{
        segment: SchedulerViewHourSegment;
    }>;
    constructor(moment: any);
    ngOnInit(): void;
    /**
     * @hidden
     */
    onMouseEnter(mouseEvent: MouseEvent, segment: SchedulerViewHourSegment, event: CalendarSchedulerEvent): void;
    /**
     * @hidden
     */
    onMouseLeave(mouseEvent: MouseEvent, segment: SchedulerViewHourSegment, event: CalendarSchedulerEvent): void;
    /**
     * @hidden
     */
    onSegmentClick(mouseEvent: MouseEvent, segment: SchedulerViewHourSegment): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerHourSegmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerHourSegmentComponent, "calendar-scheduler-hour-segment", never, { "title": { "alias": "title"; "required": false; }; "day": { "alias": "day"; "required": false; }; "segment": { "alias": "segment"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; "hourSegmentHeight": { "alias": "hourSegmentHeight"; "required": false; }; "showHour": { "alias": "showHour"; "required": false; }; }, { "segmentClicked": "segmentClicked"; }, never, never, false, never>;
}

declare class CalendarSchedulerHeaderComponent {
    days: SchedulerViewDay[];
    locale: string;
    customTemplate: TemplateRef<any>;
    dayHeaderClicked: EventEmitter<{
        day: SchedulerViewDay;
    }>;
    /**
     * @hidden
     */
    onDayHeaderClick(mouseEvent: MouseEvent, day: SchedulerViewDay): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerHeaderComponent, "calendar-scheduler-header", never, { "days": { "alias": "days"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; }, { "dayHeaderClicked": "dayHeaderClicked"; }, never, never, false, never>;
}

declare class CalendarSchedulerEventComponent implements OnInit, AfterContentChecked {
    private hostElement;
    protected changeDetectorRef: ChangeDetectorRef;
    protected moment: any;
    title: string;
    day: SchedulerViewDay;
    event: SchedulerViewEvent;
    container: HTMLElement;
    showContent: boolean;
    showActions: boolean;
    showStatus: boolean;
    customTemplate: TemplateRef<any>;
    eventTitleTemplate: TemplateRef<any>;
    eventClicked: EventEmitter<{
        event: CalendarSchedulerEvent;
    }>;
    constructor(hostElement: ElementRef, changeDetectorRef: ChangeDetectorRef, moment: any);
    ngOnInit(): void;
    ngAfterContentChecked(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    /**
     * @hidden
     */
    onEventClick(mouseEvent: MouseEvent, event: CalendarSchedulerEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerEventComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerEventComponent, "calendar-scheduler-event", never, { "title": { "alias": "title"; "required": false; }; "day": { "alias": "day"; "required": false; }; "event": { "alias": "event"; "required": false; }; "container": { "alias": "container"; "required": false; }; "showContent": { "alias": "showContent"; "required": false; }; "showActions": { "alias": "showActions"; "required": false; }; "showStatus": { "alias": "showStatus"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; "eventTitleTemplate": { "alias": "eventTitleTemplate"; "required": false; }; }, { "eventClicked": "eventClicked"; }, never, never, false, never>;
}

declare class CalendarSchedulerEventTitleComponent {
    view: string;
    event: CalendarSchedulerEvent;
    showStatus: boolean;
    showContent: boolean;
    showActions: boolean;
    customTemplate: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerEventTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerEventTitleComponent, "calendar-scheduler-event-title", never, { "view": { "alias": "view"; "required": false; }; "event": { "alias": "event"; "required": false; }; "showStatus": { "alias": "showStatus"; "required": false; }; "showContent": { "alias": "showContent"; "required": false; }; "showActions": { "alias": "showActions"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CalendarSchedulerEventContentComponent implements AfterViewInit {
    private hostElement;
    event: CalendarSchedulerEvent;
    eventContainer: HTMLElement;
    maxHeight: number;
    constructor(hostElement: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerEventContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerEventContentComponent, "calendar-scheduler-event-content", never, { "event": { "alias": "event"; "required": false; }; "eventContainer": { "alias": "eventContainer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CalendarSchedulerEventActionsComponent implements OnInit, OnChanges {
    event: CalendarSchedulerEvent;
    actions: CalendarSchedulerEventAction[];
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private setupActions;
    /**
     * @hidden
     */
    onActionClick(mouseEvent: MouseEvent, action: CalendarSchedulerEventAction, event: CalendarSchedulerEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerEventActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarSchedulerEventActionsComponent, "calendar-scheduler-event-actions", never, { "event": { "alias": "event"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SchedulerEventTitleFormatter extends CalendarEventTitleFormatter {
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerEventTitleFormatter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchedulerEventTitleFormatter>;
}

declare class SchedulerEventTitlePipe implements PipeTransform {
    private schedulerEventTitle;
    constructor(schedulerEventTitle: SchedulerEventTitleFormatter);
    transform(title: string, titleType: string, event: CalendarSchedulerEvent): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerEventTitlePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SchedulerEventTitlePipe, "schedulerEventTitle", false>;
}

declare class CalendarSchedulerDatePipe implements PipeTransform {
    private dateAdapter;
    private dateFormatter;
    private locale;
    constructor(dateAdapter: DateAdapter, dateFormatter: CalendarDateFormatter, locale: string);
    transform(date: Date, method: string, locale?: string, weekStartsOn?: number, excludeDays?: number[], daysInWeek?: number, startsWithToday?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSchedulerDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CalendarSchedulerDatePipe, "calendarSchedulerDate", false>;
}

interface SchedulerDateFormatterParams extends DateFormatterParams {
    dateAdapter: DateAdapter;
    startsWithToday: boolean;
}
declare class SchedulerDateFormatter extends CalendarDateFormatter {
    protected dateAdapter: DateAdapter;
    constructor(dateAdapter: DateAdapter);
    /**
     * The time formatting down the left hand side of the day view
     */
    dayViewHour({ date, locale }: SchedulerDateFormatterParams): string;
    weekViewTitle({ date, locale, weekStartsOn, excludeDays, daysInWeek, startsWithToday }: SchedulerDateFormatterParams): string;
    private daysInMonth;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerDateFormatter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchedulerDateFormatter>;
}

declare function addPeriod(dateAdapter: DateAdapter, period: CalendarView, date: Date, amount: number): Date;
declare function subPeriod(dateAdapter: DateAdapter, period: CalendarView, date: Date, amount: number): Date;
declare function startOfPeriod(dateAdapter: DateAdapter, period: CalendarView, date: Date): Date;
declare function endOfPeriod(dateAdapter: DateAdapter, period: CalendarView, date: Date): Date;
declare const trackByDayOrEvent: (index: number, event: SchedulerViewEvent) => string | CalendarSchedulerEvent;
declare const trackByHourColumn: (index: number, day: SchedulerViewDay) => string | SchedulerViewDay;
declare const trackByHour: (index: number, hour: WeekViewHour | SchedulerViewHour) => string;
declare const trackByHourSegment: (index: number, segment: SchedulerViewHourSegment) => string;
declare function getMinimumEventHeightInMinutes(hourSegments: number, hourSegmentHeight: number): number;
declare function getDefaultEventEnd(dateAdapter: DateAdapter, event: CalendarSchedulerEvent, minimumMinutes: number): Date;
declare function roundToNearest(amount: number, precision: number): number;
declare function getMinutesMoved(movedY: number, hourSegments: number, hourSegmentHeight: number, eventSnapSize: number): number;
declare function isDraggedWithinPeriod(newStart: Date, newEnd: Date, period: SchedulerViewPeriod): boolean;
declare function shouldFireDroppedEvent(dropEvent: {
    dropData?: {
        event?: CalendarSchedulerEvent;
        calendarId?: symbol;
    };
}, date: Date, calendarId: symbol): boolean;

declare const SCHEDULER_CONFIG: InjectionToken<unknown>;
declare function provideSchedulerConfig(config: SchedulerConfig): SchedulerConfig;
/**
 * The main module of this library. Example usage:
 *
 * ```typescript
 * import { CalendarModule, DateAdapter } from 'angular-calendar';
 * import { adapterFactory } from 'angular-calendar/date-adapters/date-fns';
 * import { SchedulerModule } from 'angular-calendar-scheduler';
 *
 * @NgModule({
 *  imports: [
 *     CalendarModule.forRoot({
 *       provide: DateAdapter,
 *       useFactory: adapterFactory
 *     }),
 *     SchedulerModule.forRoot({ locale: 'en', headerDateFormat: 'daysRange' })
 *   ]
 * })
 * class MyModule {}
 * ```
 *
 */
declare class SchedulerModule {
    static forRoot(config?: SchedulerConfig): ModuleWithProviders<SchedulerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SchedulerModule, [typeof CalendarSchedulerViewComponent, typeof CalendarSchedulerHourSegmentComponent, typeof CalendarSchedulerHeaderComponent, typeof CalendarSchedulerEventComponent, typeof CalendarSchedulerEventTitleComponent, typeof CalendarSchedulerEventContentComponent, typeof CalendarSchedulerEventActionsComponent, typeof SchedulerEventTitlePipe, typeof CalendarSchedulerDatePipe], [typeof i10.CommonModule, typeof i11.CalendarModule], [typeof CalendarSchedulerDatePipe, typeof CalendarSchedulerViewComponent, typeof CalendarSchedulerHourSegmentComponent, typeof CalendarSchedulerHeaderComponent, typeof CalendarSchedulerEventComponent, typeof CalendarSchedulerEventTitleComponent, typeof CalendarSchedulerEventContentComponent, typeof CalendarSchedulerEventActionsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SchedulerModule>;
}

export { CalendarSchedulerDatePipe, CalendarSchedulerEventActionsComponent, CalendarSchedulerEventComponent, CalendarSchedulerEventContentComponent, CalendarSchedulerEventTitleComponent, CalendarSchedulerHeaderComponent, CalendarSchedulerHourSegmentComponent, CalendarSchedulerUtils, CalendarSchedulerViewComponent, DAYS_IN_WEEK, DAYS_OF_WEEK, DEFAULT_EVENT_WIDTH, DEFAULT_HOUR_SEGMENTS, DEFAULT_HOUR_SEGMENT_HEIGHT_PX, HOURS_IN_DAY, MINUTES_IN_HOUR, SCHEDULER_CONFIG, SECONDS_IN_DAY, SchedulerDateFormatter, SchedulerEventTitleFormatter, SchedulerEventTitlePipe, SchedulerModule, addPeriod, endOfPeriod, getDefaultEventEnd, getMinimumEventHeightInMinutes, getMinutesMoved, getSchedulerView, getSchedulerViewDays, getSchedulerViewHourGrid, isDraggedWithinPeriod, provideSchedulerConfig, roundToNearest, shouldFireDroppedEvent, startOfPeriod, subPeriod, trackByDayOrEvent, trackByHour, trackByHourColumn, trackByHourSegment };
export type { CalendarSchedulerEvent, CalendarSchedulerEventAction, CalendarSchedulerEventStatus, GetEventsInPeriodArgs, GetSchedulerEventsInPeriodArgs, GetSchedulerViewArgs, GetSchedulerViewDaysArgs, GetSchedulerViewHourGridArgs, SchedulerDateFormatterParams, SchedulerEventTimesChangedEvent, SchedulerView, SchedulerViewDay, SchedulerViewEvent, SchedulerViewHour, SchedulerViewHourSegment, SchedulerViewPeriod, Time };