interface PivotGridSortable {
        allowUnsort?: boolean;
    }


interface PivotGridOptions {
        name?: string;
        dataSource?: any|kendo.data.PivotDataSource;
        autoBind?: boolean;
        reorderable?: boolean;
        excel?: PivotGridExcel;
        pdf?: PivotGridPdf;
        filterable?: boolean;
        sortable?: boolean | PivotGridSortable;
        columnWidth?: number;
        height?: number|string;
        columnHeaderTemplate?: string|Function;
        dataCellTemplate?: string|Function;
        kpiStatusTemplate?: string|Function;
        kpiTrendTemplate?: string|Function;
        rowHeaderTemplate?: string|Function;
        messages?: PivotGridMessages;
        dataBinding?(e: PivotGridDataBindingEvent): void;
        dataBound?(e: PivotGridDataBoundEvent): void;
        expandMember?(e: PivotGridExpandMemberEvent): void;
        collapseMember?(e: PivotGridCollapseMemberEvent): void;
        excelExport?(e: PivotGridExcelExportEvent): void;
        pdfExport?(e: PivotGridPdfExportEvent): void;
    }


interface PivotGridEvent {
        sender: PivotGrid;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PivotGridDataBindingEvent extends PivotGridEvent {
    }


interface PivotGridDataBoundEvent extends PivotGridEvent {
    }


interface PivotGridExpandMemberEvent extends PivotGridEvent {
        axis?: string;
        path?: string[];
    }


interface PivotGridCollapseMemberEvent extends PivotGridEvent {
        axis?: string;
        path?: string[];
    }


interface PivotGridExcelExportEvent extends PivotGridEvent {
        data?: any;
        workbook?: any;
    }


interface PivotGridPdfExportEvent extends PivotGridEvent {
        promise?: JQueryPromise<any>;
    }


interface PopupAnimationClose {
        effects?: string;
        duration?: number;
    }


interface PopupAnimationOpen {
        effects?: string;
        duration?: number;
    }


interface PopupAnimation {
        close?: PopupAnimationClose;
        open?: PopupAnimationOpen;
    }


interface PopupOptions {
        name?: string;
        adjustSize?: any;
        animation?: boolean | PopupAnimation;
        anchor?: string|JQuery;
        appendTo?: string|JQuery;
        collision?: string;
        origin?: string;
        position?: string;
        activate?(e: PopupActivateEvent): void;
        close?(e: PopupCloseEvent): void;
        deactivate?(e: PopupDeactivateEvent): void;
        open?(e: PopupOpenEvent): void;
    }


interface PopupEvent {
        sender: Popup;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PopupActivateEvent extends PopupEvent {
    }


interface PopupCloseEvent extends PopupEvent {
    }


interface PopupDeactivateEvent extends PopupEvent {
    }


interface PopupOpenEvent extends PopupEvent {
    }


interface ProgressBarAnimation {
        duration?: number;
    }


interface ProgressBarOptions {
        name?: string;
        animation?: boolean | ProgressBarAnimation;
        chunkCount?: number;
        enable?: boolean;
        max?: number;
        min?: number;
        orientation?: string;
        reverse?: boolean;
        showStatus?: boolean;
        type?: string;
        value?: number;
        change?(e: ProgressBarChangeEvent): void;
        complete?(e: ProgressBarCompleteEvent): void;
    }


interface ProgressBarEvent {
        sender: ProgressBar;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ProgressBarChangeEvent extends ProgressBarEvent {
        value?: number;
    }


interface ProgressBarCompleteEvent extends ProgressBarEvent {
        value?: number;
    }


interface PromptMessages {
        okText?: string;
        cancel?: string;
    }


interface PromptOptions {
        name?: string;
        messages?: PromptMessages;
    }


interface PromptEvent {
        sender: Prompt;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RadioGroupItem {
        attributes?: any;
        cssClass?: string;
        enabled?: boolean;
        encoded?: boolean;
        label?: string;
        value?: string;
    }


interface RadioGroupOptions {
        name?: string;
        enabled?: boolean;
        items?: RadioGroupItem[];
        labelPosition?: string;
        layout?: string;
        inputName?: string;
        value?: string;
        change?(e: RadioGroupChangeEvent): void;
        focus?(e: RadioGroupFocusEvent): void;
        select?(e: RadioGroupSelectEvent): void;
    }


interface RadioGroupEvent {
        sender: RadioGroup;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RadioGroupChangeEvent extends RadioGroupEvent {
        target?: JQuery;
        oldValue?: string;
        newValue?: string;
    }


interface RadioGroupFocusEvent extends RadioGroupEvent {
        target?: JQuery;
    }


interface RadioGroupSelectEvent extends RadioGroupEvent {
        target?: JQuery;
    }


interface RangeSliderTooltip {
        enabled?: boolean;
        format?: string;
        template?: string;
    }


interface RangeSliderOptions {
        name?: string;
        largeStep?: number;
        leftDragHandleTitle?: string;
        max?: number;
        min?: number;
        orientation?: string;
        rightDragHandleTitle?: string;
        selectionEnd?: number;
        selectionStart?: number;
        smallStep?: number;
        tickPlacement?: string;
        tooltip?: RangeSliderTooltip;
        change?(e: RangeSliderChangeEvent): void;
        slide?(e: RangeSliderSlideEvent): void;
    }


interface RangeSliderEvent {
        sender: RangeSlider;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RangeSliderChangeEvent extends RangeSliderEvent {
        value?: any;
    }


interface RangeSliderSlideEvent extends RangeSliderEvent {
        value?: any;
    }


interface RatingOptions {
        name?: string;
        min?: number;
        max?: number;
        selection: string | "continuous" | "single";
        precision: string | "item" | "half";
        label?: boolean | RatingLabel;
        tooltip?: boolean;
        itemTemplate?: string|Function;
        selectedTemplate?: string|Function;
        hoveredTemplate?: string|Function;
        selectValueOnFocus?: number;
        enabled?: boolean;
        readonly?: boolean;
        change?(e: RatingChangeEvent): void;
        select?(e: RatingSelectEvent): void;
    }


interface RatingLabel {
        template: string|Function;
    }


interface RatingEvent {
        sender: Rating;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RatingChangeEvent extends RatingEvent {
        target?: Element;
        oldValue?: number;
        newValue?: number;
    }


interface RatingSelectEvent extends RatingEvent {
        target?: Element;
    }


interface ResponsivePanelOptions {
        name?: string;
        autoClose?: boolean;
        breakpoint?: number;
        orientation?: string;
        toggleButton?: string;
        close?(e: ResponsivePanelEvent): void;
        open?(e: ResponsivePanelEvent): void;
    }


interface ResponsivePanelEvent {
        sender: ResponsivePanel;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SchedulerSelectOptions {
        events?: SchedulerEvent[] | any[];
        resources? : any[];
        start?: Date;
        end?: Date;
        isAllDay?: boolean;
    }


interface SchedulerCurrentTimeMarker {
        updateInterval?: number;
        useLocalTimezone?: boolean;
    }


interface SchedulerEditable {
        confirmation?: boolean|string;
        create?: boolean;
        destroy?: boolean;
        editRecurringMode?: string;
        move?: boolean;
        resize?: boolean;
        template?: string|Function;
        update?: boolean;
        window?: any;
    }


interface SchedulerFooter {
        command?: string|boolean;
    }


interface SchedulerGroup {
        date?: boolean;
        resources?: any;
        orientation?: string;
    }


interface SchedulerMessagesEditable {
        confirmation?: string;
    }


interface SchedulerMessagesEditor {
        allDayEvent?: string;
        description?: string;
        editorTitle?: string;
        end?: string;
        endTimezone?: string;
        repeat?: string;
        separateTimezones?: string;
        start?: string;
        startTimezone?: string;
        timezone?: string;
        timezoneEditorButton?: string;
        timezoneEditorTitle?: string;
        title?: string;
    }


interface SchedulerMessagesRecurrenceEditorDaily {
        interval?: string;
        repeatEvery?: string;
    }


interface SchedulerMessagesRecurrenceEditorEnd {
        after?: string;
        occurrence?: string;
        label?: string;
        never?: string;
        mobileLabel?: string;
        on?: string;
    }


interface SchedulerMessagesRecurrenceEditorFrequencies {
        daily?: string;
        monthly?: string;
        never?: string;
        weekly?: string;
        yearly?: string;
    }


interface SchedulerMessagesRecurrenceEditorMonthly {
        day?: string;
        interval?: string;
        repeatEvery?: string;
        repeatOn?: string;
    }


interface SchedulerMessagesRecurrenceEditorOffsetPositions {
        first?: string;
        second?: string;
        third?: string;
        fourth?: string;
        last?: string;
    }


interface SchedulerMessagesRecurrenceEditorWeekdays {
        day?: string;
        weekday?: string;
        weekend?: string;
    }


interface SchedulerMessagesRecurrenceEditorWeekly {
        interval?: string;
        repeatEvery?: string;
        repeatOn?: string;
    }


interface SchedulerMessagesRecurrenceEditorYearly {
        of?: string;
        repeatEvery?: string;
        repeatOn?: string;
        interval?: string;
    }


interface SchedulerMessagesRecurrenceEditor {
        daily?: SchedulerMessagesRecurrenceEditorDaily;
        end?: SchedulerMessagesRecurrenceEditorEnd;
        frequencies?: SchedulerMessagesRecurrenceEditorFrequencies;
        monthly?: SchedulerMessagesRecurrenceEditorMonthly;
        offsetPositions?: SchedulerMessagesRecurrenceEditorOffsetPositions;
        recurrenceEditorTitle?: string;
        weekly?: SchedulerMessagesRecurrenceEditorWeekly;
        weekdays?: SchedulerMessagesRecurrenceEditorWeekdays;
        yearly?: SchedulerMessagesRecurrenceEditorYearly;
    }


interface SchedulerMessagesRecurrenceMessages {
        deleteRecurring?: string;
        deleteWindowOccurrence?: string;
        deleteWindowSeries?: string;
        deleteWindowTitle?: string;
        editRecurring?: string;
        editWindowOccurrence?: string;
        editWindowSeries?: string;
        editWindowTitle?: string;
    }


interface SchedulerMessagesViews {
        day?: string;
        week?: string;
        month?: string;
        agenda?: string;
        year?: string;
    }


interface SchedulerMessages {
        allDay?: string;
        ariaEventLabel?: string;
        ariaSlotLabel?: string;
        cancel?: string;
        date?: string;
        deleteWindowTitle?: string;
        destroy?: string;
        event?: string;
        defaultRowText?: string;
        next?: string;
        pdf?: string;
        previous?: string;
        save?: string;
        showFullDay?: string;
        showWorkDay?: string;
        time?: string;
        today?: string;
        editable?: SchedulerMessagesEditable;
        editor?: SchedulerMessagesEditor;
        recurrenceEditor?: SchedulerMessagesRecurrenceEditor;
        recurrenceMessages?: SchedulerMessagesRecurrenceMessages;
        views?: SchedulerMessagesViews;
    }


interface SchedulerPdfMargin {
        bottom?: number|string;
        left?: number|string;
        right?: number|string;
        top?: number|string;
    }


interface SchedulerPdf {
        author?: string;
        avoidLinks?: boolean|string;
        creator?: string;
        date?: Date;
        fileName?: string;
        forceProxy?: boolean;
        keywords?: string;
        landscape?: boolean;
        margin?: SchedulerPdfMargin;
        paperSize?: string|any;
        proxyURL?: string;
        proxyTarget?: string;
        subject?: string;
        title?: string;
    }


interface SchedulerResource {
        dataColorField?: string;
        dataParentValueField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        field?: string;
        multiple?: boolean;
        name?: string;
        title?: string;
        valuePrimitive?: boolean;
    }


interface SchedulerToolbarItem {
        name?: string;
    }


interface SchedulerViewEditable {
        create?: boolean;
        destroy?: boolean;
        update?: boolean;
    }


interface SchedulerViewGroup {
        date?: boolean;
        orientation?: string;
    }


interface SchedulerView {
        adaptiveSlotHeight?: boolean;
        allDayEventTemplate?: string|Function;
        allDaySlot?: boolean;
        allDaySlotTemplate?: string|Function;
        columnWidth?: number;
        content?: JQuery;
        dateHeaderTemplate?: string|Function;
        dayTemplate?: string|Function;
        editable?: boolean | SchedulerViewEditable;
        endDate?(): Date;
        endTime?: Date;
        eventHeight?: number | string;
        eventSpacing?: number;
        eventsPerDay?: number;
        eventTemplate?: string|Function;
        eventTimeTemplate?: string|Function;
        group?: SchedulerViewGroup;
        majorTick?: number;
        majorTimeHeaderTemplate?: string|Function;
        minorTickCount?: number;
        minorTimeHeaderTemplate?: string|Function;
        name?: string;
        selected?: boolean;
        selectedDateFormat?: string;
        selectedShortDateFormat?: string;
        showWorkHours?: boolean;
        slotTemplate?: string|Function;
        startDate?(): Date;
        startTime?: Date;
        title?: string;
        type?: string;
        workWeekStart?: number;
        workWeekEnd?: number;
        months?: number;
        tooltipTemplate?: string|Function;
    }


interface SchedulerOptions {
        name?: string;
        allDayEventTemplate?: string|Function;
        allDaySlot?: boolean;
        autoBind?: boolean;
        currentTimeMarker?: boolean | SchedulerCurrentTimeMarker;
        dataSource?: any|any|kendo.data.SchedulerDataSource;
        date?: Date;
        dateHeaderTemplate?: string|Function;
        editable?: boolean | SchedulerEditable;
        endTime?: Date;
        eventTemplate?: string|Function;
        footer?: boolean | SchedulerFooter;
        group?: SchedulerGroup;
        groupHeaderTemplate?: string|Function;
        height?: number|string;
        majorTick?: number;
        majorTimeHeaderTemplate?: string|Function;
        max?: Date;
        messages?: SchedulerMessages;
        min?: Date;
        minorTickCount?: number;
        minorTimeHeaderTemplate?: string|Function;
        mobile?: boolean|string;
        pdf?: SchedulerPdf;
        resources?: SchedulerResource[];
        selectable?: boolean;
        showWorkHours?: boolean;
        snap?: boolean;
        startTime?: Date;
        timezone?: string;
        toolbar?: SchedulerToolbarItem[];
        views?: SchedulerView[];
        width?: number|string;
        workDayStart?: Date;
        workDayEnd?: Date;
        workWeekStart?: number;
        workWeekEnd?: number;
        add?(e: SchedulerAddEvent): void;
        cancel?(e: SchedulerCancelEvent): void;
        change?(e: SchedulerChangeEvent): void;
        dataBinding?(e: SchedulerDataBindingEvent): void;
        dataBound?(e: SchedulerDataBoundEvent): void;
        edit?(e: SchedulerEditEvent): void;
        moveStart?(e: SchedulerMoveStartEvent): void;
        move?(e: SchedulerMoveEvent): void;
        moveEnd?(e: SchedulerMoveEndEvent): void;
        navigate?(e: SchedulerNavigateEvent): void;
        pdfExport?(e: SchedulerPdfExportEvent): void;
        remove?(e: SchedulerRemoveEvent): void;
        resizeStart?(e: SchedulerResizeStartEvent): void;
        resize?(e: SchedulerResizeEvent): void;
        resizeEnd?(e: SchedulerResizeEndEvent): void;
        save?(e: SchedulerSaveEvent): void;
    }


interface SchedulerEvent {
        sender: Scheduler;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SchedulerAddEvent extends SchedulerEvent {
        event?: any;
    }


interface SchedulerCancelEvent extends SchedulerEvent {
        container?: JQuery;
        event?: kendo.data.SchedulerEvent;
    }


interface SchedulerChangeEvent extends SchedulerEvent {
        start?: Date;
        end?: Date;
        events?: any;
        slots?: any;
        resources?: any;
    }


interface SchedulerDataBindingEvent extends SchedulerEvent {
    }


interface SchedulerDataBoundEvent extends SchedulerEvent {
    }


interface SchedulerEditEvent extends SchedulerEvent {
        container?: JQuery;
        event?: kendo.data.SchedulerEvent;
    }


interface SchedulerMoveStartEvent extends SchedulerEvent {
        event?: kendo.data.SchedulerEvent;
    }


interface SchedulerMoveEvent extends SchedulerEvent {
        event?: kendo.data.SchedulerEvent;
        slot?: any;
    }


interface SchedulerMoveEndEvent extends SchedulerEvent {
        start?: Date;
        end?: Date;
        event?: kendo.data.SchedulerEvent;
        slot?: any;
        resources?: any;
    }


interface SchedulerNavigateEvent extends SchedulerEvent {
        action?: string;
        date?: Date;
        view?: string;
    }


interface SchedulerPdfExportEvent extends SchedulerEvent {
        promise?: JQueryPromise<any>;
    }


interface SchedulerRemoveEvent extends SchedulerEvent {
        event?: kendo.data.SchedulerEvent;
    }


interface SchedulerResizeStartEvent extends SchedulerEvent {
        event?: kendo.data.SchedulerEvent;
    }


interface SchedulerResizeEvent extends SchedulerEvent {
        event?: kendo.data.SchedulerEvent;
        slot?: any;
    }


interface SchedulerResizeEndEvent extends SchedulerEvent {
        start?: Date;
        end?: Date;
        event?: kendo.data.SchedulerEvent;
        slot?: any;
    }


interface SchedulerSaveEvent extends SchedulerEvent {
        container?: JQuery;
        event?: kendo.data.SchedulerEvent;
    }


interface ScrollViewMessages {
        nextButtonLabel?: string;
        previousButtonLabel?: string;
    }


interface ScrollViewPageable {
        ARIATemplate?: string;
    }


interface ScrollViewOptions {
        name?: string;
        ARIATemplate?: string;
        autoBind?: boolean;
        bounceVelocityThreshold?: number;
        contentHeight?: number|string;
        dataSource?: kendo.data.DataSource|any;
        duration?: number;
        emptyTemplate?: string;
        enablePager?: boolean;
        messages?: ScrollViewMessages;
        navigatable?: boolean;
        pageable?: boolean | ScrollViewPageable;
        page?: number;
        template?: string;
        velocityThreshold?: number;
        change?(e: ScrollViewChangeEvent): void;
        refresh?(e: ScrollViewRefreshEvent): void;
    }


interface ScrollViewEvent {
        sender: ScrollView;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ScrollViewChangeEvent extends ScrollViewEvent {
        currentPage?: number;
        nextPage?: number;
        element?: JQuery;
        data?: any;
    }


interface ScrollViewRefreshEvent extends ScrollViewEvent {
        pageCount?: number;
        page?: number;
    }


interface SkeletonContainerGridGap {
        columns?: number;
        rows?: number;
    }


interface SkeletonContainerGridItem {
        colStart?: number;
        colSpan?: number;
        rowStart?: number;
        rowSpan?: number;
        shape?: string;
    }


interface SkeletonContainerGrid {
        columns?: number;
        gap?: SkeletonContainerGridGap;
        items?: SkeletonContainerGridItem[];
        rows?: number;
    }


interface SkeletonContainerOptions {
        name?: string;
        animation?: string;
        grid?: SkeletonContainerGrid;
        height?: string|number;
        template?: string|Function;
        width?: string|number;
    }


interface SkeletonContainerEvent {
        sender: SkeletonContainer;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SliderTooltip {
        enabled?: boolean;
        format?: string;
        template?: string|Function;
    }


interface SliderOptions {
        name?: string;
        decreaseButtonTitle?: string;
        dragHandleTitle?: string;
        increaseButtonTitle?: string;
        largeStep?: number;
        max?: number;
        min?: number;
        orientation?: string;
        showButtons?: boolean;
        smallStep?: number;
        tickPlacement?: string;
        tooltip?: SliderTooltip;
        value?: number;
        change?(e: SliderChangeEvent): void;
        slide?(e: SliderSlideEvent): void;
    }


interface SliderEvent {
        sender: Slider;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SliderChangeEvent extends SliderEvent {
        value?: number;
    }


interface SliderSlideEvent extends SliderEvent {
        value?: number;
    }


interface SortableCursorOffset {
        left?: number;
        top?: number;
    }


interface SortableOptions {
        name?: string;
        axis?: string;
        autoScroll?: boolean;
        container?: string|JQuery;
        connectWith?: string;
        cursor?: string;
        cursorOffset?: SortableCursorOffset;
        disabled?: string;
        filter?: string;
        handler?: string;
        hint?: Function|string|JQuery;
        holdToDrag?: boolean;
        ignore?: string;
        placeholder?: Function|string|JQuery;
        start?(e: SortableStartEvent): void;
        move?(e: SortableMoveEvent): void;
        end?(e: SortableEndEvent): void;
        change?(e: SortableChangeEvent): void;
        cancel?(e: SortableCancelEvent): void;
    }


interface SortableEvent {
        sender: Sortable;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SortableStartEvent extends SortableEvent {
        draggableEvent?: any;
        item?: JQuery;
    }


interface SortableMoveEvent extends SortableEvent {
        item?: JQuery;
        target?: JQuery;
        list?: kendo.ui.Sortable;
        draggableEvent?: any;
    }


interface SortableEndEvent extends SortableEvent {
        action?: string;
        item?: JQuery;
        oldIndex?: number;
        newIndex?: number;
        draggableEvent?: any;
    }


interface SortableChangeEvent extends SortableEvent {
        action?: string;
        item?: JQuery;
        oldIndex?: number;
        newIndex?: number;
        draggableEvent?: any;
    }


interface SortableCancelEvent extends SortableEvent {
        item?: JQuery;
    }


interface SplitterPane {
        collapsed?: boolean;
        collapsedSize?: string;
        collapsible?: boolean;
        contentUrl?: string;
        max?: string;
        min?: string;
        resizable?: boolean;
        scrollable?: boolean;
        size?: string;
    }


interface SplitterOptions {
        name?: string;
        orientation?: string;
        panes?: SplitterPane[];
        collapse?(e: SplitterCollapseEvent): void;
        contentLoad?(e: SplitterContentLoadEvent): void;
        error?(e: SplitterErrorEvent): void;
        expand?(e: SplitterExpandEvent): void;
        layoutChange?(e: SplitterEvent): void;
        resize?(e: SplitterEvent): void;
    }


interface SplitterEvent {
        sender: Splitter;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SplitterCollapseEvent extends SplitterEvent {
        pane?: Element;
    }


interface SplitterContentLoadEvent extends SplitterEvent {
        pane?: Element;
    }


interface SplitterErrorEvent extends SplitterEvent {
        xhr?: JQueryXHR;
        status?: string;
    }


interface SplitterExpandEvent extends SplitterEvent {
        pane?: Element;
    }


interface SpreadsheetDefaultCellStyle {
        background?: string;
        color?: string;
        fontFamily?: string;
        fontSize?: string;
        Italic?: boolean;
        bold?: boolean;
        underline?: boolean;
        wrap?: boolean;
    }


interface SpreadsheetExcel {
        fileName?: string;
        forceProxy?: boolean;
        proxyURL?: string;
    }


interface SpreadsheetPdfMargin {
        bottom?: number|string;
        left?: number|string;
        right?: number|string;
        top?: number|string;
    }


interface SpreadsheetPdf {
        area?: string;
        author?: string;
        creator?: string;
        date?: Date;
        fileName?: string;
        fitWidth?: boolean;
        forceProxy?: boolean;
        guidelines?: boolean;
        hCenter?: boolean;
        keywords?: string;
        landscape?: boolean;
        margin?: SpreadsheetPdfMargin;
        paperSize?: string|any;
        proxyURL?: string;
        proxyTarget?: string;
        subject?: string;
        title?: string;
        vCenter?: boolean;
    }


interface SpreadsheetSheetColumn {
        index?: number;
        width?: number;
    }


interface SpreadsheetSheetFilterColumnCriteriaItem {
        operator?: string;
        value?: string;
    }


interface SpreadsheetSheetFilterColumn {
        criteria?: SpreadsheetSheetFilterColumnCriteriaItem[];
        filter?: string;
        index?: number;
        logic?: string;
        type?: string;
        value?: number|string|Date;
        values?: any;
    }


interface SpreadsheetSheetFilter {
        columns?: SpreadsheetSheetFilterColumn[];
        ref?: string;
    }


interface SpreadsheetSheetRowCellBorderBottom {
        color?: string;
        size?: string;
    }


interface SpreadsheetSheetRowCellBorderLeft {
        color?: string;
        size?: string;
    }


interface SpreadsheetSheetRowCellBorderRight {
        color?: string;
        size?: string;
    }


interface SpreadsheetSheetRowCellBorderTop {
        color?: string;
        size?: string;
    }


interface SpreadsheetSheetRowCellValidation {
        type?: string;
        comparerType?: string;
        dataType?: string;
        from?: string;
        showButton?: boolean;
        to?: string;
        allowNulls?: boolean;
        messageTemplate?: string;
        titleTemplate?: string;
    }


interface SpreadsheetSheetRowCell {
        background?: string;
        borderBottom?: SpreadsheetSheetRowCellBorderBottom;
        borderLeft?: SpreadsheetSheetRowCellBorderLeft;
        borderTop?: SpreadsheetSheetRowCellBorderTop;
        borderRight?: SpreadsheetSheetRowCellBorderRight;
        color?: string;
        comment?: string;
        fontFamily?: string;
        fontSize?: number;
        italic?: boolean;
        bold?: boolean;
        enable?: boolean;
        format?: string;
        formula?: string;
        index?: number;
        link?: string;
        textAlign?: string;
        underline?: boolean;
        value?: number|string|boolean|Date;
        validation?: SpreadsheetSheetRowCellValidation;
        verticalAlign?: string;
        wrap?: boolean;
    }


interface SpreadsheetSheetRow {
        cells?: SpreadsheetSheetRowCell[];
        height?: number;
        index?: number;
        type?: string;
    }


interface SpreadsheetSheetSortColumn {
        ascending?: boolean;
        index?: number;
    }


interface SpreadsheetSheetSort {
        columns?: SpreadsheetSheetSortColumn[];
        ref?: string;
    }


interface SpreadsheetSheet {
        activeCell?: string;
        name?: string;
        columns?: SpreadsheetSheetColumn[];
        dataSource?: kendo.data.DataSource;
        filter?: SpreadsheetSheetFilter;
        frozenColumns?: number;
        frozenRows?: number;
        mergedCells?: any;
        rows?: SpreadsheetSheetRow[];
        selection?: string;
        showGridLines?: boolean;
        sort?: SpreadsheetSheetSort;
    }


interface SpreadsheetToolbar {
        home?: boolean|any;
        insert?: boolean|any;
        data?: boolean|any;
    }


interface SpreadsheetInsertSheetOptions {
        rows?: number;
        columns?: number;
        rowHeight?: number;
        columnWidth?: number;
        headerHeight?: number;
        headerWidth?: number;
        dataSource?: kendo.data.DataSource;
        data?: any;
    }


interface SpreadsheetOptions {
        name?: string;
        activeSheet?: string;
        columnWidth?: number;
        columns?: number;
        defaultCellStyle?: SpreadsheetDefaultCellStyle;
        headerHeight?: number;
        headerWidth?: number;
        excel?: SpreadsheetExcel;
        pdf?: SpreadsheetPdf;
        rowHeight?: number;
        rows?: number;
        sheets?: SpreadsheetSheet[];
        sheetsbar?: boolean;
        toolbar?: boolean | SpreadsheetToolbar;
        useCultureDecimals?: boolean;
        insertSheet?(e: SpreadsheetInsertSheetEvent): void;
        removeSheet?(e: SpreadsheetRemoveSheetEvent): void;
        renameSheet?(e: SpreadsheetRenameSheetEvent): void;
        selectSheet?(e: SpreadsheetSelectSheetEvent): void;
        unhideColumn?(e: SpreadsheetUnhideColumnEvent): void;
        unhideRow?(e: SpreadsheetUnhideRowEvent): void;
        hideColumn?(e: SpreadsheetHideColumnEvent): void;
        hideRow?(e: SpreadsheetHideRowEvent): void;
        deleteColumn?(e: SpreadsheetDeleteColumnEvent): void;
        deleteRow?(e: SpreadsheetDeleteRowEvent): void;
        insertColumn?(e: SpreadsheetInsertColumnEvent): void;
        insertRow?(e: SpreadsheetInsertRowEvent): void;
        select?(e: SpreadsheetSelectEvent): void;
        changeFormat?(e: SpreadsheetChangeFormatEvent): void;
        changing?(e: SpreadsheetChangingEvent): void;
        change?(e: SpreadsheetChangeEvent): void;
        render?(e: SpreadsheetRenderEvent): void;
        excelExport?(e: SpreadsheetExcelExportEvent): void;
        excelImport?(e: SpreadsheetExcelImportEvent): void;
        pdfExport?(e: SpreadsheetPdfExportEvent): void;
        cut?(e: SpreadsheetCutEvent): void;
        copy?(e: SpreadsheetCopyEvent): void;
        paste?(e: SpreadsheetPasteEvent): void;
        dataBinding?(e: SpreadsheetDataBindingEvent): void;
        dataBound?(e: SpreadsheetDataBoundEvent): void;
    }


interface SpreadsheetEvent {
        sender: Spreadsheet;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SpreadsheetInsertSheetEvent extends SpreadsheetEvent {
    }


interface SpreadsheetRemoveSheetEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
    }


interface SpreadsheetRenameSheetEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        newSheetName?: string;
    }


interface SpreadsheetSelectSheetEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
    }


interface SpreadsheetUnhideColumnEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetUnhideRowEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetHideColumnEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetHideRowEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetDeleteColumnEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetDeleteRowEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetInsertColumnEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetInsertRowEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
        index?: number;
    }


interface SpreadsheetSelectEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
    }


interface SpreadsheetChangeFormatEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
    }


interface SpreadsheetChangingEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
        data?: any;
        changeType?: string;
    }


interface SpreadsheetChangeEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
    }


interface SpreadsheetRenderEvent extends SpreadsheetEvent {
    }


interface SpreadsheetExcelExportEvent extends SpreadsheetEvent {
        data?: any;
        workbook?: kendo.ooxml.Workbook;
    }


interface SpreadsheetExcelImportEvent extends SpreadsheetEvent {
        file?: Blob|File;
        progress?: JQueryPromise<any>;
    }


interface SpreadsheetPdfExportEvent extends SpreadsheetEvent {
        promise?: JQueryPromise<any>;
    }


interface SpreadsheetCopyEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
    }


interface SpreadsheetCutEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
    }


interface SpreadsheetPasteEvent extends SpreadsheetEvent {
        range?: kendo.spreadsheet.Range;
        clipboardContent?: any;
    }


interface SpreadsheetDataBindingEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
    }


interface SpreadsheetDataBoundEvent extends SpreadsheetEvent {
        sheet?: kendo.spreadsheet.Sheet;
    }


interface SwitchOptions {
        name?: string;
        checked?: boolean;
        enabled?: boolean;
        readonly?: boolean;
        width?: number|string;
        messages?: SwitchMessages;
        change?(e: SwitchChangeEvent): void;
    }


interface SwitchMessages {
        checked?: string;
        unchecked?: string;
    }


interface SwitchEvent {
        sender: Switch;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SwitchChangeEvent extends SwitchEvent {
        checked?: any;
    }


interface StepperOptions {
        name?: string;
        orientation?: string | "horizontal" | "vertical";
        linear?: boolean;
        indicator?: boolean;
        label?: boolean;
        selectOnFocus?: boolean;
        steps: kendo.stepper.StepOptions[] | string[];

