/*!
 * devextreme-angular-test
 * Version: 17.2.8
 * Build date: Mon Feb 05 2018
 *
 * Copyright (c) 2012 - 2018 Developer Express Inc. ALL RIGHTS RESERVED
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file in the root of the project for details.
 *
 * https://github.com/DevExpress/devextreme-angular
 */











import {
    Component,
    NgModule,
    ElementRef,
    NgZone,
    Input,
    Output,
    OnDestroy,
    Injector,
    EventEmitter,
    OnChanges,
    DoCheck,
    SimpleChanges,
    ContentChildren,
    QueryList
} from '@angular/core';


import DevExpress from 'devextreme/bundles/dx.all';

import DxScheduler from 'devextreme/ui/scheduler';


import { DxComponent } from '../core/component';
import { DxTemplateHost } from '../core/template-host';
import { DxTemplateModule } from '../core/template';
import { EventsRegistrator } from '../core/events-strategy';
import { NestedOptionHost } from '../core/nested-option';
import { WatcherHelper } from '../core/watcher-helper';
import { IterableDifferHelper } from '../core/iterable-differ-helper';

import { DxoEditingModule } from './nested/editing';
import { DxiResourceModule } from './nested/resource-dxi';
import { DxiViewModule } from './nested/view-dxi';

import { DxiResourceComponent } from './nested/resource-dxi';
import { DxiViewComponent } from './nested/view-dxi';




/**
 * The Scheduler is a widget that represents scheduled data and allows a user to manage and edit it.
 */
@Component({
    selector: 'dx-scheduler',
    template: '',
    providers: [
        DxTemplateHost,
        WatcherHelper,
        NestedOptionHost,
        IterableDifferHelper
    ]
})
export class DxSchedulerComponent extends DxComponent implements OnDestroy, OnChanges, DoCheck {
    instance: DxScheduler;


    /**
     * Specifies the shortcut key that sets focus on the widget.
     */
    @Input()
    get accessKey(): string {
        return this._getOption('accessKey');
    }
    set accessKey(value: string) {
        this._setOption('accessKey', value);
    }


    /**
     * Specifies the name of the data source item field whose value defines whether or not the corresponding appointment is an all-day appointment.
     */
    @Input()
    get allDayExpr(): string {
        return this._getOption('allDayExpr');
    }
    set allDayExpr(value: string) {
        this._setOption('allDayExpr', value);
    }


    /**
     * The template to be used for rendering appointments.
     */
    @Input()
    get appointmentTemplate(): any {
        return this._getOption('appointmentTemplate');
    }
    set appointmentTemplate(value: any) {
        this._setOption('appointmentTemplate', value);
    }


    /**
     * The template to be used for rendering an appointment tooltip.
     */
    @Input()
    get appointmentTooltipTemplate(): any {
        return this._getOption('appointmentTooltipTemplate');
    }
    set appointmentTooltipTemplate(value: any) {
        this._setOption('appointmentTooltipTemplate', value);
    }


    /**
     * Specifies cell duration in minutes.
     */
    @Input()
    get cellDuration(): number {
        return this._getOption('cellDuration');
    }
    set cellDuration(value: number) {
        this._setOption('cellDuration', value);
    }


    /**
     * Specifies whether or not an end-user can scroll the view in both directions at the same time.
     */
    @Input()
    get crossScrollingEnabled(): boolean {
        return this._getOption('crossScrollingEnabled');
    }
    set crossScrollingEnabled(value: boolean) {
        this._setOption('crossScrollingEnabled', value);
    }


    /**
     * Specifies a date displayed on the current scheduler view by default.
     */
    @Input()
    get currentDate(): Date|
        number|
        string {
        return this._getOption('currentDate');
    }
    set currentDate(value: Date|
        number|
        string) {
        this._setOption('currentDate', value);
    }


    /**
     * Specifies the currently displayed view. Accepts the view's name or type.
     */
    @Input()
    get currentView(): string {
        return this._getOption('currentView');
    }
    set currentView(value: string) {
        this._setOption('currentView', value);
    }


    /**
     * The template to be used for rendering table cells.
     */
    @Input()
    get dataCellTemplate(): any {
        return this._getOption('dataCellTemplate');
    }
    set dataCellTemplate(value: any) {
        this._setOption('dataCellTemplate', value);
    }