        activate?(e: StepperActivateEvent): void;
        select?(e: StepperSelectEvent): void;
    }


interface StepperActivateEvent {
        sender?: Stepper;
        originalEvent?: any;
        step?: kendo.stepper.Step;
    }


interface StepperSelectEvent extends StepperActivateEvent {
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TabStripAnimationClose {
        duration?: number;
        effects?: string;
    }


interface TabStripAnimationOpen {
        duration?: number;
        effects?: string;
    }


interface TabStripAnimation {
        close?: TabStripAnimationClose;
        open?: TabStripAnimationOpen;
    }


interface TabStripScrollable {
        distance?: number;
    }


interface TabStripOptions {
        name?: string;
        animation?: boolean | TabStripAnimation;
        collapsible?: boolean;
        contentUrls?: any;
        dataContentField?: string;
        dataContentUrlField?: string;
        dataImageUrlField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataSpriteCssClass?: string;
        dataTextField?: string;
        dataUrlField?: string;
        navigatable?: boolean;
        scrollable?: boolean | TabStripScrollable;
        tabPosition?: string;
        value?: string;
        activate?(e: TabStripActivateEvent): void;
        contentLoad?(e: TabStripContentLoadEvent): void;
        error?(e: TabStripErrorEvent): void;
        select?(e: TabStripSelectEvent): void;
        show?(e: TabStripShowEvent): void;
    }


interface TabStripEvent {
        sender: TabStrip;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TabStripActivateEvent extends TabStripEvent {
        item?: Element;
        contentElement?: Element;
    }


interface TabStripContentLoadEvent extends TabStripEvent {
        item?: Element;
        contentElement?: Element;
    }


interface TabStripErrorEvent extends TabStripEvent {
        xhr?: JQueryXHR;
        status?: string;
    }


interface TabStripSelectEvent extends TabStripEvent {
        item?: Element;
        contentElement?: Element;
    }


interface TabStripShowEvent extends TabStripEvent {
        item?: Element;
        contentElement?: Element;
    }


interface TaskBoardCardMenuItem {
        name?: string;
        text?: string;
        icon?: string;
        spriteCssClass?: string;
        command?: string;
        options?: string;
    }


interface TaskBoardColumnSettingsButton {
        name?: string;
        text?: string;
        icon?: string;
        spriteCssClass?: string;
        command?: string;
        options?: string;
    }


interface TaskBoardColumnSettings {
        buttons?: TaskBoardColumnSettingsButton[];
        dataStatusField?: string;
        dataTextField?: string;
        dataOrderField?: string;
        width?: string|number;
        template?: string|Function;
    }


interface TaskBoardEditableButton {
        name?: string;
        text?: string;
        icon?: string;
        spriteCssClass?: string;
        command?: string;
        options?: string;
        primary?: boolean;
    }


interface TaskBoardEditable {
        buttons?: TaskBoardEditableButton[];
        form?: any;
        headerTemplate?: string|Function;
    }


interface TaskBoardMessages {
        edit?: string;
        createNewCard?: string;
        create?: string;
        search?: string;
        previewCard?: string;
        addCard?: string;
        editCard?: string;
        deleteCard?: string;
        addColumn?: string;
        editColumn?: string;
        deleteColumn?: string;
        close?: string;
        cancel?: string;
        delete?: string;
        saveChanges?: string;
        title?: string;
        description?: string;
        newColumn?: string;
        deleteColumnConfirm?: string;
        deleteCardConfirm?: string;
    }


interface TaskBoardPreviewPaneButton {
        name?: string;
        text?: string;
        icon?: string;
        spriteCssClass?: string;
        command?: string;
        options?: string;
        primary?: boolean;
    }


interface TaskBoardPreviewPane {
        buttons?: TaskBoardPreviewPaneButton[];
        template?: string|Function;
        headerTemplate?: string|Function;
    }


interface TaskBoardResource {
        dataColorField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        field?: string;
        multiple?: boolean;
        name?: string;
        title?: string;
        valuePrimitive?: boolean;
    }


interface TaskBoardToolbarItem {
        type?: string;
        overflow?: string;
        click?: Function;
        command?: string;
        options?: string;
        name?: string;
        togglable?: boolean;
        text?: string;
        template?: string|Function;
        showText?: string;
        primary?: boolean;
        attributes?: any;
        enable?: boolean;
        hidden?: boolean;
        spriteCssClass?: string;
        imageUrl?: string;
        showIcon?: string;
        icon?: string;
        id?: string;
    }


interface TaskBoardToolbar {
        items?: TaskBoardToolbarItem[];
    }


interface TaskBoardRegisterShortcutOptions {
        command?: string;
        options?: string;
        handler?: Function;
    }


interface TaskBoardOptions {
        name?: string;
        autoBind?: boolean;
        cardMenu?: TaskBoardCardMenuItem[];
        columns?: any|any|kendo.data.DataSource;
        columnSettings?: TaskBoardColumnSettings;
        dataOrderField?: string;
        dataCategoryField?: string;
        dataDescriptionField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataStatusField?: string;
        dataTitleField?: string;
        editable?: boolean | TaskBoardEditable;
        height?: string|number;
        previewPane?: boolean | TaskBoardPreviewPane;
        reorderable?: boolean;
        resources?: TaskBoardResource[];
        selectable?: boolean;
        template?: string|Function;
        toolbar?: boolean | TaskBoardToolbar;
        width?: string|number;
        messages?: TaskBoardMessages;
        columnsDataBinding?(e: TaskBoardColumnsDataBindingEvent): void;
        columnsDataBound?(e: TaskBoardColumnsDataBoundEvent): void;
        select?(e: TaskBoardSelectEvent): void;
        dataBinding?(e: TaskBoardDataBindingEvent): void;
        dataBound?(e: TaskBoardDataBoundEvent): void;
        deleteCard?(e: TaskBoardDeleteCardEvent): void;
        deleteColumn?(e: TaskBoardDeleteColumnEvent): void;
        editCard?(e: TaskBoardEditCardEvent): void;
        editColumn?(e: TaskBoardEditColumnEvent): void;
        executeCommand?(e: TaskBoardExecuteCommandEvent): void;
        move?(e: TaskBoardMoveEvent): void;
        moveEnd?(e: TaskBoardMoveEndEvent): void;
        moveStart?(e: TaskBoardMoveStartEvent): void;
        change?(e: TaskBoardChangeEvent): void;
        saveCard?(e: TaskBoardSaveCardEvent): void;
        saveColumn?(e: TaskBoardSaveColumnEvent): void;
    }


interface TaskBoardEvent {
        sender: TaskBoard;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TaskBoardColumnsDataBindingEvent extends TaskBoardEvent {
        action?: string;
        index?: number;
        items?: any;
    }


interface TaskBoardColumnsDataBoundEvent extends TaskBoardEvent {
    }


interface TaskBoardSelectEvent extends TaskBoardEvent {
        card?: JQuery;
    }


interface TaskBoardDataBindingEvent extends TaskBoardEvent {
        action?: string;
        index?: number;
        items?: any;
    }


interface TaskBoardDataBoundEvent extends TaskBoardEvent {
    }


interface TaskBoardDeleteCardEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
    }


interface TaskBoardDeleteColumnEvent extends TaskBoardEvent {
        column?: kendo.data.Model;
    }


interface TaskBoardEditCardEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
    }


interface TaskBoardEditColumnEvent extends TaskBoardEvent {
        column?: kendo.data.Model;
    }


interface TaskBoardExecuteCommandEvent extends TaskBoardEvent {
        command?: string;
        options?: any;
    }


interface TaskBoardMoveEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
        cardElement?: JQuery;
        column?: kendo.data.Model;
        columnElement?: JQuery;
        item?: JQuery;
        target?: JQuery;
        list?: kendo.ui.Sortable;
        draggableEvent?: any;
    }


interface TaskBoardMoveEndEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
        cardElement?: JQuery;
        column?: kendo.data.Model;
        columnElement?: JQuery;
        action?: string;
        item?: JQuery;
        oldIndex?: number;
        newIndex?: number;
        draggableEvent?: any;
    }


interface TaskBoardMoveStartEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
        cardElement?: JQuery;
        column?: kendo.data.Model;
        columnElement?: JQuery;
        draggableEvent?: any;
        item?: JQuery;
    }


interface TaskBoardChangeEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
        cardElement?: JQuery;
        column?: kendo.data.Model;
        columnElement?: JQuery;
        action?: string;
        item?: JQuery;
        oldIndex?: number;
        newIndex?: number;
        draggableEvent?: any;
    }


interface TaskBoardSaveCardEvent extends TaskBoardEvent {
        card?: kendo.data.Model;
    }


interface TaskBoardSaveColumnEvent extends TaskBoardEvent {
        column?: kendo.data.Model;
    }


interface TileLayoutContainerHeader {
        template?: string|Function;
        text?: string;
    }


interface TileLayoutContainer {
        bodyTemplate?: string|Function;
        colSpan?: number;
        header?: TileLayoutContainerHeader;
        rowSpan?: number;
    }


interface TileLayoutGap {
        columns?: number;
        rows?: number;
    }


interface TileLayoutOptions {
        name?: string;
        columns?: number;
        columnsWidth?: string|number;
        containers?: TileLayoutContainer[];
        gap?: TileLayoutGap;
        height?: string|number;
        navigatable?: boolean;
        reorderable?: boolean;
        resizable?: boolean;
        rows?: number;
        rowsHeight?: string|number;
        width?: string|number;
        resize?(e: TileLayoutResizeEvent): void;
        reorder?(e: TileLayoutReorderEvent): void;
    }


interface TileLayoutEvent {
        sender: TileLayout;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TileLayoutResizeEvent extends TileLayoutEvent {
        container?: JQuery;
    }


interface TileLayoutReorderEvent extends TileLayoutEvent {
        newIndex?: number;
        oldIndex?: number;
        container?: JQuery;
    }


interface TextAreaLabel {
        content?: string|Function;
        floating?: boolean;
    }


interface TextAreaOptions {
        name?: string;
        cols?: number;
        enable?: boolean;
        label?: string | Function | TextAreaLabel;
        maxLength?: number;
        placeholder?: string;
        readonly?: boolean;
        resizable?: string;
        rows?: number;
        value?: string;
        change?(e: TextAreaChangeEvent): void;
    }


interface TextAreaEvent {
        sender: TextArea;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TextAreaChangeEvent extends TextAreaEvent {
    }


interface TextBoxLabel {
        content?: string|Function;
        floating?: boolean;
    }


interface TextBoxOptions {
        name?: string;
        enable?: boolean;
        label?: string | Function | TextBoxLabel;
        placeholder?: string;
        readonly?: boolean;
        value?: string;
        change?(e: TextBoxChangeEvent): void;
    }


interface TextBoxEvent {
        sender: TextBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TextBoxChangeEvent extends TextBoxEvent {
    }


interface TimePickerAnimationClose {
        effects?: string;
        duration?: number;
    }


interface TimePickerAnimationOpen {
        effects?: string;
        duration?: number;
    }


interface TimePickerAnimation {
        close?: TimePickerAnimationClose;
        open?: TimePickerAnimationOpen;
    }


interface TimePickerOptions {
        name?: string;
        animation?: boolean | TimePickerAnimation;
        culture?: string;
        dateInput?: boolean;
        dates?: any;
        format?: string;
        interval?: number;
        max?: Date;
        min?: Date;
        parseFormats?: any;
        value?: Date;
        change?(e: TimePickerChangeEvent): void;
        close?(e: TimePickerCloseEvent): void;
        open?(e: TimePickerOpenEvent): void;
    }


interface TimePickerEvent {
        sender: TimePicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TimePickerChangeEvent extends TimePickerEvent {
    }


interface TimePickerCloseEvent extends TimePickerEvent {
    }


interface TimePickerOpenEvent extends TimePickerEvent {
    }


interface TimelineOptions {
        name?: string;
        alternatingMode?: boolean;
        orientation?: string;
        collapsibleEvents?: boolean;
        dataActionsField?: string;
        dataDescriptionField?: string;
        dataDateField?: string;
        dataImagesField?: string;
        dataImagesAltField?: string;
        dataSubTitleField?: string;
        dataTitleField?: string;
        dataSource?: kendo.data.DataSource|any;
        eventTemplate?: string|Function;
        dateformat?: string;
        eventHeight?: number;
        eventWidth?: number;
        navigatable?: boolean;
        showDateLabels?: boolean;
        change?(e: TimelineChangeEvent): void;
        dataBound?(e: TimelineDataBoundEvent): void;
        expand?(e: TimelineExpandEvent): void;
        collapse?(e: TimelineCollapseEvent): void;
        actionClick?(e: TimelineActionClickEvent): void;
        navigate?(e: TimelineNavigateEvent): void;
    }


interface TimelineEvent {
        sender: Timeline;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TimelineChangeEvent extends TimelineEvent {
        dataItem?: kendo.data.Model;
        eventContainer?: JQuery;
    }


interface TimelineDataBoundEvent extends TimelineEvent {
    }


interface TimelineExpandEvent extends TimelineEvent {
        dataItem?: kendo.data.Model;
    }


interface TimelineCollapseEvent extends TimelineEvent {
        dataItem?: kendo.data.Model;
    }


interface TimelineActionClickEvent extends TimelineEvent {
        dataItem?: kendo.data.Model;
        element?: JQuery;
    }


interface TimelineNavigateEvent extends TimelineEvent {
        action?: string;
    }


interface ToolBarItemButton {
        attributes?: any;
        click?: Function;
        enable?: boolean;
        group?: string;
        hidden?: boolean;
        icon?: string;
        id?: string;
        imageUrl?: string;
        selected?: boolean;
        showIcon?: string;
        showText?: string;
        spriteCssClass?: string;
        toggle?: Function;
        togglable?: boolean;
        text?: string;
        url?: string;
    }


interface ToolBarItemMenuButton {
        attributes?: any;
        enable?: boolean;
        hidden?: boolean;
        icon?: string;
        id?: string;
        imageUrl?: string;
        spriteCssClass?: string;
        text?: string;
        url?: string;
    }


interface ToolBarItem {
        attributes?: any;
        buttons?: ToolBarItemButton[];
        click?: Function;
        enable?: boolean;
        group?: string;
        hidden?: boolean;
        icon?: string;
        id?: string;
        imageUrl?: string;
        menuButtons?: ToolBarItemMenuButton[];
        overflow?: string;
        overflowTemplate?: string|Function;
        primary?: boolean;
        selected?: boolean;
        showIcon?: string;
        showText?: string;
        spriteCssClass?: string;
        template?: string|Function;
        text?: string;
        togglable?: boolean;
        toggle?: Function;
        type?: string;
        url?: string;
    }


interface ToolBarOptions {
        name?: string;
        resizable?: boolean;
        items?: ToolBarItem[];
        click?(e: ToolBarClickEvent): void;
        close?(e: ToolBarCloseEvent): void;
        open?(e: ToolBarOpenEvent): void;
        toggle?(e: ToolBarToggleEvent): void;
        overflowClose?(e: ToolBarOverflowCloseEvent): void;
        overflowOpen?(e: ToolBarOverflowOpenEvent): void;
    }


interface ToolBarEvent {
        sender: ToolBar;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ToolBarClickEvent extends ToolBarEvent {
        target?: JQuery;
        id?: string;
    }


interface ToolBarCloseEvent extends ToolBarEvent {
        SplitButton?: JQuery;
    }


interface ToolBarOpenEvent extends ToolBarEvent {
        SplitButton?: JQuery;
    }


interface ToolBarToggleEvent extends ToolBarEvent {
        target?: JQuery;
        checked?: boolean;
        id?: string;
    }


interface ToolBarOverflowCloseEvent extends ToolBarEvent {
    }


interface ToolBarOverflowOpenEvent extends ToolBarEvent {
    }


interface TooltipAnimationClose {
        effects?: string;
        duration?: number;
    }


interface TooltipAnimationOpen {
        effects?: string;
        duration?: number;
    }


interface TooltipAnimation {
        close?: TooltipAnimationClose;
        open?: TooltipAnimationOpen;
    }


interface TooltipContent {
        url?: string;
    }


interface TooltipOptions {
        name?: string;
        autoHide?: boolean;
        animation?: boolean | TooltipAnimation;
        content?: string | Function | TooltipContent;
        callout?: boolean;
        filter?: string;
        iframe?: boolean;
        height?: number;
        width?: number;
        position?: string;
        showAfter?: number;
        showOn?: string;
        contentLoad?(e: TooltipEvent): void;
        show?(e: TooltipEvent): void;
        hide?(e: TooltipEvent): void;
        requestStart?(e: TooltipRequestStartEvent): void;
        error?(e: TooltipErrorEvent): void;
    }


interface TooltipEvent {
        sender: Tooltip;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TooltipRequestStartEvent extends TooltipEvent {
        target?: JQuery;
        options?: any;
    }


interface TooltipErrorEvent extends TooltipEvent {
        xhr?: JQueryXHR;
        status?: string;
    }


interface TouchOptions {
        name?: string;
        filter?: string;
        surface?: JQuery;
        multiTouch?: boolean;
        enableSwipe?: boolean;
        minXDelta?: number;
        maxYDelta?: number;
        maxDuration?: number;
        minHold?: number;
        doubleTapTimeout?: number;
        touchstart?(e: TouchTouchstartEvent): void;
        dragstart?(e: TouchDragstartEvent): void;
        drag?(e: TouchDragEvent): void;
        dragend?(e: TouchDragendEvent): void;
        tap?(e: TouchTapEvent): void;
        doubletap?(e: TouchDoubletapEvent): void;
        hold?(e: TouchHoldEvent): void;
        swipe?(e: TouchSwipeEvent): void;
        gesturestart?(e: TouchGesturestartEvent): void;
        gesturechange?(e: TouchGesturechangeEvent): void;
        gestureend?(e: TouchGestureendEvent): void;
    }


interface TouchEvent {
        sender: Touch;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TouchTouchstartEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchDragstartEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchDragEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchDragendEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchTapEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchDoubletapEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchHoldEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
    }


interface TouchSwipeEvent extends TouchEvent {
        touch?: kendo.mobile.ui.TouchEventOptions;
        event?: JQueryEventObject;
        direction?: string;
    }


interface TouchGesturestartEvent extends TouchEvent {
        touches?: any;
        event?: JQueryEventObject;
        distance?: number;
        center?: kendo.mobile.ui.Point;
    }


interface TouchGesturechangeEvent extends TouchEvent {
        touches?: any;
        event?: JQueryEventObject;
        distance?: number;
        center?: kendo.mobile.ui.Point;
    }


interface TouchGestureendEvent extends TouchEvent {
        touches?: any;
        event?: JQueryEventObject;
        distance?: number;
        center?: kendo.mobile.ui.Point;
    }


interface TreeListColumnMenuMessages {
        columns?: string;
        filter?: string;
        sortAscending?: string;
        sortDescending?: string;
        settings?: string;
        lock?: string;
        unlock?: string;
    }


interface TreeListColumnMenu {
        columns?: boolean;
        filterable?: boolean;
        sortable?: boolean;
        messages?: TreeListColumnMenuMessages;
    }


interface TreeListColumnCommandItem {
        className?: string;
        imageClass?: string;
        click?: Function;
        name?: string;
        text?: string;
    }


interface TreeListColumnFilterable {
        ui?: string|Function;
    }


interface TreeListColumnFilterableCell {
        dataSource?: any|kendo.data.DataSource;
        dataTextField?: string;
        delay?: number;
        inputWidth?: number;
        suggestionOperator?: string;
        minLength?: number;
        enabled?: boolean;
        operator?: string;
        showOperators?: boolean;
        template?: Function;
    }


interface TreeListColumnFilterable {
        cell?: TreeListColumnFilterableCell;
        ui?: string|Function;
    }


interface TreeListColumnSortable {
        compare?: Function;
    }


interface TreeListColumn {
        attributes?: any;
        columns?: any;
        command?: TreeListColumnCommandItem[];
        editable?: Function;
        encoded?: boolean;
        expandable?: boolean;
        field?: string;
        filterable?: boolean | TreeListColumnFilterable;
        footerTemplate?: string|Function;
        format?: string;
        headerAttributes?: any;
        headerTemplate?: string|Function;
        minScreenWidth?: number;
        selectable?: boolean;
        sortable?: boolean | TreeListColumnSortable;
        template?: string|Function;
        title?: string;
        width?: string|number;
        hidden?: boolean;
        includeChildren?: boolean;
        menu?: boolean;
        locked?: boolean;
        lockable?: boolean;
    }


interface TreeListEditable {
        mode?: string;
        move?: boolean;
        template?: string|Function;
        window?: any;
    }


interface TreeListExcel {
        fileName?: string;
        filterable?: boolean;
        forceProxy?: boolean;
        proxyURL?: string;
    }


interface TreeListFilterableMessages {
        and?: string;
        clear?: string;
        filter?: string;
        info?: string;
        title?: string;
        isFalse?: string;
        isTrue?: string;
        or?: string;
    }


interface TreeListFilterableOperatorsDate {
        eq?: string;
        neq?: string;
        isnull?: string;
        isnotnull?: string;
        gte?: string;
        gt?: string;
        lte?: string;
        lt?: string;
    }


interface TreeListFilterableOperatorsNumber {
        eq?: string;
        neq?: string;
        isnull?: string;
        isnotnull?: string;
        gte?: string;
        gt?: string;
        lte?: string;
        lt?: string;
    }


interface TreeListFilterableOperatorsString {
        eq?: string;
        neq?: string;
        isnull?: string;
        isnotnull?: string;
        isempty?: string;
        isnotempty?: string;
        startswith?: string;
        contains?: string;
        doesnotcontain?: string;
        endswith?: string;
    }


interface TreeListFilterableOperators {
        string?: TreeListFilterableOperatorsString;
        number?: TreeListFilterableOperatorsNumber;
        date?: TreeListFilterableOperatorsDate;
    }


interface TreeListFilterable {
        extra?: boolean;
        messages?: TreeListFilterableMessages;
        mode?: string;
        operators?: TreeListFilterableOperators;
    }


interface TreeListMessagesCommands {
        canceledit?: string;
        create?: string;
        createchild?: string;
        destroy?: string;
        edit?: string;
        save?: string;
        cancel?: string;
        excel?: string;
        pdf?: string;
        update?: string;
    }


interface TreeListMessages {
        commands?: TreeListMessagesCommands;
        loading?: string;
        noRows?: string;
        requestFailed?: string;
        retry?: string;
    }


interface TreeListPageableMessages {
        display?: string;
        empty?: string;
        page?: string;
        of?: string;
        itemsPerPage?: string;
        first?: string;
        last?: string;
        next?: string;
        previous?: string;
        refresh?: string;
        morePages?: string;
    }


interface TreeListPageable {
        alwaysVisible?: boolean;
        pageSize?: number;
        previousNext?: boolean;
        numeric?: boolean;
        buttonCount?: number;
        input?: boolean;
        pageSizes?: boolean|any;
        refresh?: boolean;
        responsive?: boolean;
        info?: boolean;
        messages?: TreeListPageableMessages;
    }


interface TreeListPdfMargin {
        bottom?: number|string;
        left?: number|string;
        right?: number|string;
        top?: number|string;
    }


interface TreeListPdf {
        author?: string;
        avoidLinks?: boolean|string;
        creator?: string;
        date?: Date;
        fileName?: string;
        forceProxy?: boolean;
        keywords?: string;
        landscape?: boolean;
        margin?: TreeListPdfMargin;
        paperSize?: string|any;
        proxyURL?: string;
        proxyTarget?: string;
        subject?: string;
        title?: string;
    }


interface TreeListSearch {
        fields?: any;
    }


interface TreeListSortable {
        allowUnsort?: boolean;
        mode?: string;
    }


interface TreeListToolbarItem {
        click?: Function;
        imageClass?: string;
        name?: string;
        text?: string;
    }


interface TreeListOptions {
        name?: string;
        altRowTemplate?: string|Function;
        autoBind?: boolean;
        columns?: TreeListColumn[];
        resizable?: boolean;
        reorderable?: boolean;
        columnMenu?: boolean | TreeListColumnMenu;
        dataSource?: any|any|kendo.data.TreeListDataSource;
        editable?: boolean | TreeListEditable;
        excel?: TreeListExcel;
        filterable?: boolean | TreeListFilterable;
        height?: number|string;
        messages?: TreeListMessages;
        navigatable?: boolean;
        pageable?: boolean | TreeListPageable;
        pdf?: TreeListPdf;
        rowTemplate?: string|Function;
        scrollable?: boolean|any;
        search?: TreeListSearch;
        selectable?: boolean|string;
        sortable?: boolean | TreeListSortable;
        toolbar?: TreeListToolbarItem[] | any;
        beforeEdit?(e: TreeListBeforeEditEvent): void;
        cancel?(e: TreeListCancelEvent): void;
        cellClose?(e: TreeListCellCloseEvent): void;
        change?(e: TreeListChangeEvent): void;
        collapse?(e: TreeListCollapseEvent): void;
        dataBinding?(e: TreeListDataBindingEvent): void;
        dataBound?(e: TreeListDataBoundEvent): void;
        dragstart?(e: TreeListDragstartEvent): void;
        drag?(e: TreeListDragEvent): void;
        dragend?(e: TreeListDragendEvent): void;
        drop?(e: TreeListDropEvent): void;
        edit?(e: TreeListEditEvent): void;
        excelExport?(e: TreeListExcelExportEvent): void;
        expand?(e: TreeListExpandEvent): void;
        filterMenuInit?(e: TreeListFilterMenuInitEvent): void;
        filterMenuOpen?(e: TreeListFilterMenuOpenEvent): void;
        pdfExport?(e: TreeListPdfExportEvent): void;
        remove?(e: TreeListRemoveEvent): void;
        save?(e: TreeListSaveEvent): void;
        saveChanges?(e: TreeListSaveChangesEvent): void;
        columnShow?(e: TreeListColumnShowEvent): void;
        columnHide?(e: TreeListColumnHideEvent): void;
        columnReorder?(e: TreeListColumnReorderEvent): void;
        columnResize?(e: TreeListColumnResizeEvent): void;
        columnMenuInit?(e: TreeListColumnMenuInitEvent): void;
        columnMenuOpen?(e: TreeListColumnMenuOpenEvent): void;
        columnLock?(e: TreeListColumnLockEvent): void;
        columnUnlock?(e: TreeListColumnUnlockEvent): void;
    }


interface TreeListEvent {
        sender: TreeList;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TreeListBeforeEditEvent extends TreeListEvent {
        model?: kendo.data.Model;
    }


interface TreeListCancelEvent extends TreeListEvent {
        container?: JQuery;
        model?: kendo.data.TreeListModel;
    }


interface TreeListCellCloseEvent extends TreeListEvent {
        container?: JQuery;
        model?: kendo.data.Model;
        type?: string;
    }


interface TreeListChangeEvent extends TreeListEvent {
    }


interface TreeListCollapseEvent extends TreeListEvent {
        model?: kendo.data.TreeListModel;
    }


interface TreeListDataBindingEvent extends TreeListEvent {
    }


interface TreeListDataBoundEvent extends TreeListEvent {
    }


interface TreeListDragstartEvent extends TreeListEvent {
        source?: kendo.data.TreeListModel;
    }


interface TreeListDragEvent extends TreeListEvent {
        source?: kendo.data.TreeListModel;
        target?: JQuery;
    }


interface TreeListDragendEvent extends TreeListEvent {
        source?: kendo.data.TreeListModel;
        destination?: kendo.data.TreeListModel;
    }


interface TreeListDropEvent extends TreeListEvent {
        source?: kendo.data.TreeListModel;
        destination?: kendo.data.TreeListModel;
        dropTarget?: Element;
        valid?: boolean;
        setValid?: boolean;
    }


interface TreeListEditEvent extends TreeListEvent {
        container?: JQuery;
        model?: kendo.data.TreeListModel;
    }


interface TreeListExcelExportEvent extends TreeListEvent {
        data?: any;
        workbook?: any;
    }


interface TreeListExpandEvent extends TreeListEvent {
        model?: kendo.data.TreeListModel;
    }


interface TreeListFilterMenuInitEvent extends TreeListEvent {
        container?: JQuery;
        field?: string;
    }


interface TreeListFilterMenuOpenEvent extends TreeListEvent {
        container?: JQuery;
        field?: string;
    }


interface TreeListPdfExportEvent extends TreeListEvent {
        promise?: JQueryPromise<any>;
    }


interface TreeListRemoveEvent extends TreeListEvent {
        model?: kendo.data.TreeListModel;
        row?: JQuery;
    }


interface TreeListSaveEvent extends TreeListEvent {
        model?: kendo.data.TreeListModel;
        container?: JQuery;
    }


interface TreeListSaveChangesEvent extends TreeListEvent {
    }


interface TreeListColumnShowEvent extends TreeListEvent {
        column?: any;
    }


interface TreeListColumnHideEvent extends TreeListEvent {
        column?: any;
    }


interface TreeListColumnReorderEvent extends TreeListEvent {
        column?: any;
        newIndex?: number;
        oldIndex?: number;
    }


interface TreeListColumnResizeEvent extends TreeListEvent {
        column?: any;
        newWidth?: number;
        oldWidth?: number;
    }


interface TreeListColumnMenuInitEvent extends TreeListEvent {
        container?: JQuery;
        field?: string;
    }


interface TreeListColumnMenuOpenEvent extends TreeListEvent {
        container?: JQuery;
        field?: string;
    }


interface TreeListColumnLockEvent extends TreeListEvent {
        column?: any;
    }


interface TreeListColumnUnlockEvent extends TreeListEvent {
        column?: any;
    }


interface TreeViewAnimationCollapse {
        duration?: number;
        effects?: string;
    }


interface TreeViewAnimationExpand {
        duration?: number;
        effects?: string;
    }


interface TreeViewAnimation {
        collapse?: boolean | TreeViewAnimationCollapse;
        expand?: boolean | TreeViewAnimationExpand;
    }


interface TreeViewCheckboxes {
        checkChildren?: boolean;
        name?: string;
        template?: string|Function;
    }


interface TreeViewMessages {
        loading?: string;
        requestFailed?: string;
        retry?: string;
    }


interface TreeViewOptions {
        name?: string;
        animation?: boolean | TreeViewAnimation;
        autoBind?: boolean;
        autoScroll?: boolean;
        checkboxes?: boolean | TreeViewCheckboxes;
        dataImageUrlField?: string;
        dataSource?: any|any|kendo.data.HierarchicalDataSource;
        dataSpriteCssClassField?: string;
        dataTextField?: string|any;
        dataUrlField?: string;
        dragAndDrop?: boolean;
        loadOnDemand?: boolean;
        messages?: TreeViewMessages;
        template?: string|Function;
        change?(e: TreeViewEvent): void;
        check?(e: TreeViewCheckEvent): void;
        collapse?(e: TreeViewCollapseEvent): void;
        dataBound?(e: TreeViewDataBoundEvent): void;
        drag?(e: TreeViewDragEvent): void;
        dragend?(e: TreeViewDragendEvent): void;
        dragstart?(e: TreeViewDragstartEvent): void;
        drop?(e: TreeViewDropEvent): void;
        expand?(e: TreeViewExpandEvent): void;
        navigate?(e: TreeViewNavigateEvent): void;
        select?(e: TreeViewSelectEvent): void;
    }


interface TreeViewEvent {
        sender: TreeView;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TreeViewCheckEvent extends TreeViewEvent {
        node?: Element;
    }


interface TreeViewCollapseEvent extends TreeViewEvent {
        node?: Element;
    }


interface TreeViewDataBoundEvent extends TreeViewEvent {
        node?: JQuery;
    }


interface TreeViewDragEvent extends TreeViewEvent {
        sourceNode?: Element;
        dropTarget?: Element;
        pageX?: number;
        pageY?: number;
        statusClass?: string;
        setStatusClass?: Function;
    }


interface TreeViewDragendEvent extends TreeViewEvent {
        sourceNode?: Element;
        destinationNode?: Element;
        dropPosition?: string;
    }


interface TreeViewDragstartEvent extends TreeViewEvent {
        sourceNode?: Element;
    }


interface TreeViewDropEvent extends TreeViewEvent {
        sourceNode?: Element;
        destinationNode?: Element;
        valid?: boolean;
        setValid?: Function;
        dropTarget?: Element;
        dropPosition?: string;
    }


interface TreeViewExpandEvent extends TreeViewEvent {
        node?: Element;
    }


interface TreeViewNavigateEvent extends TreeViewEvent {
        node?: Element;
    }


interface TreeViewSelectEvent extends TreeViewEvent {
        node?: Element;
    }


interface UploadAsync {
        autoUpload?: boolean;
        batch?: boolean;
        chunkSize?: number;
        concurrent?: boolean;
        autoRetryAfter?: number;
        maxAutoRetries?: number;
        removeField?: string;
        removeUrl?: string;
        removeVerb?: string;
        saveField?: string;
        saveUrl?: string;
        useArrayBuffer?: boolean;
        withCredentials?: boolean;
    }


interface UploadFile {
        extension?: string;
        name?: string;
        size?: number;
    }


interface UploadLocalization {
        cancel?: string;
        clearSelectedFiles?: string;
        dropFilesHere?: string;
        headerStatusUploaded?: string;
        headerStatusUploading?: string;
        invalidFileExtension?: string;
        uploadSuccess?: string;
        uploadFail?: string;
        invalidFiles?: string;
        invalidMaxFileSize?: string;
        invalidMinFileSize?: string;
        remove?: string;
        retry?: string;
        select?: string;
        statusFailed?: string;
        statusUploaded?: string;
        statusUploading?: string;
        uploadSelectedFiles?: string;
    }


interface UploadValidation {
        allowedExtensions?: any;
        maxFileSize?: number;
        minFileSize?: number;
    }


interface UploadOptions {
        name?: string;
        async?: UploadAsync;
        directory?: boolean;
        directoryDrop?: boolean;
        dropZone?: string;
        enabled?: boolean;
        files?: UploadFile[];
        localization?: UploadLocalization;
        multiple?: boolean;
        showFileList?: boolean;
        template?: string|Function;
        validation?: UploadValidation;
        cancel?(e: UploadCancelEvent): void;
        clear?(e: UploadClearEvent): void;
        complete?(e: UploadEvent): void;
        error?(e: UploadErrorEvent): void;
        pause?(e: UploadPauseEvent): void;
        progress?(e: UploadProgressEvent): void;
        resume?(e: UploadEvent): void;
        remove?(e: UploadRemoveEvent): void;
        select?(e: UploadSelectEvent): void;
        success?(e: UploadSuccessEvent): void;
        upload?(e: UploadUploadEvent): void;
    }


interface UploadEvent {
        sender: Upload;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface UploadCancelEvent extends UploadEvent {
        files?: any[];
    }


interface UploadClearEvent extends UploadEvent {
        e?: any;
    }


interface UploadErrorEvent extends UploadEvent {
        files?: any[];
        operation?: string;
        XMLHttpRequest?: any;
    }


interface UploadPauseEvent extends UploadEvent {
        e?: any;
    }


interface UploadProgressEvent extends UploadEvent {
        files?: any[];
        percentComplete?: number;
    }


interface UploadRemoveEvent extends UploadEvent {
        files?: any[];
        headers?: any;
        data?: any;
    }


interface UploadSelectEvent extends UploadEvent {
        e?: any;
        files?: any[];
    }


interface UploadSuccessEvent extends UploadEvent {
        files?: any[];
        operation?: string;
        response?: any;
        XMLHttpRequest?: any;
    }


interface UploadUploadEvent extends UploadEvent {
        files?: any[];
        data?: any;
        formData?: any;
        XMLHttpRequest?: any;
    }


interface ValidatorOptions {
        name?: string;
        errorTemplate?: string;
        messages?: any;
        rules?: any;
        validateOnBlur?: boolean;
        validationSummary?: boolean | ValidationSummary;
        validate?(e: ValidatorValidateEvent): void;
        validateInput?(e: ValidatorValidateInputEvent): void;
    }


interface ValidationSummary {
        container?: string | JQuery;
        template?: string | Function;
    }


interface ValidatorEvent {
        sender: Validator;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ValidatorValidateEvent extends ValidatorEvent {
        valid?: boolean;
        errors?: any[];
    }


interface ValidatorValidateInputEvent extends ValidatorEvent {
        input?: JQuery;
        valid?: boolean;
        error?: string;
        field?: string;
    }


interface WindowAnimationClose {
        effects?: string;
        duration?: number;
        reverse?: boolean;
    }


interface WindowAnimationOpen {
        effects?: string;
        duration?: number;
    }


interface WindowAnimation {
        close?: WindowAnimationClose;
        open?: WindowAnimationOpen;
    }


interface WindowContent {
        url?: string;
        dataType?: string;
        iframe?: boolean;
        template?: string;
    }


interface WindowPosition {
        top?: number|string;
        left?: number|string;
    }


interface WindowModal {
        preventScroll?: boolean;
    }


interface WindowRefreshOptions {
        url?: string;
        cache?: boolean;
        data?: any;
        type?: string;
        template?: string;
        iframe?: boolean;
    }


interface WindowDraggable {
        containment?: any|string;
        dragHandle?: any|string;
        axis?: string;
    }


interface WindowOptions {
        name?: string;
        actions?: any;
        animation?: boolean | WindowAnimation;
        appendTo?: any|string;
        autoFocus?: boolean;
        content?: string | WindowContent;
        draggable?: boolean | WindowDraggable;
        iframe?: boolean;
        height?: number|string;
        maxHeight?: number;
        maxWidth?: number;
        minHeight?: number;
        minWidth?: number;
        modal?: boolean | WindowModal;
        pinned?: boolean;
        position?: WindowPosition;
        resizable?: boolean;
        scrollable?: boolean;
        title?: string|boolean;
        visible?: boolean;
        width?: number|string;
        size?: string;
        activate?(e: WindowEvent): void;
        close?(e: WindowCloseEvent): void;
        deactivate?(e: WindowEvent): void;
        dragend?(e: WindowEvent): void;
        dragstart?(e: WindowEvent): void;
        error?(e: WindowErrorEvent): void;
        maximize?(e: WindowEvent): void;
        minimize?(e: WindowEvent): void;
        open?(e: WindowEvent): void;
        refresh?(e: WindowEvent): void;
        resize?(e: WindowEvent): void;
    }


interface WindowEvent {
        sender: Window;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface WindowCloseEvent extends WindowEvent {
        userTriggered?: boolean;
    }


interface WindowErrorEvent extends WindowEvent {
        xhr?: JQueryXHR;
        status?: string;
    }


interface WizardMessages {
        done?: string;
        next?: string;
        of?: string;
        previous?: string;
        reset?: string;
        step?: string;
    }


interface WizardStepper {
        indicator?: boolean;
        label?: boolean;
        linear?: boolean;
    }


interface WizardStepButton {
        click?: Function;
        enabled?: boolean;
        name?: string;
        primary?: string;
        text?: string;
    }


interface WizardStep {
        buttons?: WizardStepButton[];
        content?: string;
        contentId?: string;
        contentUrl?: string;
        className?: string;
        enabled?: boolean;
        form?: any;
        pager?: boolean;
        title?: string;
    }


interface WizardOptions {
        name?: string;
        actionBar?: boolean;
        contentPosition?: string;
        loadOnDemand?: boolean;
        messages?: WizardMessages;
        pager?: boolean;
        reloadOnSelect?: boolean;
        stepper?: WizardStepper;
        validateForms?: boolean;
        steps?: WizardStep[];
        activate?(e: WizardActivateEvent): void;
        contentLoad?(e: WizardContentLoadEvent): void;
        done?(e: WizardDoneEvent): void;
        error?(e: WizardErrorEvent): void;
        reset?(e: WizardResetEvent): void;
        select?(e: WizardSelectEvent): void;
        formValidateFailed?(e: WizardFormValidateFailedEvent): void;
    }


interface WizardEvent {
        sender: Wizard;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface WizardActivateEvent extends WizardEvent {
        step?: kendo.wizard.Step;
    }


interface WizardContentLoadEvent extends WizardEvent {
        step?: kendo.wizard.Step;
    }


interface WizardDoneEvent extends WizardEvent {
        originalEvent?: any;
        button?: kendo.ui.Button;
        forms?: any;
    }


interface WizardErrorEvent extends WizardEvent {
        xhr?: JQueryXHR;
        status?: string;
        step?: kendo.wizard.Step;
    }


interface WizardResetEvent extends WizardEvent {
        originalEvent?: any;
        button?: kendo.ui.Button;
    }


interface WizardSelectEvent extends WizardEvent {
        originalEvent?: any;
        step?: kendo.wizard.Step;
        button?: kendo.ui.Button;
        stepper?: kendo.ui.Stepper;
    }


interface WizardFormValidateFailedEvent extends WizardEvent {
        form?: kendo.ui.Form;
        step?: kendo.wizard.Step;
    }


interface ArcOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface ArcEvent {
        sender: Arc;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface CircleOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface CircleEvent {
        sender: Circle;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ElementOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        opacity?: number;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface ElementEvent {
        sender: Element;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FillOptions  {

        color?: string;
        opacity?: number;

    }


interface GradientOptions {
        name?: string;
        stops?: any;
    }


interface GradientEvent {
        sender: Gradient;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface GradientStopOptions {
        name?: string;
        offset?: number;
        color?: string;
        opacity?: number;
    }


interface GradientStopEvent {
        sender: GradientStop;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface GroupOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        opacity?: number;
        pdf?: kendo.drawing.PDFOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface GroupEvent {
        sender: Group;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ImageOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        opacity?: number;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface ImageEvent {
        sender: Image;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface LayoutOptions {
        name?: string;
        alignContent?: string;
        alignItems?: string;
        justifyContent?: string;
        lineSpacing?: number;
        spacing?: number;
        orientation?: string;
        wrap?: boolean;
    }


interface LayoutEvent {
        sender: Layout;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface LinearGradientOptions {
        name?: string;
        stops?: any;
    }


interface LinearGradientEvent {
        sender: LinearGradient;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MultiPathOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface MultiPathEvent {
        sender: MultiPath;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface OptionsStoreOptions {
        name?: string;
    }


interface OptionsStoreEvent {
        sender: OptionsStore;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PDFOptions  {
        creator?: string;
        date?: Date;
        imgDPI?: number;
        keywords?: string;
        landscape?: boolean;
        margin?: any;
        multiPage?: boolean;
        paperSize?: any;
        jpegQuality?: number;
        keepPNG?: boolean;
        subject?: string;
        title?: string;
    }


interface PathOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface PathEvent {
        sender: Path;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RadialGradientOptions {
        name?: string;
        center?: any|kendo.geometry.Point;
        radius?: number;
        stops?: any;
    }


interface RadialGradientEvent {
        sender: RadialGradient;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RectOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface RectEvent {
        sender: Rect;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SegmentOptions {
        name?: string;
    }


interface SegmentEvent {
        sender: Segment;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface StrokeOptions  {

        color?: string;
        dashType?: string;
        lineCap?: string;
        lineJoin?: string;
        opacity?: number;
        width?: number;

    }


interface SurfaceTooltipAnimationClose {
        effects?: string;
        duration?: number;
    }


interface SurfaceTooltipAnimationOpen {
        effects?: string;
        duration?: number;
    }


interface SurfaceTooltipAnimation {
        close?: SurfaceTooltipAnimationClose;
        open?: SurfaceTooltipAnimationOpen;
    }


interface SurfaceTooltip {
        animation?: boolean | SurfaceTooltipAnimation;
        appendTo?: string|JQuery;
    }


interface SurfaceOptions {
        name?: string;
        type?: string;
        height?: string;
        width?: string;
        tooltip?: SurfaceTooltip;
        click?(e: SurfaceClickEvent): void;
        mouseenter?(e: SurfaceMouseenterEvent): void;
        mouseleave?(e: SurfaceMouseleaveEvent): void;
        tooltipClose?(e: SurfaceTooltipCloseEvent): void;
        tooltipOpen?(e: SurfaceTooltipOpenEvent): void;
    }


interface SurfaceEvent {
        sender: Surface;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SurfaceClickEvent extends SurfaceEvent {
        element?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface SurfaceMouseenterEvent extends SurfaceEvent {
        element?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface SurfaceMouseleaveEvent extends SurfaceEvent {
        element?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface SurfaceTooltipCloseEvent extends SurfaceEvent {
        element?: kendo.drawing.Element;
        target?: kendo.drawing.Element;
    }


interface SurfaceTooltipOpenEvent extends SurfaceEvent {
        element?: kendo.drawing.Element;
        target?: kendo.drawing.Element;
    }


interface TextOptions {
        name?: string;
        clip?: kendo.drawing.Path;
        cursor?: string;
        fill?: kendo.drawing.FillOptions;
        font?: string;
        opacity?: number;
        stroke?: kendo.drawing.StrokeOptions;
        tooltip?: kendo.drawing.TooltipOptions;
        transform?: kendo.geometry.Transformation;
        visible?: boolean;
    }


interface TextEvent {
        sender: Text;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TooltipOptions  {

        autoHide?: boolean;
        content?: string|Function;
        position?: string;
        height?: number|string;
        hideDelay?: number;
        offset?: number;
        shared?: boolean;
        showAfter?: number;
        showOn?: string;
        width?: number|string;

    }


interface ArcOptions {
        name?: string;
    }


interface CircleOptions {
        name?: string;
    }


interface MatrixOptions {
        name?: string;
    }


interface MatrixEvent {
        sender: Matrix;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PointOptions {
        name?: string;
    }


interface PointEvent {
        sender: Point;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface RectOptions {
        name?: string;
    }


interface SizeOptions {
        name?: string;
    }


interface SizeEvent {
        sender: Size;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface TransformationOptions {
        name?: string;
    }


interface TransformationEvent {
        sender: Transformation;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ArcGaugeColor {
        color?: string;
        from?: number;
        to?: number;
    }


interface ArcGaugeGaugeAreaBorder {
        color?: string;
        dashType?: string;
        opacity?: number;
        width?: number;
    }


interface ArcGaugeGaugeAreaMargin {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    }


interface ArcGaugeGaugeArea {
        background?: string;
        border?: ArcGaugeGaugeAreaBorder;
        height?: number;
        margin?: number | ArcGaugeGaugeAreaMargin;
        width?: number;
    }


interface ArcGaugeScaleLabelsBorder {
        color?: string;
        dashType?: string;
        opacity?: number;
        width?: number;
    }


interface ArcGaugeScaleLabelsMargin {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    }


interface ArcGaugeScaleLabelsPadding {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    }


interface ArcGaugeScaleLabels {
        background?: string;
        border?: ArcGaugeScaleLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | ArcGaugeScaleLabelsMargin;
        padding?: number | ArcGaugeScaleLabelsPadding;
        position?: string;
        template?: string|Function;
        visible?: boolean;
    }


interface ArcGaugeScaleMajorTicks {
        color?: string;
        size?: number;
        visible?: boolean;
        width?: number;
    }


interface ArcGaugeScaleMinorTicks {
        color?: string;
        size?: number;
        visible?: boolean;
        width?: number;
    }


interface ArcGaugeScale {
        endAngle?: number;
        labels?: ArcGaugeScaleLabels;
        majorTicks?: ArcGaugeScaleMajorTicks;
        majorUnit?: number;
        max?: number;
        min?: number;
        minorTicks?: ArcGaugeScaleMinorTicks;
        minorUnit?: number;
        rangeLineCap?: string;
        rangePlaceholderColor?: string;
        rangeSize?: number;
        rangeDistance?: number;
        reverse?: boolean;
        startAngle?: number;
    }


interface ArcGaugeExportImageOptions {
        width?: string;
        height?: string;
    }


interface ArcGaugeExportSVGOptions {
        raw?: boolean;
    }


interface ArcGaugeOptions {
        name?: string;
        centerTemplate?: string|Function;
        color?: string;
        colors?: ArcGaugeColor[];
        gaugeArea?: ArcGaugeGaugeArea;
        opacity?: number;
        renderAs?: string;
        scale?: ArcGaugeScale;
        theme?: string;
        transitions?: boolean;
        value?: number;
    }


interface ArcGaugeEvent {
        sender: ArcGauge;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface BarcodeBorder {
        color?: string;
        dashType?: string;
        width?: number;
    }


interface BarcodePadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface BarcodeTextMargin {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface BarcodeText {
        color?: string;
        font?: string;
        margin?: BarcodeTextMargin;
        visible?: boolean;
    }


interface BarcodeExportImageOptions {
        width?: string;
        height?: string;
    }


interface BarcodeExportSVGOptions {
        raw?: boolean;
    }


interface BarcodeOptions {
        name?: string;
        renderAs?: string;
        background?: string;
        border?: BarcodeBorder;
        checksum?: boolean;
        color?: string;
        height?: number;
        padding?: BarcodePadding;
        text?: BarcodeText;
        type?: string;
        value?: string;
        width?: number;
    }


interface BarcodeEvent {
        sender: Barcode;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ChartAxisDefaultsCrosshairTooltipBorder {
        color?: string;
        dashType?: string;
        width?: number;
    }


interface ChartAxisDefaultsCrosshairTooltipPadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartAxisDefaultsCrosshairTooltip {
        background?: string;
        border?: ChartAxisDefaultsCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartAxisDefaultsCrosshairTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartAxisDefaultsCrosshair {
        color?: string;
        dashType?: string;
        opacity?: number;
        tooltip?: ChartAxisDefaultsCrosshairTooltip;
        visible?: boolean;
        width?: number;
    }


interface ChartAxisDefaultsLabelsMargin {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartAxisDefaultsLabelsPadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartAxisDefaultsLabelsRotation {
        align?: string;
        angle?: number|string;
    }


interface ChartAxisDefaultsLabels {
        font?: string;
        format?: string;
        margin?: number | ChartAxisDefaultsLabelsMargin;
        mirror?: boolean;
        padding?: number | ChartAxisDefaultsLabelsPadding;
        rotation?: string | number | ChartAxisDefaultsLabelsRotation;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        visual?: Function;
    }


interface ChartAxisDefaultsLine {
        color?: string;
        dashType?: string;
        visible?: boolean;
        width?: number;
    }


interface ChartAxisDefaultsMajorGridLines {
        color?: string;
        dashType?: string;
        visible?: boolean;
        width?: number;
        step?: number;
        skip?: number;
    }


interface ChartAxisDefaultsMajorTicks {
        color?: string;
        size?: number;
        visible?: boolean;
        width?: number;
        step?: number;
        skip?: number;
    }


interface ChartAxisDefaultsMinorGridLines {
        color?: string;
        dashType?: string;
        visible?: boolean;
        width?: number;
        step?: number;
        skip?: number;
    }


interface ChartAxisDefaultsMinorTicks {
        color?: string;
        size?: number;
        visible?: boolean;
        width?: number;
        step?: number;
        skip?: number;
    }


interface ChartAxisDefaultsPlotBand {
        color?: string;
        from?: number;
        opacity?: number;
        to?: number;
    }


interface ChartAxisDefaultsTitleBorder {
        color?: string;
        dashType?: string;
        width?: number;
    }


interface ChartAxisDefaultsTitleMargin {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartAxisDefaultsTitlePadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartAxisDefaultsTitle {
        background?: string;
        border?: ChartAxisDefaultsTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartAxisDefaultsTitleMargin;
        padding?: number | ChartAxisDefaultsTitlePadding;
        position?: string;
        rotation?: number;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartAxisDefaults {
        background?: string;
        color?: string;
        crosshair?: ChartAxisDefaultsCrosshair;
        labels?: ChartAxisDefaultsLabels;
        line?: ChartAxisDefaultsLine;
        majorGridLines?: ChartAxisDefaultsMajorGridLines;
        majorTicks?: ChartAxisDefaultsMajorTicks;
        minorGridLines?: ChartAxisDefaultsMinorGridLines;
        minorTicks?: ChartAxisDefaultsMinorTicks;
        narrowRange?: boolean;
        pane?: string;
        plotBands?: ChartAxisDefaultsPlotBand[];
        reverse?: boolean;
        startAngle?: number;
        title?: ChartAxisDefaultsTitle;
        visible?: boolean;
    }


interface ChartCategoryAxisItemAutoBaseUnitSteps {
        milliseconds?: any;
        seconds?: any;
        minutes?: any;
        hours?: any;
        days?: any;
        weeks?: any;
        months?: any;
        years?: any;
    }


interface ChartCategoryAxisItemCrosshairTooltipBorder {
        color?: string;
        dashType?: string;
        width?: number;
    }


interface ChartCategoryAxisItemCrosshairTooltipPadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartCategoryAxisItemCrosshairTooltip {
        background?: string;
        border?: ChartCategoryAxisItemCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartCategoryAxisItemCrosshairTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartCategoryAxisItemCrosshair {
        color?: string;
        dashType?: string;
        opacity?: number;
        tooltip?: ChartCategoryAxisItemCrosshairTooltip;
        visible?: boolean;
        width?: number;
    }


interface ChartCategoryAxisItemLabelsBorder {
        color?: string;
        dashType?: string;
        width?: number;
    }


interface ChartCategoryAxisItemLabelsDateFormats {
        days?: string;
        hours?: string;
        months?: string;
        weeks?: string;
        years?: string;
    }


interface ChartCategoryAxisItemLabelsMargin {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartCategoryAxisItemLabelsPadding {
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }


interface ChartCategoryAxisItemLabelsRotation {
        align?: string;
        angle?: number|string;
    }