    /**
     * Specifies the origin of data for the widget.
     */
    @Input()
    get dataSource(): DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<DevExpress.ui.dxSchedulerAppointmentTemplate> {
        return this._getOption('dataSource');
    }
    set dataSource(value: DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<DevExpress.ui.dxSchedulerAppointmentTemplate>) {
        this._setOption('dataSource', value);
    }


    /**
     * The template used for rendering day scale items.
     */
    @Input()
    get dateCellTemplate(): any {
        return this._getOption('dateCellTemplate');
    }
    set dateCellTemplate(value: any) {
        this._setOption('dateCellTemplate', value);
    }


    /**
     * Specifies the date-time values' serialization format. Use it only if you do not specify the dataSource at design time.
     */
    @Input()
    get dateSerializationFormat(): string {
        return this._getOption('dateSerializationFormat');
    }
    set dateSerializationFormat(value: string) {
        this._setOption('dateSerializationFormat', value);
    }


    /**
     * Specifies the name of the data source item field whose value holds the description of the corresponding appointment.
     */
    @Input()
    get descriptionExpr(): string {
        return this._getOption('descriptionExpr');
    }
    set descriptionExpr(value: string) {
        this._setOption('descriptionExpr', value);
    }


    /**
     * Specifies whether the widget responds to user interaction.
     */
    @Input()
    get disabled(): boolean {
        return this._getOption('disabled');
    }
    set disabled(value: boolean) {
        this._setOption('disabled', value);
    }


    /**
     * The template to be used for rendering appointments in the appointment collector's drop-down list.
     */
    @Input()
    get dropDownAppointmentTemplate(): any {
        return this._getOption('dropDownAppointmentTemplate');
    }
    set dropDownAppointmentTemplate(value: any) {
        this._setOption('dropDownAppointmentTemplate', value);
    }


    /**
     * Specifies which editing operations an end-user can perform on appointments.
     */
    @Input()
    get editing(): boolean|
        { allowAdding?: boolean, allowDeleting?: boolean, allowDragging?: boolean, allowResizing?: boolean, allowUpdating?: boolean } {
        return this._getOption('editing');
    }
    set editing(value: boolean|
        { allowAdding?: boolean, allowDeleting?: boolean, allowDragging?: boolean, allowResizing?: boolean, allowUpdating?: boolean }) {
        this._setOption('editing', value);
    }


    /**
     * Specifies the attributes to be attached to the widget's root element.
     */
    @Input()
    get elementAttr(): any {
        return this._getOption('elementAttr');
    }
    set elementAttr(value: any) {
        this._setOption('elementAttr', value);
    }


    /**
     * Specifies the name of the data source item field that defines the ending of an appointment.
     */
    @Input()
    get endDateExpr(): string {
        return this._getOption('endDateExpr');
    }
    set endDateExpr(value: string) {
        this._setOption('endDateExpr', value);
    }


    /**
     * Specifies the name of the data source item field that defines the timezone of the appointment end date.
     */
    @Input()
    get endDateTimeZoneExpr(): string {
        return this._getOption('endDateTimeZoneExpr');
    }
    set endDateTimeZoneExpr(value: string) {
        this._setOption('endDateTimeZoneExpr', value);
    }


    /**
     * Specifies an end hour in the scheduler view's time interval.
     */
    @Input()
    get endDayHour(): number {
        return this._getOption('endDayHour');
    }
    set endDayHour(value: number) {
        this._setOption('endDayHour', value);
    }


    /**
     * Specifies the first day of a week.
     */
    @Input()
    get firstDayOfWeek(): number|
        string {
        return this._getOption('firstDayOfWeek');
    }
    set firstDayOfWeek(value: number|
        string) {
        this._setOption('firstDayOfWeek', value);
    }


    /**
     * Specifies whether the widget can be focused using keyboard navigation.
     */
    @Input()
    get focusStateEnabled(): boolean {
        return this._getOption('focusStateEnabled');
    }
    set focusStateEnabled(value: boolean) {
        this._setOption('focusStateEnabled', value);
    }


    /**
     * Specifies the resource kinds by which the scheduler's appointments are grouped in a timetable.
     */
    @Input()
    get groups(): Array<string> {
        return this._getOption('groups');
    }
    set groups(value: Array<string>) {
        this._setOption('groups', value);
    }


    /**
     * Specifies the widget's height.
     */
    @Input()
    get height(): number|
        Function|
        string {
        return this._getOption('height');
    }
    set height(value: number|
        Function|
        string) {
        this._setOption('height', value);
    }


    /**
     * Specifies text for a hint that appears when a user pauses on the widget.
     */
    @Input()
    get hint(): string {
        return this._getOption('hint');
    }
    set hint(value: string) {
        this._setOption('hint', value);
    }


    @Input()
    get horizontalScrollingEnabled(): any {
        return this._getOption('horizontalScrollingEnabled');
    }
    set horizontalScrollingEnabled(value: any) {
        this._setOption('horizontalScrollingEnabled', value);
    }


    /**
     * Specifies the time interval between when the date-time indicator changes its position, in milliseconds.
     */
    @Input()
    get indicatorUpdateInterval(): number {
        return this._getOption('indicatorUpdateInterval');
    }
    set indicatorUpdateInterval(value: number) {
        this._setOption('indicatorUpdateInterval', value);
    }


    /**
     * The latest date the widget allows you to select.
     */
    @Input()
    get max(): Date|
        number|
        string {
        return this._getOption('max');
    }
    set max(value: Date|
        number|
        string) {
        this._setOption('max', value);
    }


    /**
     * Specifies the limit of full-sized appointments displayed per cell. In the "day", "week" and "workweek" views, this option applies only to all-day appointments.
     */
    @Input()
    get maxAppointmentsPerCell(): number|
        string {
        return this._getOption('maxAppointmentsPerCell');
    }
    set maxAppointmentsPerCell(value: number|
        string) {
        this._setOption('maxAppointmentsPerCell', value);
    }


    /**
     * The earliest date the widget allows you to select.
     */
    @Input()
    get min(): Date|
        number|
        string {
        return this._getOption('min');
    }
    set min(value: Date|
        number|
        string) {
        this._setOption('min', value);
    }


    /**
     * The text or HTML markup displayed by the widget if the item collection is empty. Available for the Agenda view only.
     */
    @Input()
    get noDataText(): string {
        return this._getOption('noDataText');
    }
    set noDataText(value: string) {
        this._setOption('noDataText', value);
    }


    /**
     * Specifies the edit mode for recurring appointments.
     */
    @Input()
    get recurrenceEditMode(): string {
        return this._getOption('recurrenceEditMode');
    }
    set recurrenceEditMode(value: string) {
        this._setOption('recurrenceEditMode', value);
    }


    /**
     * Specifies the name of the data source item field that defines exceptions for the current recurring appointment.
     */
    @Input()
    get recurrenceExceptionExpr(): string {
        return this._getOption('recurrenceExceptionExpr');
    }
    set recurrenceExceptionExpr(value: string) {
        this._setOption('recurrenceExceptionExpr', value);
    }


    /**
     * Specifies the name of the data source item field that defines a recurrence rule for generating recurring appointments.
     */
    @Input()
    get recurrenceRuleExpr(): string {
        return this._getOption('recurrenceRuleExpr');
    }
    set recurrenceRuleExpr(value: string) {
        this._setOption('recurrenceRuleExpr', value);
    }


    /**
     * Specifies whether filtering is performed on the server or client side.
     */
    @Input()
    get remoteFiltering(): boolean {
        return this._getOption('remoteFiltering');
    }
    set remoteFiltering(value: boolean) {
        this._setOption('remoteFiltering', value);
    }


    /**
     * The template to be used for rendering resource headers.
     */
    @Input()
    get resourceCellTemplate(): any {
        return this._getOption('resourceCellTemplate');
    }
    set resourceCellTemplate(value: any) {
        this._setOption('resourceCellTemplate', value);
    }


    /**
     * Specifies an array of resources available in the scheduler.
     */
    @Input()
    get resources(): Array<any|
        { allowMultiple?: boolean, colorExpr?: string, dataSource?: DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<any>, displayExpr?: Function|
        string, field?: string, fieldExpr?: string, label?: string, mainColor?: boolean, useColorAsDefault?: boolean, valueExpr?: Function|
        string }> {
        return this._getOption('resources');
    }
    set resources(value: Array<any|
        { allowMultiple?: boolean, colorExpr?: string, dataSource?: DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<any>, displayExpr?: Function|
        string, field?: string, fieldExpr?: string, label?: string, mainColor?: boolean, useColorAsDefault?: boolean, valueExpr?: Function|
        string }>) {
        this._setOption('resources', value);
    }


    /**
     * Switches the widget to a right-to-left representation.
     */
    @Input()
    get rtlEnabled(): boolean {
        return this._getOption('rtlEnabled');
    }
    set rtlEnabled(value: boolean) {
        this._setOption('rtlEnabled', value);
    }


    /**
     * Specifies whether to apply shading to cover the timetable up to the current time.
     */
    @Input()
    get shadeUntilCurrentTime(): boolean {
        return this._getOption('shadeUntilCurrentTime');
    }
    set shadeUntilCurrentTime(value: boolean) {
        this._setOption('shadeUntilCurrentTime', value);
    }


    /**
     * Specifies the "All-day" panel's visibility. Setting this option to false hides the panel along with the all-day appointments.
     */
    @Input()
    get showAllDayPanel(): boolean {
        return this._getOption('showAllDayPanel');
    }
    set showAllDayPanel(value: boolean) {
        this._setOption('showAllDayPanel', value);
    }


    /**
     * Specifies the current date-time indicator's visibility.
     */
    @Input()
    get showCurrentTimeIndicator(): boolean {
        return this._getOption('showCurrentTimeIndicator');
    }
    set showCurrentTimeIndicator(value: boolean) {
        this._setOption('showCurrentTimeIndicator', value);
    }


    /**
     * Specifies the name of the data source item field that defines the start of an appointment.
     */
    @Input()
    get startDateExpr(): string {
        return this._getOption('startDateExpr');
    }
    set startDateExpr(value: string) {
        this._setOption('startDateExpr', value);
    }


    /**
     * Specifies the name of the data source item field that defines the timezone of the appointment start date.
     */
    @Input()
    get startDateTimeZoneExpr(): string {
        return this._getOption('startDateTimeZoneExpr');
    }
    set startDateTimeZoneExpr(value: string) {
        this._setOption('startDateTimeZoneExpr', value);
    }


    /**
     * Specifies a start hour in the scheduler view's time interval.
     */
    @Input()
    get startDayHour(): number {
        return this._getOption('startDayHour');
    }
    set startDayHour(value: number) {
        this._setOption('startDayHour', value);
    }


    /**
     * Specifies the number of the element when the Tab key is used for navigating.
     */
    @Input()
    get tabIndex(): number {
        return this._getOption('tabIndex');
    }
    set tabIndex(value: number) {
        this._setOption('tabIndex', value);
    }


    /**
     * Specifies the name of the data source item field that holds the subject of an appointment.
     */
    @Input()
    get textExpr(): string {
        return this._getOption('textExpr');
    }
    set textExpr(value: string) {
        this._setOption('textExpr', value);
    }


    /**
     * The template to be used for rendering time scale items.
     */
    @Input()
    get timeCellTemplate(): any {
        return this._getOption('timeCellTemplate');
    }
    set timeCellTemplate(value: any) {
        this._setOption('timeCellTemplate', value);
    }


    /**
     * Specifies the timezone of the widget.
     */
    @Input()
    get timeZone(): string {
        return this._getOption('timeZone');
    }
    set timeZone(value: string) {
        this._setOption('timeZone', value);
    }


    /**
     * Specifies whether a user can switch views using tabs or a drop-down menu.
     */
    @Input()
    get useDropDownViewSwitcher(): boolean {
        return this._getOption('useDropDownViewSwitcher');
    }
    set useDropDownViewSwitcher(value: boolean) {
        this._setOption('useDropDownViewSwitcher', value);
    }


    /**
     * Configures individual views.
     */
    @Input()
    get views(): string|
        Array<string|
        { agendaDuration?: number, appointmentTemplate?: any, appointmentTooltipTemplate?: any, cellDuration?: number, dataCellTemplate?: any, dateCellTemplate?: any, dropDownAppointmentTemplate?: any, endDayHour?: number, firstDayOfWeek?: number|
        string, groups?: Array<string>, intervalCount?: number, maxAppointmentsPerCell?: number|
        string, name?: string, resourceCellTemplate?: any, startDate?: Date|
        number|
        string, startDayHour?: number, timeCellTemplate?: any, type?: string }> {
        return this._getOption('views');
    }
    set views(value: string|
        Array<string|
        { agendaDuration?: number, appointmentTemplate?: any, appointmentTooltipTemplate?: any, cellDuration?: number, dataCellTemplate?: any, dateCellTemplate?: any, dropDownAppointmentTemplate?: any, endDayHour?: number, firstDayOfWeek?: number|
        string, groups?: Array<string>, intervalCount?: number, maxAppointmentsPerCell?: number|
        string, name?: string, resourceCellTemplate?: any, startDate?: Date|
        number|
        string, startDayHour?: number, timeCellTemplate?: any, type?: string }>) {
        this._setOption('views', value);
    }


    /**
     * Specifies whether the widget is visible.
     */
    @Input()
    get visible(): boolean {
        return this._getOption('visible');
    }
    set visible(value: boolean) {
        this._setOption('visible', value);
    }


    /**
     * Specifies the widget's width.
     */
    @Input()
    get width(): number|
        Function|
        string {
        return this._getOption('width');
    }
    set width(value: number|
        Function|
        string) {
        this._setOption('width', value);
    }

    /**
     * A handler for the appointmentAdded event.
     */
    @Output() onAppointmentAdded: EventEmitter<any>;

    /**
     * A handler for the AppointmentAdding event.
     */
    @Output() onAppointmentAdding: EventEmitter<any>;

    /**
     * A handler for the appointmentClick event.
     */
    @Output() onAppointmentClick: EventEmitter<any>;

    /**
     * A handler for the appointmentDblClick event.
     */
    @Output() onAppointmentDblClick: EventEmitter<any>;

    /**
     * A handler for the appointmentDeleted event.
     */
    @Output() onAppointmentDeleted: EventEmitter<any>;

    /**
     * A handler for the AppointmentDeleting event.
     */
    @Output() onAppointmentDeleting: EventEmitter<any>;

    /**
     * A handler for the appointmentFormCreated event.
     */
    @Output() onAppointmentFormCreated: EventEmitter<any>;

    /**
     * A handler for the appointmentRendered event.
     */
    @Output() onAppointmentRendered: EventEmitter<any>;

    /**
     * A handler for the appointmentUpdated event.
     */
    @Output() onAppointmentUpdated: EventEmitter<any>;

    /**
     * A handler for the AppointmentUpdating event.
     */
    @Output() onAppointmentUpdating: EventEmitter<any>;

    /**
     * A handler for the cellClick event.
     */
    @Output() onCellClick: EventEmitter<any>;

    /**
     * A handler for the contentReady event. Executed when the widget's content is ready. This handler may be executed multiple times during the widget's lifetime depending on the number of times its content changes.
     */
    @Output() onContentReady: EventEmitter<any>;

    /**
     * A handler for the disposing event. Executed when the widget is removed from the DOM using the remove(), empty(), or html() jQuery methods only.
     */
    @Output() onDisposing: EventEmitter<any>;

    /**
     * A handler for the initialized event. Executed only once, after the widget is initialized.
     */
    @Output() onInitialized: EventEmitter<any>;

    /**
     * A handler for the optionChanged event. Executed after an option of the widget is changed.
     */
    @Output() onOptionChanged: EventEmitter<any>;

    /**
     * A handler for the accessKeyChange event.
     */
    @Output() accessKeyChange: EventEmitter<string>;

    /**
     * A handler for the allDayExprChange event.
     */
    @Output() allDayExprChange: EventEmitter<string>;

    /**
     * A handler for the appointmentTemplateChange event.
     */
    @Output() appointmentTemplateChange: EventEmitter<any>;

    /**
     * A handler for the appointmentTooltipTemplateChange event.
     */
    @Output() appointmentTooltipTemplateChange: EventEmitter<any>;

    /**
     * A handler for the cellDurationChange event.
     */
    @Output() cellDurationChange: EventEmitter<number>;

    /**
     * A handler for the crossScrollingEnabledChange event.
     */
    @Output() crossScrollingEnabledChange: EventEmitter<boolean>;

    /**
     * A handler for the currentDateChange event.
     */
    @Output() currentDateChange: EventEmitter<Date|
        number|
        string>;

    /**
     * A handler for the currentViewChange event.
     */
    @Output() currentViewChange: EventEmitter<string>;

    /**
     * A handler for the dataCellTemplateChange event.
     */
    @Output() dataCellTemplateChange: EventEmitter<any>;

    /**
     * A handler for the dataSourceChange event.
     */
    @Output() dataSourceChange: EventEmitter<DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<DevExpress.ui.dxSchedulerAppointmentTemplate>>;

    /**
     * A handler for the dateCellTemplateChange event.
     */
    @Output() dateCellTemplateChange: EventEmitter<any>;

    /**
     * A handler for the dateSerializationFormatChange event.
     */
    @Output() dateSerializationFormatChange: EventEmitter<string>;

    /**
     * A handler for the descriptionExprChange event.
     */
    @Output() descriptionExprChange: EventEmitter<string>;

    /**
     * A handler for the disabledChange event.
     */
    @Output() disabledChange: EventEmitter<boolean>;

    /**
     * A handler for the dropDownAppointmentTemplateChange event.
     */
    @Output() dropDownAppointmentTemplateChange: EventEmitter<any>;

    /**
     * A handler for the editingChange event.
     */
    @Output() editingChange: EventEmitter<boolean|
        { allowAdding?: boolean, allowDeleting?: boolean, allowDragging?: boolean, allowResizing?: boolean, allowUpdating?: boolean }>;

    /**
     * A handler for the elementAttrChange event.
     */
    @Output() elementAttrChange: EventEmitter<any>;

    /**
     * A handler for the endDateExprChange event.
     */
    @Output() endDateExprChange: EventEmitter<string>;

    /**
     * A handler for the endDateTimeZoneExprChange event.
     */
    @Output() endDateTimeZoneExprChange: EventEmitter<string>;

    /**
     * A handler for the endDayHourChange event.
     */
    @Output() endDayHourChange: EventEmitter<number>;

    /**
     * A handler for the firstDayOfWeekChange event.
     */
    @Output() firstDayOfWeekChange: EventEmitter<number|
        string>;

    /**
     * A handler for the focusStateEnabledChange event.
     */
    @Output() focusStateEnabledChange: EventEmitter<boolean>;

    /**
     * A handler for the groupsChange event.
     */
    @Output() groupsChange: EventEmitter<Array<string>>;

    /**
     * A handler for the heightChange event.
     */
    @Output() heightChange: EventEmitter<number|
        Function|
        string>;

    /**
     * A handler for the hintChange event.
     */
    @Output() hintChange: EventEmitter<string>;

    /**
     * A handler for the horizontalScrollingEnabledChange event.
     */
    @Output() horizontalScrollingEnabledChange: EventEmitter<any>;

    /**
     * A handler for the indicatorUpdateIntervalChange event.
     */
    @Output() indicatorUpdateIntervalChange: EventEmitter<number>;

    /**
     * A handler for the maxChange event.
     */
    @Output() maxChange: EventEmitter<Date|
        number|
        string>;

    /**
     * A handler for the maxAppointmentsPerCellChange event.
     */
    @Output() maxAppointmentsPerCellChange: EventEmitter<number|
        string>;

    /**
     * A handler for the minChange event.
     */
    @Output() minChange: EventEmitter<Date|
        number|
        string>;

    /**
     * A handler for the noDataTextChange event.
     */
    @Output() noDataTextChange: EventEmitter<string>;

    /**
     * A handler for the recurrenceEditModeChange event.
     */
    @Output() recurrenceEditModeChange: EventEmitter<string>;

    /**
     * A handler for the recurrenceExceptionExprChange event.
     */
    @Output() recurrenceExceptionExprChange: EventEmitter<string>;

    /**
     * A handler for the recurrenceRuleExprChange event.
     */
    @Output() recurrenceRuleExprChange: EventEmitter<string>;

    /**
     * A handler for the remoteFilteringChange event.
     */
    @Output() remoteFilteringChange: EventEmitter<boolean>;

    /**
     * A handler for the resourceCellTemplateChange event.
     */
    @Output() resourceCellTemplateChange: EventEmitter<any>;

    /**
     * A handler for the resourcesChange event.
     */
    @Output() resourcesChange: EventEmitter<Array<any|
        { allowMultiple?: boolean, colorExpr?: string, dataSource?: DevExpress.data.DataSource|
        DevExpress.data.DataSourceOptions|
        string|
        Array<any>, displayExpr?: Function|
        string, field?: string, fieldExpr?: string, label?: string, mainColor?: boolean, useColorAsDefault?: boolean, valueExpr?: Function|
        string }>>;

    /**
     * A handler for the rtlEnabledChange event.
     */
    @Output() rtlEnabledChange: EventEmitter<boolean>;

    /**
     * A handler for the shadeUntilCurrentTimeChange event.
     */
    @Output() shadeUntilCurrentTimeChange: EventEmitter<boolean>;

    /**
     * A handler for the showAllDayPanelChange event.
     */
    @Output() showAllDayPanelChange: EventEmitter<boolean>;

    /**
     * A handler for the showCurrentTimeIndicatorChange event.
     */
    @Output() showCurrentTimeIndicatorChange: EventEmitter<boolean>;

    /**
     * A handler for the startDateExprChange event.
     */
    @Output() startDateExprChange: EventEmitter<string>;

    /**
     * A handler for the startDateTimeZoneExprChange event.
     */
    @Output() startDateTimeZoneExprChange: EventEmitter<string>;

    /**
     * A handler for the startDayHourChange event.
     */
    @Output() startDayHourChange: EventEmitter<number>;

    /**
     * A handler for the tabIndexChange event.
     */
    @Output() tabIndexChange: EventEmitter<number>;

    /**
     * A handler for the textExprChange event.
     */
    @Output() textExprChange: EventEmitter<string>;

    /**
     * A handler for the timeCellTemplateChange event.
     */
    @Output() timeCellTemplateChange: EventEmitter<any>;

    /**
     * A handler for the timeZoneChange event.
     */
    @Output() timeZoneChange: EventEmitter<string>;

    /**
     * A handler for the useDropDownViewSwitcherChange event.
     */
    @Output() useDropDownViewSwitcherChange: EventEmitter<boolean>;

    /**
     * A handler for the viewsChange event.
     */
    @Output() viewsChange: EventEmitter<string|
        Array<string|
        { agendaDuration?: number, appointmentTemplate?: any, appointmentTooltipTemplate?: any, cellDuration?: number, dataCellTemplate?: any, dateCellTemplate?: any, dropDownAppointmentTemplate?: any, endDayHour?: number, firstDayOfWeek?: number|
        string, groups?: Array<string>, intervalCount?: number, maxAppointmentsPerCell?: number|
        string, name?: string, resourceCellTemplate?: any, startDate?: Date|
        number|
        string, startDayHour?: number, timeCellTemplate?: any, type?: string }>>;

    /**
     * A handler for the visibleChange event.
     */
    @Output() visibleChange: EventEmitter<boolean>;

    /**
     * A handler for the widthChange event.
     */
    @Output() widthChange: EventEmitter<number|
        Function|
        string>;




    @ContentChildren(DxiResourceComponent)
    get resourcesChildren(): QueryList<DxiResourceComponent> {
        return this._getOption('resources');
    }
    set resourcesChildren(value) {
        this.setChildren('resources', value);
    }

    @ContentChildren(DxiViewComponent)
    get viewsChildren(): QueryList<DxiViewComponent> {
        return this._getOption('views');
    }
    set viewsChildren(value) {
        this.setChildren('views', value);
    }


    constructor(elementRef: ElementRef, ngZone: NgZone, templateHost: DxTemplateHost, injector: Injector,
            private _watcherHelper: WatcherHelper,
            private _idh: IterableDifferHelper, optionHost: NestedOptionHost) {

        super(elementRef, ngZone, templateHost, _watcherHelper);
        injector.get(EventsRegistrator);

        this._createEventEmitters([
            { subscribe: 'appointmentAdded', emit: 'onAppointmentAdded' },
            { subscribe: 'appointmentAdding', emit: 'onAppointmentAdding' },
            { subscribe: 'appointmentClick', emit: 'onAppointmentClick' },
            { subscribe: 'appointmentDblClick', emit: 'onAppointmentDblClick' },
            { subscribe: 'appointmentDeleted', emit: 'onAppointmentDeleted' },
            { subscribe: 'appointmentDeleting', emit: 'onAppointmentDeleting' },
            { subscribe: 'appointmentFormCreated', emit: 'onAppointmentFormCreated' },
            { subscribe: 'appointmentRendered', emit: 'onAppointmentRendered' },
            { subscribe: 'appointmentUpdated', emit: 'onAppointmentUpdated' },
            { subscribe: 'appointmentUpdating', emit: 'onAppointmentUpdating' },
            { subscribe: 'cellClick', emit: 'onCellClick' },
            { subscribe: 'contentReady', emit: 'onContentReady' },
            { subscribe: 'disposing', emit: 'onDisposing' },
            { subscribe: 'initialized', emit: 'onInitialized' },
            { subscribe: 'optionChanged', emit: 'onOptionChanged' },
            { emit: 'accessKeyChange' },
            { emit: 'allDayExprChange' },
            { emit: 'appointmentTemplateChange' },
            { emit: 'appointmentTooltipTemplateChange' },
            { emit: 'cellDurationChange' },
            { emit: 'crossScrollingEnabledChange' },
            { emit: 'currentDateChange' },
            { emit: 'currentViewChange' },
            { emit: 'dataCellTemplateChange' },
            { emit: 'dataSourceChange' },
            { emit: 'dateCellTemplateChange' },
            { emit: 'dateSerializationFormatChange' },
            { emit: 'descriptionExprChange' },
            { emit: 'disabledChange' },
            { emit: 'dropDownAppointmentTemplateChange' },
            { emit: 'editingChange' },
            { emit: 'elementAttrChange' },
            { emit: 'endDateExprChange' },
            { emit: 'endDateTimeZoneExprChange' },
            { emit: 'endDayHourChange' },
            { emit: 'firstDayOfWeekChange' },
            { emit: 'focusStateEnabledChange' },
            { emit: 'groupsChange' },
            { emit: 'heightChange' },
            { emit: 'hintChange' },
            { emit: 'horizontalScrollingEnabledChange' },
            { emit: 'indicatorUpdateIntervalChange' },
            { emit: 'maxChange' },
            { emit: 'maxAppointmentsPerCellChange' },
            { emit: 'minChange' },
            { emit: 'noDataTextChange' },
            { emit: 'recurrenceEditModeChange' },
            { emit: 'recurrenceExceptionExprChange' },
            { emit: 'recurrenceRuleExprChange' },
            { emit: 'remoteFilteringChange' },
            { emit: 'resourceCellTemplateChange' },
            { emit: 'resourcesChange' },
            { emit: 'rtlEnabledChange' },
            { emit: 'shadeUntilCurrentTimeChange' },
            { emit: 'showAllDayPanelChange' },
            { emit: 'showCurrentTimeIndicatorChange' },
            { emit: 'startDateExprChange' },
            { emit: 'startDateTimeZoneExprChange' },
            { emit: 'startDayHourChange' },
            { emit: 'tabIndexChange' },
            { emit: 'textExprChange' },
            { emit: 'timeCellTemplateChange' },
            { emit: 'timeZoneChange' },
            { emit: 'useDropDownViewSwitcherChange' },
            { emit: 'viewsChange' },
            { emit: 'visibleChange' },
            { emit: 'widthChange' }
        ]);

        this._idh.setHost(this);
        optionHost.setHost(this);
    }

    protected _createInstance(element, options) {
        return new DxScheduler(element, options);
    }

    ngOnDestroy() {
        this._destroyWidget();
    }

    ngOnChanges(changes: SimpleChanges) {
        super.ngOnChanges(changes);
        this.setupChanges('dataSource', changes);
        this.setupChanges('groups', changes);
        this.setupChanges('resources', changes);
        this.setupChanges('views', changes);
    }

    setupChanges(prop: string, changes: SimpleChanges) {
        if (!(prop in this._optionsToUpdate)) {
            this._idh.setup(prop, changes);
        }
    }

    ngDoCheck() {
        this._idh.doCheck('dataSource');
        this._idh.doCheck('groups');
        this._idh.doCheck('resources');
        this._idh.doCheck('views');
        this._watcherHelper.checkWatchers();
        super.ngDoCheck();
    }

    _setOption(name: string, value: any) {
        let isSetup = this._idh.setupSingle(name, value);
        let isChanged = this._idh.getChanges(name, value) !== null;

        if (isSetup || isChanged) {
            super._setOption(name, value);
        }
    }

}

@NgModule({
  imports: [
    DxoEditingModule,
    DxiResourceModule,
    DxiViewModule,
    DxTemplateModule
  ],
  declarations: [
    DxSchedulerComponent
  ],
  exports: [
    DxSchedulerComponent,
    DxoEditingModule,
    DxiResourceModule,
    DxiViewModule,
    DxTemplateModule
  ],
  providers: [EventsRegistrator]

})
export class DxSchedulerModule { }