interface ChatOptions {
        name?: string;
        messages?: ChatMessages;
        user?: ChatUser;
        actionClick?(e: ChatActionClickEvent): void;
        post?(e: ChatPostEvent): void;
        sendMessage?(e: ChatSendMessageEvent): void;
        typingEnd?(e: ChatTypingEndEvent): void;
        typingStart?(e: ChatTypingStartEvent): void;
    }


interface ChatEvent {
        sender: Chat;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ChatActionClickEvent extends ChatEvent {
        text?: string;
    }


interface ChatPostEvent extends ChatEvent {
        text?: string;
        timestamp?: Date;
        from?: any;
    }


interface ChatSendMessageEvent extends ChatEvent {
        text?: string;
    }


interface ChatTypingEndEvent extends ChatEvent {
    }


interface ChatTypingStartEvent extends ChatEvent {
    }


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


interface CheckBoxGroupOptions {
        name?: string;
        enabled?: boolean;
        inputName?: string;
        items?: CheckBoxGroupItem[];
        labelPosition?: string;
        layout?: string;
        value?: any;
        change?(e: CheckBoxGroupChangeEvent): void;
        focus?(e: CheckBoxGroupFocusEvent): void;
        select?(e: CheckBoxGroupSelectEvent): void;
    }


interface CheckBoxGroupEvent {
        sender: CheckBoxGroup;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface CheckBoxGroupChangeEvent extends CheckBoxGroupEvent {
        target?: JQuery;
    }


interface CheckBoxGroupFocusEvent extends CheckBoxGroupEvent {
        target?: JQuery;
    }


interface CheckBoxGroupSelectEvent extends CheckBoxGroupEvent {
        target?: JQuery;
    }


interface ColorPaletteTileSize {
        width?: number;
        height?: number;
    }


interface ColorPaletteOptions {
        name?: string;
        palette?: string|any;
        columns?: number;
        tileSize?: ColorPaletteTileSize;
        value?: string;
        change?(e: ColorPaletteEvent): void;
    }


interface ColorPaletteEvent {
        sender: ColorPalette;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ColorPickerMessages {
        apply?: string;
        cancel?: string;
        previewInput?: string;
    }


interface ColorPickerTileSize {
        width?: number;
        height?: number;
    }


interface ColorPickerOptions {
        name?: string;
        buttons?: boolean;
        clearButton?: boolean;
        columns?: number;
        tileSize?: ColorPickerTileSize;
        messages?: ColorPickerMessages;
        palette?: string|any;
        opacity?: boolean;
        preview?: boolean;
        toolIcon?: string;
        value?: string;
        change?(e: ColorPickerChangeEvent): void;
        select?(e: ColorPickerSelectEvent): void;
        open?(e: ColorPickerEvent): void;
        close?(e: ColorPickerEvent): void;
    }


interface ColorPickerEvent {
        sender: ColorPicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ColorPickerChangeEvent extends ColorPickerEvent {
        value?: string;
    }


interface ColorPickerSelectEvent extends ColorPickerEvent {
        value?: string;
    }


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


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


interface ComboBoxAnimation {
        close?: ComboBoxAnimationClose;
        open?: ComboBoxAnimationOpen;
    }


interface ComboBoxPopup {
        appendTo?: string;
        origin?: string;
        position?: string;
    }


interface ComboBoxVirtual {
        itemHeight?: number;
        mapValueTo?: string;
        valueMapper?: Function;
    }


interface ComboBoxOptions {
        name?: string;
        animation?: ComboBoxAnimation;
        autoBind?: boolean;
        autoWidth?: boolean;
        cascadeFrom?: string;
        cascadeFromField?: string;
        clearButton?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        delay?: number;
        enable?: boolean;
        enforceMinLength?: boolean;
        filter?: string;
        fixedGroupTemplate?: string|Function;
        footerTemplate?: string|Function;
        groupTemplate?: string|Function;
        height?: number;
        highlightFirst?: boolean;
        ignoreCase?: boolean;
        index?: number;
        minLength?: number;
        noDataTemplate?: string|Function|boolean;
        placeholder?: string;
        popup?: ComboBoxPopup;
        suggest?: boolean;
        syncValueAndText?: boolean;
        headerTemplate?: string|Function;
        template?: string|Function;
        text?: string;
        value?: string;
        valuePrimitive?: boolean;
        virtual?: boolean | ComboBoxVirtual;
        change?(e: ComboBoxChangeEvent): void;
        close?(e: ComboBoxCloseEvent): void;
        dataBound?(e: ComboBoxDataBoundEvent): void;
        filtering?(e: ComboBoxFilteringEvent): void;
        open?(e: ComboBoxOpenEvent): void;
        select?(e: ComboBoxSelectEvent): void;
        cascade?(e: ComboBoxCascadeEvent): void;
    }


interface ComboBoxEvent {
        sender: ComboBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ComboBoxChangeEvent extends ComboBoxEvent {
    }


interface ComboBoxCloseEvent extends ComboBoxEvent {
    }


interface ComboBoxDataBoundEvent extends ComboBoxEvent {
    }


interface ComboBoxFilteringEvent extends ComboBoxEvent {
        filter?: any;
    }


interface ComboBoxOpenEvent extends ComboBoxEvent {
    }


interface ComboBoxSelectEvent extends ComboBoxEvent {
        dataItem?: any;
        item?: JQuery;
    }


interface ComboBoxCascadeEvent extends ComboBoxEvent {
    }


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


interface ConfirmOptions {
        name?: string;
        content?: string;
        messages?: ConfirmMessages;
        title?: string | boolean;
        initOpen?(e: DialogEvent): void;
        open?(e: DialogEvent): void;
    }


interface ConfirmEvent {
        sender: Confirm;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


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


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


interface ContextMenuAnimation {
        close?: ContextMenuAnimationClose;
        open?: ContextMenuAnimationOpen;
    }


interface ContextMenuScrollable {
        distance?: number;
    }


interface ContextMenuOptions {
        name?: string;
        alignToAnchor?: boolean;
        animation?: boolean | ContextMenuAnimation;
        appendTo?: string|JQuery;
        closeOnClick?: boolean;
        copyAnchorStyles?: boolean;
        dataSource?: any|any|kendo.data.HierarchicalDataSource;
        dataTextField?: string;
        dataUrlField?: string;
        dataSpriteCssClassField?: string;
        dataImageUrlField?: string;
        dataContentField?: string;
        direction?: string;
        filter?: string;
        hoverDelay?: number;
        orientation?: string;
        popupCollision?: string;
        scrollable?: boolean | ContextMenuScrollable;
        showOn?: string;
        target?: string|JQuery;
        close?(e: ContextMenuCloseEvent): void;
        open?(e: ContextMenuOpenEvent): void;
        activate?(e: ContextMenuActivateEvent): void;
        deactivate?(e: ContextMenuDeactivateEvent): void;
        select?(e: ContextMenuSelectEvent): void;
    }


interface ContextMenuEvent {
        sender: ContextMenu;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ContextMenuCloseEvent extends ContextMenuEvent {
        item?: Element;
        type?: string;
        target?: Element;
        event?: JQueryEventObject;
    }


interface ContextMenuOpenEvent extends ContextMenuEvent {
        item?: Element;
        type?: string;
        target?: Element;
        event?: JQueryEventObject;
    }


interface ContextMenuActivateEvent extends ContextMenuEvent {
        item?: Element;
        type?: string;
        target?: Element;
    }


interface ContextMenuDeactivateEvent extends ContextMenuEvent {
        item?: Element;
        type?: string;
        target?: Element;
    }


interface ContextMenuSelectEvent extends ContextMenuEvent {
        item?: Element;
        type?: string;
        target?: Element;
    }


interface DateInputMessages {
        year?: string;
        month?: string;
        day?: string;
        weekday?: string;
        hour?: string;
        minute?: string;
        second?: string;
        dayperiod?: string;
    }


interface DateInputOptions {
        name?: string;
        format?: string;
        max?: Date;
        min?: Date;
        value?: Date;
        messages?: DateInputMessages;
        change?(e: DateInputChangeEvent): void;
    }


interface DateInputEvent {
        sender: DateInput;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DateInputChangeEvent extends DateInputEvent {
    }


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


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


interface DatePickerAnimation {
        close?: DatePickerAnimationClose;
        open?: DatePickerAnimationOpen;
    }


interface DatePickerMonth {
        content?: string;
        weekNumber?: string;
        empty?: string;
    }


interface DatePickerOptions {
        name?: string;
        animation?: boolean | DatePickerAnimation;
        ARIATemplate?: string;
        culture?: string;
        dateInput?: boolean;
        dates?: any;
        depth?: string;
        disableDates?: any|Function;
        footer?: boolean|string|Function;
        format?: string;
        max?: Date;
        min?: Date;
        month?: DatePickerMonth;
        weekNumber?: boolean;
        parseFormats?: any;
        start?: string;
        value?: Date;
        change?(e: DatePickerChangeEvent): void;
        close?(e: DatePickerCloseEvent): void;
        open?(e: DatePickerOpenEvent): void;
    }


interface DatePickerEvent {
        sender: DatePicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DatePickerChangeEvent extends DatePickerEvent {
    }


interface DatePickerCloseEvent extends DatePickerEvent {
    }


interface DatePickerOpenEvent extends DatePickerEvent {
    }


interface DateRangePickerMessages {
        startLabel?: string;
        endLabel?: string;
    }


interface DateRangePickerMonth {
        content?: string;
        weekNumber?: string;
        empty?: string;
    }


interface DateRangePickerRange {
        start?: Date;
        end?: Date;
    }


interface DateRangePickerOptions {
        name?: string;
        ARIATemplate?: string;
        culture?: string;
        dates?: any;
        depth?: string;
        disableDates?: any|Function;
        footer?: string|Function;
        format?: string;
        max?: Date;
        messages?: DateRangePickerMessages;
        min?: Date;
        month?: DateRangePickerMonth;
        labels?: boolean;
        weekNumber?: boolean;
        range?: DateRangePickerRange;
        start?: string;
        change?(e: DateRangePickerChangeEvent): void;
        close?(e: DateRangePickerCloseEvent): void;
        open?(e: DateRangePickerOpenEvent): void;
    }


interface DateRangePickerEvent {
        sender: DateRangePicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DateRangePickerChangeEvent extends DateRangePickerEvent {
    }


interface DateRangePickerCloseEvent extends DateRangePickerEvent {
    }


interface DateRangePickerOpenEvent extends DateRangePickerEvent {
    }


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


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


interface DateTimePickerAnimation {
        close?: DateTimePickerAnimationClose;
        open?: DateTimePickerAnimationOpen;
    }


interface DateTimePickerMonth {
        content?: string;
        weekNumber?: string;
        empty?: string;
    }


interface DateTimePickerOptions {
        name?: string;
        animation?: boolean | DateTimePickerAnimation;
        ARIATemplate?: string;
        culture?: string;
        dateInput?: boolean;
        dates?: any;
        depth?: string;
        disableDates?: any|Function;
        footer?: boolean|string|Function;
        format?: string;
        interval?: number;
        max?: Date;
        min?: Date;
        month?: DateTimePickerMonth;
        weekNumber?: boolean;
        parseFormats?: any;
        start?: string;
        timeFormat?: string;
        value?: Date;
        change?(e: DateTimePickerChangeEvent): void;
        close?(e: DateTimePickerCloseEvent): void;
        open?(e: DateTimePickerOpenEvent): void;
    }


interface DateTimePickerEvent {
        sender: DateTimePicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DateTimePickerChangeEvent extends DateTimePickerEvent {
    }


interface DateTimePickerCloseEvent extends DateTimePickerEvent {
        view?: string;
    }


interface DateTimePickerOpenEvent extends DateTimePickerEvent {
        view?: string;
    }


interface DialogAction {
        text?: string;
        action?: Function;
        primary?: boolean;
    }


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


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


interface DialogAnimation {
        close?: DialogAnimationClose;
        open?: DialogAnimationOpen;
    }


interface DialogMessages {
        close?: string;
        promptInput?: string;
    }


interface DialogModal {
        preventScroll?: string;
    }


interface DialogOptions {
        name?: string;
        actions?: DialogAction[];
        animation?: boolean | DialogAnimation;
        buttonLayout?: string;
        closable?: boolean;
        content?: string;
        height?: number|string;
        maxHeight?: number;
        maxWidth?: number;
        messages?: DialogMessages;
        minHeight?: number;
        minWidth?: number;
        modal?: boolean | DialogModal;
        title?: string|boolean;
        visible?: boolean;
        width?: number|string;
        size?: string;
        close?(e: DialogCloseEvent): void;
        hide?(e: DialogEvent): void;
        initOpen?(e: DialogEvent): void;
        open?(e: DialogEvent): void;
        show?(e: DialogEvent): void;
    }


interface DialogEvent {
        sender: Dialog;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DialogCloseEvent extends DialogEvent {
        userTriggered?: boolean;
    }


interface DrawerMini {
        width?: number;
        template?: string;
    }


interface DrawerOptions {
        name?: string;
        position?: string;
        mode?: string;
        template?: string;
        minHeight?: number;
        mini?: boolean | DrawerMini;
        swipeToOpen?: boolean;
        hide?(e: DrawerHideEvent): void;
        show?(e: DrawerEvent): void;
        itemClick?(e: DrawerEvent): void;
    }


interface DrawerEvent {
        sender: Drawer;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DrawerHideEvent extends DrawerEvent {
    }


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


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


interface DropDownListAnimation {
        close?: DropDownListAnimationClose;
        open?: DropDownListAnimationOpen;
    }


interface DropDownListPopup {
        appendTo?: string;
        origin?: string;
        position?: string;
    }


interface DropDownListVirtual {
        itemHeight?: number;
        mapValueTo?: string;
        valueMapper?: Function;
    }


interface DropDownListOptions {
        name?: string;
        animation?: boolean | DropDownListAnimation;
        autoBind?: boolean;
        autoWidth?: boolean;
        cascadeFrom?: string;
        cascadeFromField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        delay?: number;
        enable?: boolean;
        enforceMinLength?: boolean;
        filter?: string;
        fixedGroupTemplate?: string|Function;
        footerTemplate?: string|Function;
        groupTemplate?: string|Function;
        height?: number;
        ignoreCase?: boolean;
        index?: number;
        filterTitle?: string;
        minLength?: number;
        noDataTemplate?: string|Function|boolean;
        popup?: DropDownListPopup;
        optionLabel?: string|any;
        optionLabelTemplate?: string|Function;
        headerTemplate?: string|Function;
        template?: string|Function;
        valueTemplate?: string|Function;
        text?: string;
        value?: string;
        valuePrimitive?: boolean;
        virtual?: boolean | DropDownListVirtual;
        change?(e: DropDownListChangeEvent): void;
        close?(e: DropDownListCloseEvent): void;
        dataBound?(e: DropDownListDataBoundEvent): void;
        filtering?(e: DropDownListFilteringEvent): void;
        open?(e: DropDownListOpenEvent): void;
        select?(e: DropDownListSelectEvent): void;
        cascade?(e: DropDownListCascadeEvent): void;
    }


interface DropDownListEvent {
        sender: DropDownList;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DropDownListChangeEvent extends DropDownListEvent {
    }


interface DropDownListCloseEvent extends DropDownListEvent {
    }


interface DropDownListDataBoundEvent extends DropDownListEvent {
    }


interface DropDownListFilteringEvent extends DropDownListEvent {
        filter?: any;
    }


interface DropDownListOpenEvent extends DropDownListEvent {
    }


interface DropDownListSelectEvent extends DropDownListEvent {
        dataItem?: any;
        item?: JQuery;
    }


interface DropDownListCascadeEvent extends DropDownListEvent {
    }


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


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


interface DropDownTreeAnimation {
        close?: DropDownTreeAnimationClose;
        open?: DropDownTreeAnimationOpen;
    }


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


interface DropDownTreeMessages {
        clear?: string;
        deleteTag?: string;
        singleTag?: string;
    }


interface DropDownTreePopup {
        appendTo?: string;
        origin?: string;
        position?: string;
    }


interface DropDownTreeOptions {
        name?: string;
        animation?: boolean | DropDownTreeAnimation;
        autoBind?: boolean;
        autoClose?: boolean;
        autoWidth?: boolean;
        checkAll?: boolean;
        checkAllTemplate?: string|Function;
        checkboxes?: boolean | DropDownTreeCheckboxes;
        clearButton?: boolean;
        dataImageUrlField?: string;
        dataSource?: any|any|kendo.data.HierarchicalDataSource;
        dataSpriteCssClassField?: string;
        dataTextField?: string|any;
        dataUrlField?: string;
        dataValueField?: string|any;
        delay?: number;
        enable?: boolean;
        enforceMinLength?: boolean;
        filter?: string;
        footerTemplate?: string|Function;
        height?: string|number;
        ignoreCase?: boolean;
        loadOnDemand?: boolean;
        messages?: DropDownTreeMessages;
        minLength?: number;
        noDataTemplate?: string|Function|boolean;
        placeholder?: string;
        popup?: DropDownTreePopup;
        headerTemplate?: string|Function;
        valueTemplate?: string|Function;
        tagMode?: string;
        template?: string|Function;
        text?: string;
        value?: string|any;
        valuePrimitive?: boolean;
        change?(e: DropDownTreeChangeEvent): void;
        close?(e: DropDownTreeCloseEvent): void;
        dataBound?(e: DropDownTreeDataBoundEvent): void;
        filtering?(e: DropDownTreeFilteringEvent): void;
        open?(e: DropDownTreeOpenEvent): void;
        select?(e: DropDownTreeSelectEvent): void;
    }


interface DropDownTreeEvent {
        sender: DropDownTree;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DropDownTreeChangeEvent extends DropDownTreeEvent {
    }


interface DropDownTreeCloseEvent extends DropDownTreeEvent {
    }


interface DropDownTreeDataBoundEvent extends DropDownTreeEvent {
    }


interface DropDownTreeFilteringEvent extends DropDownTreeEvent {
        filter?: any;
    }


interface DropDownTreeOpenEvent extends DropDownTreeEvent {
    }


interface DropDownTreeSelectEvent extends DropDownTreeEvent {
        node?: Element;
    }


interface EditorDeserialization {
        custom?: Function;
    }


interface EditorFileBrowserMessages {
        uploadFile?: string;
        orderBy?: string;
        orderByName?: string;
        orderBySize?: string;
        directoryNotFound?: string;
        emptyFolder?: string;
        deleteFile?: string;
        invalidFileType?: string;
        overwriteFile?: string;
        search?: string;
    }


interface EditorFileBrowserSchemaModelFieldsName {
        field?: string;
        parse?: Function;
    }


interface EditorFileBrowserSchemaModelFieldsSize {
        field?: string;
        parse?: Function;
    }


interface EditorFileBrowserSchemaModelFieldsType {
        parse?: Function;
        field?: string;
    }


interface EditorFileBrowserSchemaModelFields {
        name?: string | EditorFileBrowserSchemaModelFieldsName;
        type?: string | EditorFileBrowserSchemaModelFieldsType;
        size?: string | EditorFileBrowserSchemaModelFieldsSize;
    }


interface EditorFileBrowserSchemaModel {
        id?: string;
        fields?: EditorFileBrowserSchemaModelFields;
    }


interface EditorFileBrowserSchema {
    }


interface EditorFileBrowserTransportCreate {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorFileBrowserTransportDestroy {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorFileBrowserTransportRead {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorFileBrowserTransport {
        read?: string | Function | EditorFileBrowserTransportRead;
        uploadUrl?: string;
        fileUrl?: string|Function;
        destroy?: string | EditorFileBrowserTransportDestroy;
        create?: string | EditorFileBrowserTransportCreate;
    }


interface EditorFileBrowser {
        fileTypes?: string;
        path?: string;
        transport?: EditorFileBrowserTransport;
        schema?: EditorFileBrowserSchema;
        messages?: EditorFileBrowserMessages;
    }


interface EditorImageBrowserMessages {
        uploadFile?: string;
        orderBy?: string;
        orderByName?: string;
        orderBySize?: string;
        directoryNotFound?: string;
        emptyFolder?: string;
        deleteFile?: string;
        invalidFileType?: string;
        overwriteFile?: string;
        search?: string;
    }


interface EditorImageBrowserSchemaModelFieldsName {
        field?: string;
        parse?: Function;
    }


interface EditorImageBrowserSchemaModelFieldsSize {
        field?: string;
        parse?: Function;
    }


interface EditorImageBrowserSchemaModelFieldsType {
        parse?: Function;
        field?: string;
    }


interface EditorImageBrowserSchemaModelFields {
        name?: string | EditorImageBrowserSchemaModelFieldsName;
        type?: string | EditorImageBrowserSchemaModelFieldsType;
        size?: string | EditorImageBrowserSchemaModelFieldsSize;
    }


interface EditorImageBrowserSchemaModel {
        id?: string;
        fields?: EditorImageBrowserSchemaModelFields;
    }


interface EditorImageBrowserSchema {
    }


interface EditorImageBrowserTransportCreate {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorImageBrowserTransportDestroy {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorImageBrowserTransportRead {
        contentType?: string;
        data?: any|string|Function;
        dataType?: string;
        type?: string;
        url?: string|Function;
    }


interface EditorImageBrowserTransport {
        read?: string | Function | EditorImageBrowserTransportRead;
        thumbnailUrl?: string|Function;
        uploadUrl?: string;
        imageUrl?: string|Function;
        destroy?: string | EditorImageBrowserTransportDestroy;
        create?: string | EditorImageBrowserTransportCreate;
    }


interface EditorImageBrowser {
        fileTypes?: string;
        path?: string;
        transport?: EditorImageBrowserTransport;
        schema?: EditorImageBrowserSchema;
        messages?: EditorImageBrowserMessages;
    }


interface EditorImmutables {
        deserialization?: Function;
        serialization?: string|Function;
    }


interface EditorMessages {
        accessibilityTab?: string;
        addColumnLeft?: string;
        addColumnRight?: string;
        addRowAbove?: string;
        addRowBelow?: string;
        alignCenter?: string;
        alignCenterBottom?: string;
        alignCenterMiddle?: string;
        alignCenterTop?: string;
        alignLeft?: string;
        alignLeftBottom?: string;
        alignLeftMiddle?: string;
        alignLeftTop?: string;
        alignRemove?: string;
        alignRight?: string;
        alignRightBottom?: string;
        alignRightMiddle?: string;
        alignRightTop?: string;
        alignment?: string;
        associateCellsWithHeaders?: string;
        backColor?: string;
        background?: string;
        bold?: string;
        border?: string;
        style?: string;
        caption?: string;
        cellMargin?: string;
        cellPadding?: string;
        cellSpacing?: string;
        cellTab?: string;
        cleanFormatting?: string;
        collapseBorders?: string;
        columns?: string;
        createLink?: string;
        createTable?: string;
        createTableHint?: string;
        cssClass?: string;
        deleteColumn?: string;
        deleteRow?: string;
        dialogCancel?: string;
        dialogInsert?: string;
        dialogOk?: string;
        dialogUpdate?: string;
        editAreaTitle?: string;
        fileTitle?: string;
        fileWebAddress?: string;
        fontName?: string;
        fontNameInherit?: string;
        fontSize?: string;
        fontSizeInherit?: string;
        foreColor?: string;
        formatBlock?: string;
        formatting?: string;
        height?: string;
        id?: string;
        imageAltText?: string;
        imageHeight?: string;
        imageWebAddress?: string;
        imageWidth?: string;
        indent?: string;
        insertFile?: string;
        insertHtml?: string;
        insertImage?: string;
        insertOrderedList?: string;
        insertUnorderedList?: string;
        insertUpperRomanList?: string;
        insertLowerRomanList?: string;
        italic?: string;
        overflowAnchor?: string;
        justifyCenter?: string;
        justifyFull?: string;
        justifyLeft?: string;
        justifyRight?: string;
        linkOpenInNewWindow?: string;
        linkText?: string;
        linkToolTip?: string;
        linkWebAddress?: string;
        outdent?: string;
        print?: string;
        rows?: string;
        selectAllCells?: string;
        strikethrough?: string;
        subscript?: string;
        summary?: string;
        superscript?: string;
        tableAlignLeft?: string;
        tableAlignCenter?: string;
        tableAlignRight?: string;
        tableTab?: string;
        tableWizard?: string;
        underline?: string;
        units?: string;
        unlink?: string;
        viewHtml?: string;
        width?: string;
        wrapText?: string;
        copyFormat?: string;
        applyFormat?: string;
    }


interface EditorPasteCleanup {
        all?: boolean;
        css?: boolean;
        custom?: Function;
        keepNewLines?: boolean;
        msAllFormatting?: boolean;
        msConvertLists?: boolean;
        msTags?: boolean;
        none?: boolean;
        span?: boolean;
    }


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


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


interface EditorResizable {
        content?: boolean;
        min?: number;
        max?: number;
        toolbar?: boolean;
    }


interface EditorSerialization {
        custom?: Function;
        entities?: boolean;
        scripts?: boolean;
        semantic?: boolean;
    }


interface EditorToolItem {
        text?: string;
        value?: string;
        context?: string;
    }


interface EditorTool {
        name?: string;
        tooltip?: string;
        exec?: Function;
        items?: EditorToolItem[];
        palette?: string|any;
        columns?: number;
        template?: string;
    }


interface EditorExecParams {
        value?: any;
    }


interface EditorPasteOptions {
        split?: boolean;
    }


interface EditorOptions {
        name?: string;
        placeholder?: string;
        deserialization?: EditorDeserialization;
        domain?: string;
        encoded?: boolean;
        immutables?: boolean | EditorImmutables;
        messages?: EditorMessages;
        pasteCleanup?: EditorPasteCleanup;
        pdf?: EditorPdf;
        resizable?: boolean | EditorResizable;
        serialization?: EditorSerialization;
        stylesheets?: any;
        tools?: EditorTool[]|string[];
        imageBrowser?: EditorImageBrowser;
        fileBrowser?: EditorFileBrowser;
        change?(e: EditorEvent): void;
        execute?(e: EditorExecuteEvent): void;
        keydown?(e: EditorEvent): void;
        keyup?(e: EditorEvent): void;
        paste?(e: EditorPasteEvent): void;
        pdfExport?(e: EditorPdfExportEvent): void;
        select?(e: EditorEvent): void;
    }


interface EditorEvent {
        sender: Editor;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface EditorExecuteEvent extends EditorEvent {
        name?: string;
        command?: any;
    }


interface EditorPasteEvent extends EditorEvent {
        html?: any;
    }


interface EditorPdfExportEvent extends EditorEvent {
        promise?: JQueryPromise<any>;
    }


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


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


interface ExpansionPanelAnimation {
        collapse?: ExpansionPanelAnimationCollapse;
        expand?: ExpansionPanelAnimationExpand;
    }


interface ExpansionPanelOptions {
        name?: string;
        animation?: boolean | ExpansionPanelAnimation;
        collapseIconClass?: string;
        disabled?: boolean;
        expanded?: boolean;
        expandIconClass?: string;
        height?: number|string;
        subTitle?: string;
        title?: string;
        toggleable?: boolean;
        expand?(e: ExpansionPanelEvent): void;
        collapse?(e: ExpansionPanelEvent): void;
        complete?(e: ExpansionPanelEvent): void;
    }


interface ExpansionPanelEvent {
        sender: ExpansionPanel;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FileManagerBreadcrumb {
        rootIcon?: string;
        delimiterIcon?: string;
    }


interface FileManagerContextMenuItem {
        name?: string;
        text?: string;
        spriteCssClass?: string;
        command?: string;
    }


interface FileManagerContextMenu {
        items?: FileManagerContextMenuItem[];

        close?(e: ContextMenuCloseEvent): void;
        open?(e: ContextMenuOpenEvent): void;
        activate?(e: ContextMenuActivateEvent): void;
        deactivate?(e: ContextMenuDeactivateEvent): void;
        select?(e: ContextMenuSelectEvent): void;
    }


interface FileManagerDialogs {
        upload?: any;
        moveConfirm?: any;
        deleteConfirm?: any;
        renamePrompt?: any;
    }


interface FileManagerMessagesDialogsDeleteConfirm {
        title?: string;
        content?: string;
        okText?: string;
        cancel?: string;
        close?: string;
    }


interface FileManagerMessagesDialogsMoveConfirm {
        title?: string;
        content?: string;
        okText?: string;
        cancel?: string;
        close?: string;
    }


interface FileManagerMessagesDialogsRenamePrompt {
        title?: string;
        content?: string;
        okText?: string;
        cancel?: string;
        close?: string;
    }


interface FileManagerMessagesDialogsUpload {
        title?: string;
        clear?: string;
        done?: string;
    }


interface FileManagerMessagesDialogs {
        upload?: FileManagerMessagesDialogsUpload;
        moveConfirm?: FileManagerMessagesDialogsMoveConfirm;
        deleteConfirm?: FileManagerMessagesDialogsDeleteConfirm;
        renamePrompt?: FileManagerMessagesDialogsRenamePrompt;
    }


interface FileManagerMessagesPreviewPane {
        noFileSelected?: string;
        extension?: string;
        size?: string;
        created?: string;
        modified?: string;
        items?: string;
    }


interface FileManagerMessagesToolbar {
        createFolder?: string;
        uploadDialog?: string;
        sortDirection?: string;
        sortDirectionAsc?: string;
        sortDirectionDesc?: string;
        sortField?: string;
        nameField?: string;
        sizeField?: string;
        typeField?: string;
        dateModifiedField?: string;
        dateCreatedField?: string;
        search?: string;
        details?: string;
        detailsChecked?: string;
        detailsUnchecked?: string;
        delete?: string;
        rename?: string;
    }


interface FileManagerMessagesViews {
        nameField?: string;
        sizeField?: string;
        typeField?: string;
        dateModifiedField?: string;
        dateCreatedField?: string;
        items?: string;
    }


interface FileManagerMessages {
        toolbar?: FileManagerMessagesToolbar;
        views?: FileManagerMessagesViews;
        dialogs?: FileManagerMessagesDialogs;
        previewPane?: FileManagerMessagesPreviewPane;
    }


interface FileManagerPreviewPane {
        metaFields?: any;
        noFileTemplate?: string|Function;
        singleFileTemplate?: string|Function;
        multipleFilesTemplate?: string|Function;
    }


interface FileManagerToolbarItem {
        type?: string;
        overflow?: string;
        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 FileManagerToolbar {
        items?: FileManagerToolbarItem[];
    }


interface FileManagerViews {
        grid?: any;
        list?: any;
        tree?: any;
    }


interface FileManagerOptions {
        name?: string;
        width?: number|string;
        height?: number|string;
        initialView?: string;
        resizable?: boolean;
        draggable?: boolean;
        dataSource?: any|any|kendo.data.FileManagerDataSource;
        upload?: any;
        uploadUrl?: string;
        toolbar?: boolean | FileManagerToolbar;
        dialogs?: FileManagerDialogs;
        contextMenu?: boolean | FileManagerContextMenu;
        views?: FileManagerViews;
        previewPane?: FileManagerPreviewPane;
        breadcrumb?: boolean | FileManagerBreadcrumb;
        messages?: FileManagerMessages;
        navigate?(e: FileManagerEvent): void;
        select?(e: FileManagerEvent): void;
        open?(e: FileManagerEvent): void;
        execute?(e: FileManagerEvent): void;
        error?(e: FileManagerEvent): void;
        dataBinding?(e: FileManagerEvent): void;
        dataBound?(e: FileManagerEvent): void;
        drop?(e: FileManagerEvent): void;
    }


interface FileManagerEvent {
        sender: FileManager;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FilterField {
        defaultValue?: any;
        editorTemplate?: string|Function;
        label?: string;
        name?: string;
        type?: string;
        previewFormat?: string;
    }


interface FilterMessages {
        and?: string;
        apply?: string;
        or?: string;
    }


interface FilterOperatorsBoolean {
        eq?: string;
        neq?: string;
    }


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


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


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


interface FilterOperators {
        string?: FilterOperatorsString;
        number?: FilterOperatorsNumber;
        date?: FilterOperatorsDate;
        boolean?: FilterOperatorsBoolean;
    }


interface FilterOptions {
        name?: string;
        applyButton?: boolean;
        dataSource?: kendo.data.DataSource;
        expression?: any;
        expressionPreview?: boolean;
        fields?: FilterField[];
        mainLogic?: string;
        messages?: FilterMessages;
        operators?: FilterOperators;
        change?(e: FilterChangeEvent): void;
    }


interface FilterEvent {
        sender: Filter;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FilterChangeEvent extends FilterEvent {
        expression?: any;
    }


interface FilterMenuMessages {
        and?: string;
        clear?: string;
        filter?: string;
        info?: string;
        title?: string;
        additionalValue?: string;
        additionalOperator?: string;
        logic?: string;
        isFalse?: string;
        isTrue?: string;
        or?: string;
        selectValue?: string;
    }


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


interface FilterMenuOperatorsEnums {
        eq?: string;
        neq?: string;
        isnull?: string;
        isnotnull?: string;
    }


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


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


interface FilterMenuOperators {
        string?: FilterMenuOperatorsString;
        number?: FilterMenuOperatorsNumber;
        date?: FilterMenuOperatorsDate;
        enums?: FilterMenuOperatorsEnums;
    }


interface FilterMenuOptions {
        name?: string;
        dataSource?: any|any|kendo.data.DataSource;
        extra?: boolean;
        field?: string;
        messages?: FilterMenuMessages;
        operators?: FilterMenuOperators;
    }


interface FilterMenuEvent {
        sender: FilterMenu;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FlatColorPickerMessages {
        apply?: string;
        cancel?: string;
    }


interface FlatColorPickerOptions {
        name?: string;
        opacity?: boolean;
        buttons?: boolean;
        value?: string;
        preview?: boolean;
        autoupdate?: boolean;
        messages?: FlatColorPickerMessages;
        change?(e: FlatColorPickerChangeEvent): void;
    }


interface FlatColorPickerEvent {
        sender: FlatColorPicker;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FlatColorPickerChangeEvent extends FlatColorPickerEvent {
        value?: string;
    }


interface FloatingActionButtonAlignOffset {
        x?: number;
        y?: number;
    }


interface FloatingActionButtonOptions {
        icon?: string;
        text?: string;
        themeColor?: string | FloatingActionButtonThemeColor;
        size?: string | FloatingActionButtonSize;
        shape?: string | FloatingActionButtonShape;
        align?: string;
        alignOffset?: FloatingActionButtonAlignOffset;
        positionMode?: string | FloatingActionButtonPositionMode
        visible?: boolean;
        enabled?: boolean;
        items?: FloatingActionButtonItem[];

        click?(e: FloatingActionButtonClickEvent): void;
        expand?(e: FloatingActionButtonExpandEvent): void;
        collapse?(e: FloatingActionButtonCollapseEvent): void;
    }


interface FloatingActionButtonItem {
        label?: string;
        icon?: string;
        title?: string;
        enabled?: boolean;
        cssClass?: string;

        click?(e: FloatingActionButtonItemClickEvent): void;
    }


interface FloatingActionButtonEvent {
        sender: FloatingActionButton;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FloatingActionButtonExpandEvent extends FloatingActionButtonEvent {
    }


interface FloatingActionButtonCollapseEvent extends FloatingActionButtonEvent {
    }


interface FloatingActionButtonClickEvent extends FloatingActionButtonEvent {
    }


interface FloatingActionButtonItemClickEvent extends FloatingActionButtonEvent {
        target: JQuery;
        item: FloatingActionButtonItem | any;
    }


interface FormOptions {
        name?: string;
        orientation?: string | "horizontal" | "vertical";
        focusFirst?: boolean;
        formatLabel?: Function;
        buttonsTemplate?: string|Function;
        items?: FormItem[];
        formData?: FormData;
        layout?: string | "grid";
        grid?: FormGridOptions;
        validatable?: FormValidatable;

        change?(e: FormChangeEvent): void;
        validate?(e: FormValidateEvent): void;
        validateField?(e: FormValidateFieldEvent): void;
        submit?(e: FormSubmitEvent): void;
        clear?(e: FormClearEvent): void;
    }


interface FormData {
        [key: string]: any;
    }


interface FormItemLabel {
        text?: string;
        optional?: boolean;
        encoded?: boolean;
    }


interface FormGridOptions {
        cols?: string | number;
        gutter?: string | number;
    }


interface FormItem {
        field?: string;
        type?: string;
        name?: string;
        id?: string;
        hint?: string;
        title?: string;
        colSpan?: number;
        attributes?: any;
        editor?: string|Function;
        editorOptions?: any;
        label?: string | FormItemLabel;
        validation?: any;
        items?: FormItem[];
    }


interface FormValidatable {
        validateOnBlur: boolean;
        validationSummary: boolean;
        errorTemplate: string|Function;
    }


interface FormEvent {
        sender: Form;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface FormChangeEvent extends FormEvent {
        field?: string;
        value?: any;
    }


interface FormValidateEvent extends FormEvent {
        model?: kendo.data.Model;
        valid?: boolean;
        errors?: any[];
    }


interface FormValidateFieldEvent extends FormEvent {
        model?: kendo.data.Model;
        valid?: boolean;
        field?: string;
        error?: string;
        input?: Element;
    }


interface FormSubmitEvent extends FormEvent {
        model?: kendo.data.Model;
    }


interface FormClearEvent extends FormEvent {
    }


interface GanttAssignments {
        dataSource?: any|any|kendo.data.DataSource;
        dataResourceIdField?: string;
        dataTaskIdField?: string;
        dataValueField?: string;
    }


interface GanttColumnFilterable {
        ui?: string|Function;
    }


interface GanttColumnSortable {
        compare?: Function;
    }


interface GanttColumn {
        attributes?: any;
        columns?: any;
        editable?: boolean;
        editor?: Function;
        expandable?: boolean;
        field?: string;
        filterable?: boolean | GanttColumnFilterable;
        format?: string;
        headerAttributes?: any;
        headerTemplate?: string|Function;
        hidden?: boolean;
        menu?: boolean;
        minScreenWidth?: number;
        sortable?: boolean | GanttColumnSortable;
        template?: string|Function;
        title?: string;
        width?: string|number;
    }


interface GanttCurrentTimeMarker {
        updateInterval?: number;
    }


interface GanttEditable {
        confirmation?: boolean;
        create?: boolean;
        dependencyCreate?: boolean;
        dependencyDestroy?: boolean;
        dragPercentComplete?: boolean;
        destroy?: boolean;
        move?: boolean;
        reorder?: boolean;
        resize?: boolean;
        template?: string|Function;
        update?: boolean;
        plannedTasks?: boolean;
    }


interface GanttMessagesActions {
        addChild?: string;
        append?: string;
        insertAfter?: string;
        insertBefore?: string;
        pdf?: string;
    }


interface GanttMessagesEditor {
        assignButton?: string;
        editorTitle?: string;
        end?: string;
        percentComplete?: string;
        plannedEnd?: string;
        plannedStart?: string;
        resources?: string;
        resourcesEditorTitle?: string;
        resourcesHeader?: string;
        start?: string;
        title?: string;
        unitsHeader?: string;
    }


interface GanttMessagesPlannedTasks {
        switchText?: string;
        offsetTooltipAdvanced?: string;
        offsetTooltipDelay?: string;
        seconds?: string;
        minutes?: string;
        hours?: string;
        days?: string;
    }


interface GanttMessagesViews {
        day?: string;
        end?: string;
        month?: string;
        start?: string;
        week?: string;
        year?: string;
    }


interface GanttMessages {
        actions?: GanttMessagesActions;
        cancel?: string;
        deleteDependencyConfirmation?: string;
        deleteDependencyWindowTitle?: string;
        deleteTaskConfirmation?: string;
        deleteTaskWindowTitle?: string;
        destroy?: string;
        editor?: GanttMessagesEditor;
        plannedTasks?: GanttMessagesPlannedTasks;
        save?: string;
        views?: GanttMessagesViews;
    }


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


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


interface GanttRange {
        start?: Date;
        end?: Date;
    }


interface GanttResources {
        dataFormatField?: string;
        dataColorField?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        field?: string;
    }


interface GanttToolbarItem {
        name?: string;
        template?: string|Function;
        text?: string;
    }


interface GanttTooltip {
        template?: string|Function;
        visible?: boolean;
    }


interface GanttViewRange {
        start?: Date;
        end?: Date;
    }


interface GanttView {
        date?: Date;
        range?: GanttViewRange;
        type?: string;
        selected?: boolean;
        slotSize?: number|string;
        timeHeaderTemplate?: string|Function;
        dayHeaderTemplate?: string|Function;
        weekHeaderTemplate?: string|Function;
        monthHeaderTemplate?: string|Function;
        yearHeaderTemplate?: string|Function;
        resizeTooltipFormat?: string;
    }


interface GanttOptions {
        name?: string;
        assignments?: GanttAssignments;
        autoBind?: boolean;
        columnResizeHandleWidth?: number;
        columnMenu?: boolean|any;
        columns?: GanttColumn[];
        currentTimeMarker?: boolean | GanttCurrentTimeMarker;
        dataSource?: any|any|kendo.data.GanttDataSource;
        date?: Date;
        dependencies?: any|any|kendo.data.GanttDependencyDataSource;
        editable?: boolean | GanttEditable;
        filterable?: boolean|any;
        reorderable?: boolean;
        navigatable?: boolean;
        workDayStart?: Date;
        workDayEnd?: Date;
        workWeekStart?: number;
        workWeekEnd?: number;
        hourSpan?: number;
        snap?: boolean;
        height?: number|string;
        listWidth?: string|number;
        messages?: GanttMessages;
        pdf?: GanttPdf;
        range?: GanttRange;
        resizable?: boolean;
        selectable?: boolean;
        showWorkDays?: boolean;
        showWorkHours?: boolean;
        taskTemplate?: string|Function;
        toolbar?: GanttToolbarItem[];
        tooltip?: GanttTooltip;
        views?: GanttView[];
        resources?: GanttResources;
        rowHeight?: number|string;
        dataBinding?(e: GanttDataBindingEvent): void;
        dataBound?(e: GanttDataBoundEvent): void;
        add?(e: GanttAddEvent): void;
        edit?(e: GanttEditEvent): void;
        remove?(e: GanttRemoveEvent): void;
        cancel?(e: GanttCancelEvent): void;
        save?(e: GanttSaveEvent): void;
        change?(e: GanttChangeEvent): void;
        columnResize?(e: GanttColumnResizeEvent): void;
        navigate?(e: GanttNavigateEvent): void;
        moveStart?(e: GanttMoveStartEvent): void;
        move?(e: GanttMoveEvent): void;
        moveEnd?(e: GanttMoveEndEvent): void;
        pdfExport?(e: GanttPdfExportEvent): void;
        resizeStart?(e: GanttResizeStartEvent): void;
        resize?(e: GanttResizeEvent): void;
        resizeEnd?(e: GanttResizeEndEvent): void;
        togglePlannedTasks?(e: GanttTogglePlannedTasks): void;
    }


interface GanttEvent {
        sender: Gantt;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface GanttDataBindingEvent extends GanttEvent {
    }


interface GanttDataBoundEvent extends GanttEvent {
    }


interface GanttAddEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        dependency?: kendo.data.GanttDependency;
    }


interface GanttEditEvent extends GanttEvent {
        container?: JQuery;
        task?: kendo.data.GanttTask;
    }


interface GanttRemoveEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        dependencies?: any;
    }


interface GanttCancelEvent extends GanttEvent {
        container?: JQuery;
        task?: kendo.data.GanttTask;
    }


interface GanttSaveEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        values?: any;
    }


interface GanttChangeEvent extends GanttEvent {
    }


interface GanttColumnResizeEvent extends GanttEvent {
        column?: any;
        newWidth?: number;
        oldWidth?: number;
    }


interface GanttNavigateEvent extends GanttEvent {
        view?: string;
    }


interface GanttMoveStartEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
    }


interface GanttMoveEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        start?: Date;
        end?: Date;
    }


interface GanttMoveEndEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        start?: Date;
        end?: Date;
    }


interface GanttPdfExportEvent extends GanttEvent {
        promise?: JQueryPromise<any>;
    }


interface GanttResizeStartEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
    }


interface GanttResizeEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        start?: Date;
        end?: Date;
    }


interface GanttResizeEndEvent extends GanttEvent {
        task?: kendo.data.GanttTask;
        start?: Date;
        end?: Date;
    }


interface GanttTogglePlannedTasks extends GanttEvent {
        showPlannedTasks?: boolean;
    }


interface GridAllowCopy {
        delimeter?: string|any;
    }


interface GridColumnMenuColumnsGroup {
        columns?: any;
        title?: string;
    }


interface GridColumnMenuColumns {
        sort?: string;
        groups?: GridColumnMenuColumnsGroup[];
    }


interface GridColumnMenuMessages {
        columns?: string;
        filter?: string;
        sortAscending?: string;
        sortDescending?: string;
        setColumnPosition?: string;
        settings?: string;
        stick?: string;
        unstick?: string;
        done?: string;
        lock?: string;
        unlock?: string;
        apply?: string;
        reset?: string;
    }


interface GridColumnMenu {
        columns?: boolean | GridColumnMenuColumns;
        filterable?: boolean;
        sortable?: boolean;
        messages?: GridColumnMenuMessages;
        componentType?: string;
    }


interface GridColumnCommandItemIconClass {
        cancel?: string;
        edit?: string;
        update?: string;
    }


interface GridColumnCommandItemText {
        edit?: string;
        cancel?: string;
        update?: string;
    }


interface GridColumnCommandItem {
        className?: string;
        click?: Function;
        iconClass?: string | GridColumnCommandItemIconClass;
        name?: string;
        template?: string;
        text?: string | GridColumnCommandItemText;
        visible?: Function;
    }


interface GridColumnExportable {
        excel?: boolean;
        pdf?: boolean;
    }


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


interface GridColumnFilterable {
        cell?: GridColumnFilterableCell;
        extra?: boolean;
        multi?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        checkAll?: boolean;
        itemTemplate?: Function;
        operators?: any;
        search?: boolean;
        ignoreCase?: boolean;
        ui?: string|Function;
    }


interface GridColumnGroupable {
        compare?: Function;
        dir?: string;
    }


interface GridColumnSortable {
        allowUnsort?: boolean;
        compare?: Function;
        initialDirection?: string;
    }


interface GridColumn {
        dataTextField?: string;
        dataValueField?: string;
        dataSource?: kendo.data.DataSource | kendo.data.DataSourceOptions;
        aggregates?: any;
        attributes?: any;
        columns?: any;
        command?: string | string[] | GridColumnCommandItem | GridColumnCommandItem[];
        editable?: Function;
        encoded?: boolean;
        exportable?: boolean | GridColumnExportable;
        field?: string;
        filterable?: boolean | GridColumnFilterable;
        footerAttributes?: any;
        footerTemplate?: string|Function;
        format?: string;
        groupable?: boolean | GridColumnGroupable;
        groupHeaderColumnTemplate?: string|Function;
        groupHeaderTemplate?: string|Function;
        groupFooterTemplate?: string|Function;
        headerAttributes?: any;
        headerTemplate?: string|Function;
        hidden?: boolean;
        locked?: boolean;
        lockable?: boolean;
        media?: string;
        minResizableWidth?: number;
        minScreenWidth?: number;
        selectable?: boolean;
        sortable?: boolean | GridColumnSortable;
        sticky?: boolean;
        stickable?: boolean;
        template?: string|Function;
        title?: string;
        width?: string|number;
        values?: any;
        menu?: boolean;
    }


interface GridEditable {
        confirmation?: boolean|string|Function;
        cancelDelete?: string;
        confirmDelete?: string;
        createAt?: string;
        destroy?: boolean;
        mode?: string;
        template?: string|Function;
        update?: boolean;
        window?: any;
    }


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


interface GridFilterableMessages {
        and?: string;
        clear?: string;
        filter?: string;
        info?: string;
        title?: string;
        isFalse?: string;
        isTrue?: string;
        or?: string;
        search?: string;
        selectValue?: string;
        cancel?: string;
        selectedItemsFormat?: string;
        operator?: string;
        value?: string;
        checkAll?: string;
    }


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


interface GridFilterableOperatorsEnums {
        eq?: string;
        neq?: string;
        isnull?: string;
        isnotnull?: string;
    }


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


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


interface GridFilterableOperators {
        string?: GridFilterableOperatorsString;
        number?: GridFilterableOperatorsNumber;
        date?: GridFilterableOperatorsDate;
        enums?: GridFilterableOperatorsEnums;
    }


interface GridFilterable {
        extra?: boolean;
        messages?: GridFilterableMessages;
        mode?: string;
        operators?: GridFilterableOperators;
    }


interface GridGroupableMessages {
        empty?: string;
    }


interface GridGroupable {
        enabled?: boolean;
        showFooter?: boolean;
        messages?: GridGroupableMessages;
        compare?: Function;
        dir?: string;
    }


interface GridMessagesCommands {
        cancel?: string;
        canceledit?: string;
        create?: string;
        destroy?: string;
        edit?: string;
        excel?: string;
        save?: string;
        update?: string;
    }


interface GridMessages {
        commands?: GridMessagesCommands;
        noRecords?: string;
        expandCollapseColumnHeader?: string;
    }


interface GridNoRecords {
        template?: string|Function;
    }


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


interface GridPageable {
        alwaysVisible?: boolean;
        pageSize?: number;
        previousNext?: boolean;
        numeric?: boolean;
        buttonCount?: number;
        input?: boolean;
        pageSizes?: boolean|any;
        refresh?: boolean;
        responsive?: boolean;
        info?: boolean;
        messages?: GridPageableMessages;
        position?: string;
    }


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


interface GridPdf {
        allPages?: boolean;
        author?: string;
        avoidLinks?: boolean|string;
        creator?: string;
        date?: Date;
        fileName?: string;
        forceProxy?: boolean;
        keywords?: string;
        landscape?: boolean;
        margin?: GridPdfMargin;
        paperSize?: string|any;
        template?: string;
        repeatHeaders?: boolean;
        scale?: number;
        proxyURL?: string;
        proxyTarget?: string;
        subject?: string;
        title?: string;
    }


interface GridScrollable {
        virtual?: boolean|string;
        endless?: boolean;
    }


interface GridSearch {
        fields?: any;
    }


interface GridSortable {
        allowUnsort?: boolean;
        showIndexes?: boolean;
        initialDirection?: string;
        mode?: string;
    }


interface GridToolbarItem {
        iconClass?: string;
        name?: string;
        template?: string|Function;
        text?: string;
    }


interface GridOptions {
        name?: string;
        allowCopy?: boolean | GridAllowCopy;
        altRowTemplate?: string|Function;
        autoBind?: boolean;
        columnResizeHandleWidth?: number;
        columns?: GridColumn[];
        columnMenu?: boolean | GridColumnMenu;
        dataSource?: any|any|kendo.data.DataSource;
        detailTemplate?: string|Function;
        editable?: boolean | "inline" | "incell" | "popup" | GridEditable;
        excel?: GridExcel;
        filterable?: boolean | GridFilterable;
        groupable?: boolean | GridGroupable;
        height?: number|string;
        loaderType?: string;
        messages?: GridMessages;
        mobile?: boolean|string;
        navigatable?: boolean;
        noRecords?: boolean | GridNoRecords;
        pageable?: boolean | GridPageable;
        pdf?: GridPdf;
        persistSelection?: boolean;
        reorderable?: boolean;
        resizable?: boolean;
        rowTemplate?: string|Function;
        scrollable?: boolean | GridScrollable;
        search?: GridSearch;
        selectable?: boolean|string;
        sortable?: boolean | GridSortable;
        toolbar?: string | Function | (string | GridToolbarItem)[];
        beforeEdit?(e: GridBeforeEditEvent): void;
        cancel?(e: GridCancelEvent): void;
        cellClose?(e: GridCellCloseEvent): void;
        change?(e: GridChangeEvent): void;
        columnHide?(e: GridColumnHideEvent): void;
        columnLock?(e: GridColumnLockEvent): void;
        columnMenuInit?(e: GridColumnMenuInitEvent): void;
        columnMenuOpen?(e: GridColumnMenuOpenEvent): void;
        columnReorder?(e: GridColumnReorderEvent): void;
        columnResize?(e: GridColumnResizeEvent): void;
        columnShow?(e: GridColumnShowEvent): void;
        columnStick?(e: GridColumnStickEvent): void;
        columnUnlock?(e: GridColumnUnlockEvent): void;
        columnUnstick?(e: GridColumnUnstickEvent): void;
        dataBinding?(e: GridDataBindingEvent): void;
        dataBound?(e: GridDataBoundEvent): void;
        detailCollapse?(e: GridDetailCollapseEvent): void;
        detailExpand?(e: GridDetailExpandEvent): void;
        detailInit?(e: GridDetailInitEvent): void;
        edit?(e: GridEditEvent): void;
        excelExport?(e: GridExcelExportEvent): void;
        filter?(e: GridFilterEvent): void;
        filterMenuInit?(e: GridFilterMenuInitEvent): void;
        filterMenuOpen?(e: GridFilterMenuOpenEvent): void;
        group?(e: GridGroupEvent): void;
        groupCollapse?(e: GridGroupCollapseEvent): void;
        groupExpand?(e: GridGroupExpandEvent): void;
        navigate?(e: GridNavigateEvent): void;
        page?(e: GridPageEvent): void;
        pdfExport?(e: GridPdfExportEvent): void;
        remove?(e: GridRemoveEvent): void;
        save?(e: GridSaveEvent): void;
        saveChanges?(e: GridSaveChangesEvent): void;
        sort?(e: GridSortEvent): void;
    }


interface GridEvent {
        sender: Grid;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface GridBeforeEditEvent extends GridEvent {
        model?: kendo.data.Model;
    }


interface GridCancelEvent extends GridEvent {
        container?: JQuery;
        model?: kendo.data.Model;
    }


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


interface GridChangeEvent extends GridEvent {
    }


interface GridColumnHideEvent extends GridEvent {
        column?: any;
    }


interface GridColumnLockEvent extends GridEvent {
        column?: any;
    }


interface GridColumnMenuInitEvent extends GridEvent {
        container?: JQuery;
        field?: string;
    }


interface GridColumnMenuOpenEvent extends GridEvent {
        container?: JQuery;
        field?: string;
    }


interface GridColumnReorderEvent extends GridEvent {
        column?: any;
        newIndex?: number;
        oldIndex?: number;
    }


interface GridColumnResizeEvent extends GridEvent {
        column?: any;
        newWidth?: number;
        oldWidth?: number;
    }


interface GridColumnShowEvent extends GridEvent {
        column?: any;
    }


interface GridColumnStickEvent extends GridEvent {
        column?: any;
    }


interface GridColumnUnlockEvent extends GridEvent {
        column?: any;
    }


interface GridColumnUnstickEvent extends GridEvent {
        column?: any;
    }


interface GridDataBindingEvent extends GridEvent {
        action?: string;
        index?: number;
        items?: any;
    }


interface GridDataBoundEvent extends GridEvent {
    }


interface GridDetailCollapseEvent extends GridEvent {
        detailRow?: JQuery;
        masterRow?: JQuery;
    }


interface GridDetailExpandEvent extends GridEvent {
        detailRow?: JQuery;
        masterRow?: JQuery;
    }


interface GridDetailInitEvent extends GridEvent {
        data?: kendo.data.ObservableObject;
        detailCell?: JQuery;
        detailRow?: JQuery;
        masterRow?: JQuery;
    }


interface GridEditEvent extends GridEvent {
        container?: JQuery;
        model?: kendo.data.Model;
    }


interface GridExcelExportEvent extends GridEvent {
        data?: any;
        workbook?: kendo.ooxml.Workbook;
    }


interface GridFilterEvent extends GridEvent {
        filter?: any;
        field?: string;
    }


interface GridFilterMenuInitEvent extends GridEvent {
        container?: JQuery;
        field?: string;
    }


interface GridFilterMenuOpenEvent extends GridEvent {
        container?: JQuery;
        field?: string;
    }


interface GridGroupEvent extends GridEvent {
        groups?: any;
    }


interface GridGroupCollapseEvent extends GridEvent {
        element?: JQuery;
        group?: any;
    }


interface GridGroupExpandEvent extends GridEvent {
        element?: JQuery;
        group?: any;
    }


interface GridNavigateEvent extends GridEvent {
        element?: JQuery;
    }


interface GridPageEvent extends GridEvent {
        page?: number;
    }


interface GridPdfExportEvent extends GridEvent {
        promise?: JQueryPromise<any>;
    }


interface GridRemoveEvent extends GridEvent {
        model?: kendo.data.Model;
        row?: JQuery;
    }


interface GridSaveEvent extends GridEvent {
        model?: kendo.data.Model;
        container?: JQuery;
        values?: any;
    }


interface GridSaveChangesEvent extends GridEvent {
    }


interface GridSortEvent extends GridEvent {
        sort?: any;
    }


interface ImageEditorMessagesCommon {
        width?: string;
        height?: string;
        cancel?: string;
        confirm?: string;
        lockAspectRatio?: string;
    }


interface ImageEditorMessagesPanesCropAspectRatioItems {
        originalRatio?: string;
    }


interface ImageEditorMessagesPanesCrop {
        title?: string;
        aspectRatio?: string;
        aspectRatioItems?: ImageEditorMessagesPanesCropAspectRatioItems;
        orientation?: string;
        portrait?: string;
        landscape?: string;
    }


interface ImageEditorMessagesPanesResize {
        title?: string;
        pixels?: string;
        percents?: string;
    }


interface ImageEditorMessagesPanes {
        crop?: ImageEditorMessagesPanesCrop;
        resize?: ImageEditorMessagesPanesResize;
    }


interface ImageEditorMessagesToolbar {
        open?: string;
        save?: string;
        undo?: string;
        redo?: string;
        crop?: string;
        resize?: string;
        zoomIn?: string;
        zoomOut?: string;
        zoomDropdown?: string;
        zoomActualSize?: string;
        zoomFitToScreen?: string;
    }


interface ImageEditorMessages {
        toolbar?: ImageEditorMessagesToolbar;
        panes?: ImageEditorMessagesPanes;
        common?: ImageEditorMessagesCommon;
    }


interface ImageEditorSaveAs {
        fileName?: string;
        forceProxy?: boolean;
        proxyURL?: boolean;
        proxyTarget?: string;
    }


interface ImageEditorToolbarItem {
        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 ImageEditorToolbar {
        items?: ImageEditorToolbarItem[];
        click?: Function;
        close?: Function;
        open?: Function;
        toggle?: Function;
        overflowClose?: Function;
        overflowOpen?: Function;
    }


interface ImageEditorOptions {
        name?: string;
        width?: number|string;
        height?: number|string;
        imageUrl?: string;
        saveAs?: ImageEditorSaveAs;
        toolbar?: boolean | ImageEditorToolbar;
        messages?: ImageEditorMessages;
        imageLoaded?(e: ImageEditorImageLoadedEvent): void;
        imageRendered?(e: ImageEditorImageRenderedEvent): void;
        execute?(e: ImageEditorExecuteEvent): void;
        error?(e: ImageEditorErrorEvent): void;
    }


interface ImageEditorEvent {
        sender: ImageEditor;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ImageEditorImageLoadedEvent extends ImageEditorEvent {
        image?: any;
    }


interface ImageEditorImageRenderedEvent extends ImageEditorEvent {
        image?: any;
        canvas?: HTMLElement;
        ctx?: any;
    }


interface ImageEditorExecuteEvent extends ImageEditorEvent {
        command?: string;
        options?: any;
    }


interface ImageEditorErrorEvent extends ImageEditorEvent {
    }


interface ListBoxDraggable {
        enabled?: boolean;
        hint?: Function|string|JQuery;
        placeholder?: Function|string|JQuery;
    }


interface ListBoxMessagesTools {
        moveDown?: string;
        moveUp?: string;
        remove?: string;
        transferAllFrom?: string;
        transferAllTo?: string;
        transferFrom?: string;
        transferTo?: string;
    }


interface ListBoxMessages {
        tools?: ListBoxMessagesTools;
    }


interface ListBoxToolbar {
        position?: string;
        tools?: any;
    }


interface ListBoxOptions {
        name?: string;
        autoBind?: boolean;
        connectWith?: string;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        draggable?: boolean | ListBoxDraggable;
        dropSources?: any;
        navigatable?: boolean;
        messages?: ListBoxMessages;
        selectable?: string;
        template?: string|Function;
        toolbar?: ListBoxToolbar;
        add?(e: ListBoxAddEvent): void;
        change?(e: ListBoxEvent): void;
        dataBound?(e: ListBoxEvent): void;
        dragstart?(e: ListBoxDragstartEvent): void;
        drag?(e: ListBoxDragEvent): void;
        drop?(e: ListBoxDropEvent): void;
        dragend?(e: ListBoxDragendEvent): void;
        remove?(e: ListBoxRemoveEvent): void;
        reorder?(e: ListBoxReorderEvent): void;
    }


interface ListBoxEvent {
        sender: ListBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ListBoxAddEvent extends ListBoxEvent {
        items?: any;
        dataItems?: any;
    }


interface ListBoxDragstartEvent extends ListBoxEvent {
        draggableEvent?: any;
        items?: JQuery;
    }


interface ListBoxDragEvent extends ListBoxEvent {
        items?: JQuery;
        dataItems?: any;
        draggableEvent?: any;
    }


interface ListBoxDropEvent extends ListBoxEvent {
        items?: any;
        dataItems?: any;
    }


interface ListBoxDragendEvent extends ListBoxEvent {
        items?: any;
        dataItems?: any;
        draggableEvent?: any;
    }


interface ListBoxRemoveEvent extends ListBoxEvent {
        items?: any;
        dataItems?: any;
    }


interface ListBoxReorderEvent extends ListBoxEvent {
        items?: any;
        dataItems?: any;
        offset?: number;
    }


interface ListViewOptions {
        name?: string;
        autoBind?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        editTemplate?: Function;
        height?: number|string;
        scrollable?: boolean|string;
        navigatable?: boolean;
        selectable?: boolean|string;
        template?: Function;
        altTemplate?: Function;
        cancel?(e: ListViewCancelEvent): void;
        change?(e: ListViewEvent): void;
        dataBound?(e: ListViewEvent): void;
        dataBinding?(e: ListViewEvent): void;
        edit?(e: ListViewEditEvent): void;
        remove?(e: ListViewRemoveEvent): void;
        save?(e: ListViewSaveEvent): void;
    }


interface ListViewEvent {
        sender: ListView;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ListViewCancelEvent extends ListViewEvent {
        container?: JQuery;
        model?: kendo.data.Model;
    }


interface ListViewEditEvent extends ListViewEvent {
        item?: JQuery;
        model?: kendo.data.Model;
    }


interface ListViewRemoveEvent extends ListViewEvent {
        item?: JQuery;
        model?: kendo.data.Model;
    }


interface ListViewSaveEvent extends ListViewEvent {
        model?: kendo.data.Model;
        item?: JQuery;
    }


interface LoaderOptions {
        name?: string;
        themeColor?: string;
        type?: string;
        size?: string;
        visible?: boolean;
    }


interface LoaderEvent {
        sender: Loader;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


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


interface MaskedTextBoxOptions {
        name?: string;
        clearPromptChar?: boolean;
        culture?: string;
        label?: string | Function | MaskedTextBoxLabel;
        mask?: string;
        promptChar?: string;
        rules?: any;
        unmaskOnPost?: boolean;
        value?: string;
        change?(e: MaskedTextBoxChangeEvent): void;
    }


interface MaskedTextBoxEvent {
        sender: MaskedTextBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MaskedTextBoxChangeEvent extends MaskedTextBoxEvent {
    }


interface MediaPlayerMedia {
        source?: string;
        title?: string;
    }


interface MediaPlayerMessages {
        pause?: string;
        play?: string;
        mute?: string;
        unmute?: string;
        quality?: string;
        fullscreen?: string;
    }


interface MediaPlayerOptions {
        name?: string;
        autoPlay?: boolean;
        autoRepeat?: boolean;
        forwardSeek?: boolean;
        fullScreen?: boolean;
        media?: MediaPlayerMedia;
        messages?: MediaPlayerMessages;
        mute?: boolean;
        navigatable?: boolean;
        volume?: number;
        end?(e: MediaPlayerEvent): void;
        pause?(e: MediaPlayerEvent): void;
        play?(e: MediaPlayerEvent): void;
        ready?(e: MediaPlayerEvent): void;
        timeChange?(e: MediaPlayerEvent): void;
        volumeChange?(e: MediaPlayerEvent): void;
    }


interface MediaPlayerEvent {
        sender: MediaPlayer;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


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


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


interface MenuAnimation {
        close?: MenuAnimationClose;
        open?: MenuAnimationOpen;
    }


interface MenuOpenOnClick {
        rootMenuItems?: boolean;
        subMenuItems?: boolean;
    }


interface MenuScrollable {
        distance?: number;
    }


interface MenuOptions {
        name?: string;
        animation?: boolean | MenuAnimation;
        closeOnClick?: boolean;
        dataSource?: any|any|kendo.data.HierarchicalDataSource;
        dataTextField?: string;
        dataUrlField?: string;
        dataSpriteCssClassField?: string;
        dataImageUrlField?: string;
        dataContentField?: string;
        direction?: string;
        hoverDelay?: number;
        openOnClick?: boolean | MenuOpenOnClick;
        orientation?: string;
        popupCollision?: string;
        scrollable?: boolean | MenuScrollable;
        close?(e: MenuCloseEvent): void;
        open?(e: MenuOpenEvent): void;
        activate?(e: MenuActivateEvent): void;
        deactivate?(e: MenuDeactivateEvent): void;
        select?(e: MenuSelectEvent): void;
    }


interface MenuEvent {
        sender: Menu;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MenuCloseEvent extends MenuEvent {
        item?: HTMLElement;
    }


interface MenuOpenEvent extends MenuEvent {
        item?: HTMLElement;
    }


interface MenuActivateEvent extends MenuEvent {
        item?: HTMLElement;
    }


interface MenuDeactivateEvent extends MenuEvent {
        item?: HTMLElement;
    }


interface MenuSelectEvent extends MenuEvent {
        item?: HTMLElement;
    }


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


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


interface MultiColumnComboBoxAnimation {
        close?: MultiColumnComboBoxAnimationClose;
        open?: MultiColumnComboBoxAnimationOpen;
    }


interface MultiColumnComboBoxColumn {
        field?: string;
        title?: string;
        template?: string|Function;
        headerTemplate?: string|Function;
        width?: number|string;
    }


interface MultiColumnComboBoxPopup {
        appendTo?: string;
        origin?: string;
        position?: string;
    }


interface MultiColumnComboBoxVirtual {
        itemHeight?: number;
        mapValueTo?: string;
        valueMapper?: Function;
    }


interface MultiColumnComboBoxOptions {
        name?: string;
        animation?: MultiColumnComboBoxAnimation;
        autoBind?: boolean;
        autoWidth?: boolean;
        cascadeFrom?: string;
        cascadeFromField?: string;
        columns?: MultiColumnComboBoxColumn[];
        clearButton?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        delay?: number;
        dropDownWidth?: string|number;
        enable?: boolean;
        enforceMinLength?: boolean;
        filter?: string;
        filterFields?: any;
        fixedGroupTemplate?: string|Function;
        footerTemplate?: string|Function;
        groupTemplate?: string|Function;
        height?: number;
        highlightFirst?: boolean;
        ignoreCase?: boolean;
        index?: number;
        minLength?: number;
        noDataTemplate?: string|Function|boolean;
        placeholder?: string;
        popup?: MultiColumnComboBoxPopup;
        suggest?: boolean;
        syncValueAndText?: boolean;
        headerTemplate?: string|Function;
        template?: string|Function;
        text?: string;
        value?: string;
        valuePrimitive?: boolean;
        virtual?: boolean | MultiColumnComboBoxVirtual;
        change?(e: MultiColumnComboBoxChangeEvent): void;
        close?(e: MultiColumnComboBoxCloseEvent): void;
        dataBound?(e: MultiColumnComboBoxDataBoundEvent): void;
        filtering?(e: MultiColumnComboBoxFilteringEvent): void;
        open?(e: MultiColumnComboBoxOpenEvent): void;
        select?(e: MultiColumnComboBoxSelectEvent): void;
        cascade?(e: MultiColumnComboBoxCascadeEvent): void;
    }


interface MultiColumnComboBoxEvent {
        sender: MultiColumnComboBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MultiColumnComboBoxChangeEvent extends MultiColumnComboBoxEvent {
    }


interface MultiColumnComboBoxCloseEvent extends MultiColumnComboBoxEvent {
    }


interface MultiColumnComboBoxDataBoundEvent extends MultiColumnComboBoxEvent {
    }


interface MultiColumnComboBoxFilteringEvent extends MultiColumnComboBoxEvent {
        filter?: any;
    }


interface MultiColumnComboBoxOpenEvent extends MultiColumnComboBoxEvent {
    }


interface MultiColumnComboBoxSelectEvent extends MultiColumnComboBoxEvent {
        dataItem?: any;
        item?: JQuery;
    }


interface MultiColumnComboBoxCascadeEvent extends MultiColumnComboBoxEvent {
    }


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


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


interface MultiSelectAnimation {
        close?: MultiSelectAnimationClose;
        open?: MultiSelectAnimationOpen;
    }


interface MultiSelectPopup {
        appendTo?: string;
        origin?: string;
        position?: string;
    }


interface MultiSelectVirtual {
        itemHeight?: number;
        mapValueTo?: string;
        valueMapper?: Function;
    }


interface MultiSelectOptions {
        name?: string;
        animation?: boolean | MultiSelectAnimation;
        autoBind?: boolean;
        autoClose?: boolean;
        autoWidth?: boolean;
        clearButton?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        dataTextField?: string;
        dataValueField?: string;
        delay?: number;
        enable?: boolean;
        enforceMinLength?: boolean;
        filter?: string;
        fixedGroupTemplate?: string|Function;
        footerTemplate?: string|Function;
        groupTemplate?: string|Function;
        height?: number;
        highlightFirst?: boolean;
        ignoreCase?: boolean;
        minLength?: number;
        maxSelectedItems?: number;
        noDataTemplate?: string|Function|boolean;
        placeholder?: string;
        popup?: MultiSelectPopup;
        headerTemplate?: string|Function;
        itemTemplate?: string|Function;
        tagTemplate?: string|Function;
        tagMode?: string;
        value?: any;
        valuePrimitive?: boolean;
        virtual?: boolean | MultiSelectVirtual;
        change?(e: MultiSelectChangeEvent): void;
        close?(e: MultiSelectCloseEvent): void;
        dataBound?(e: MultiSelectDataBoundEvent): void;
        filtering?(e: MultiSelectFilteringEvent): void;
        open?(e: MultiSelectOpenEvent): void;
        select?(e: MultiSelectSelectEvent): void;
        deselect?(e: MultiSelectDeselectEvent): void;
    }


interface MultiSelectEvent {
        sender: MultiSelect;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MultiSelectChangeEvent extends MultiSelectEvent {
    }


interface MultiSelectCloseEvent extends MultiSelectEvent {
    }


interface MultiSelectDataBoundEvent extends MultiSelectEvent {
    }


interface MultiSelectFilteringEvent extends MultiSelectEvent {
        filter?: any;
    }


interface MultiSelectOpenEvent extends MultiSelectEvent {
    }


interface MultiSelectSelectEvent extends MultiSelectEvent {
        dataItem?: any;
        item?: JQuery;
    }


interface MultiSelectDeselectEvent extends MultiSelectEvent {
        dataItem?: any;
        item?: JQuery;
    }


interface MultiViewCalendarMessages {
        weekColumnHeader?: string;
    }


interface MultiViewCalendarMonth {
        content?: string;
        weekNumber?: string;
        empty?: string;
    }


interface MultiViewCalendarRange {
        start?: Date;
        end?: Date;
    }


interface MultiViewCalendarOptions {
        name?: string;
        culture?: string;
        dates?: any;
        depth?: string;
        disableDates?: any|Function;
        footer?: string|Function;
        format?: string;
        max?: Date;
        messages?: MultiViewCalendarMessages;
        min?: Date;
        month?: MultiViewCalendarMonth;
        views?: number;
        range?: MultiViewCalendarRange;
        selectable?: string;
        selectDates?: any;
        showViewHeader?: boolean;
        weekNumber?: boolean;
        start?: string;
        value?: Date;
        change?(e: MultiViewCalendarEvent): void;
        navigate?(e: MultiViewCalendarEvent): void;
    }


interface MultiViewCalendarEvent {
        sender: MultiViewCalendar;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface NotificationPosition {
        bottom?: number;
        left?: number;
        pinned?: boolean;
        right?: number;
        top?: number;
    }


interface NotificationTemplate {
        type?: string;
        template?: string;
    }


interface NotificationOptions {
        name?: string;
        allowHideAfter?: number;
        animation?: any|boolean;
        appendTo?: string|JQuery;
        autoHideAfter?: number;
        button?: boolean;
        height?: number|string;
        hideOnClick?: boolean;
        position?: NotificationPosition;
        stacking?: string;
        templates?: NotificationTemplate[];
        title?: string;
        width?: number|string;
        hide?(e: NotificationHideEvent): void;
        show?(e: NotificationShowEvent): void;
    }


interface NotificationEvent {
        sender: Notification;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface NotificationHideEvent extends NotificationEvent {
        element?: JQuery;
    }


interface NotificationShowEvent extends NotificationEvent {
        element?: JQuery;
    }


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


interface NumericTextBoxOptions {
        name?: string;
        culture?: string;
        decimals?: number;
        downArrowText?: string;
        factor?: number;
        format?: string;
        label?: string | Function | NumericTextBoxLabel;
        max?: number;
        min?: number;
        placeholder?: string;
        restrictDecimals?: boolean;
        round?: boolean;
        spinners?: boolean;
        step?: number;
        upArrowText?: string;
        value?: number;
        change?(e: NumericTextBoxChangeEvent): void;
        spin?(e: NumericTextBoxSpinEvent): void;
    }


interface NumericTextBoxEvent {
        sender: NumericTextBox;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface NumericTextBoxChangeEvent extends NumericTextBoxEvent {
    }


interface NumericTextBoxSpinEvent extends NumericTextBoxEvent {
    }


interface PDFViewerDefaultPageSize {
        width?: number;
        height?: number;
    }


interface PDFViewerDplProcessingDownload {
        url?: string;
    }


interface PDFViewerDplProcessingRead {
        url?: string;
        pageField?: string;
        type?: string;
        dataType?: string;
    }


interface PDFViewerDplProcessingUpload {
        url?: string;
        saveField?: string;
    }


interface PDFViewerDplProcessing {
        read?: PDFViewerDplProcessingRead;
        upload?: PDFViewerDplProcessingUpload;
        download?: PDFViewerDplProcessingDownload;
        loadOnDemand?: boolean;
    }


interface PDFViewerMessagesDialogsExportAsDialogLabels {
        fileName?: string;
        saveAsType?: string;
        page?: string;
    }


interface PDFViewerMessagesDialogsExportAsDialog {
        title?: string;
        defaultFileName?: string;
        pdf?: string;
        png?: string;
        svg?: string;
        labels?: PDFViewerMessagesDialogsExportAsDialogLabels;
    }


interface PDFViewerMessagesDialogs {
        exportAsDialog?: PDFViewerMessagesDialogsExportAsDialog;
        okText?: string;
        save?: string;
        cancel?: string;
    }


interface PDFViewerMessagesErrorMessages {
        notSupported?: string;
        parseError?: string;
        notFound?: string;
    }


interface PDFViewerMessagesToolbarPager {
        first?: string;
        previous?: string;
        next?: string;
        last?: string;
        of?: string;
        page?: string;
        pages?: string;
    }


interface PDFViewerMessagesToolbar {
        open?: string;
        exportAs?: string;
        download?: string;
        pager?: PDFViewerMessagesToolbarPager;
    }


interface PDFViewerMessages {
        defaultFileName?: string;
        toolbar?: PDFViewerMessagesToolbar;
        errorMessages?: PDFViewerMessagesErrorMessages;
        dialogs?: PDFViewerMessagesDialogs;
    }


interface PDFViewerPdfjsProcessing {
        file?: any|string;
    }


interface PDFViewerToolbarItem {
        type?: string;
        overflow?: string;
        command?: string;
        name?: string;
        click?: Function;
        toggle?: Function;
        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 PDFViewerToolbar {
        items?: PDFViewerToolbarItem[];
    }


interface PDFViewerView {
        type?: string;
    }


interface PDFViewerOptions {
        name?: string;
        pdfjsProcessing?: PDFViewerPdfjsProcessing;
        dplProcessing?: PDFViewerDplProcessing;
        width?: number|string;
        height?: number|string;
        defaultPageSize?: PDFViewerDefaultPageSize;
        page?: number;
        view?: PDFViewerView;
        toolbar?: boolean | PDFViewerToolbar;
        messages?: PDFViewerMessages;
        render?(e: PDFViewerRenderEvent): void;
        open?(e: PDFViewerOpenEvent): void;
        error?(e: PDFViewerErrorEvent): void;
    }


interface PDFViewerEvent {
        sender: PDFViewer;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PDFViewerRenderEvent extends PDFViewerEvent {
        page?: any;
    }


interface PDFViewerOpenEvent extends PDFViewerEvent {
        file?: any;
    }


interface PDFViewerErrorEvent extends PDFViewerEvent {
        dialog?: kendo.ui.Dialog;
        error?: any;
        message?: string;
    }


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


interface PagerOptions {
        name?: string;
        autoBind?: boolean;
        buttonCount?: number;
        dataSource?: any|kendo.data.DataSource;
        selectTemplate?: string;
        linkTemplate?: string;
        info?: boolean;
        input?: boolean;
        numeric?: boolean;
        pageSizes?: boolean|any;
        previousNext?: boolean;
        refresh?: boolean;
        responsive?: boolean;
        messages?: PagerMessages;
        change?(e: PagerChangeEvent): void;
    }


interface PagerEvent {
        sender: Pager;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PagerChangeEvent extends PagerEvent {
    }


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


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


interface PanelBarAnimation {
        collapse?: PanelBarAnimationCollapse;
        expand?: PanelBarAnimationExpand;
    }


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


interface PanelBarOptions {
        name?: string;
        animation?: boolean | PanelBarAnimation;
        autoBind?: boolean;
        contentUrls?: any;
        dataImageUrlField?: string;
        dataSource?: any|any|kendo.data.HierarchicalDataSource;
        dataSpriteCssClassField?: string;
        dataTextField?: string|any;
        dataUrlField?: string;
        expandMode?: string;
        loadOnDemand?: boolean;
        messages?: PanelBarMessages;
        template?: string|Function;
        activate?(e: PanelBarActivateEvent): void;
        collapse?(e: PanelBarCollapseEvent): void;
        contentLoad?(e: PanelBarContentLoadEvent): void;
        dataBound?(e: PanelBarDataBoundEvent): void;
        error?(e: PanelBarErrorEvent): void;
        expand?(e: PanelBarExpandEvent): void;
        select?(e: PanelBarSelectEvent): void;
    }


interface PanelBarEvent {
        sender: PanelBar;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PanelBarActivateEvent extends PanelBarEvent {
        item?: Element;
    }


interface PanelBarCollapseEvent extends PanelBarEvent {
        item?: Element;
    }


interface PanelBarContentLoadEvent extends PanelBarEvent {
        item?: Element;
        contentElement?: Element;
    }


interface PanelBarDataBoundEvent extends PanelBarEvent {
        node?: JQuery;
    }


interface PanelBarErrorEvent extends PanelBarEvent {
        xhr?: JQueryXHR;
        status?: string;
    }


interface PanelBarExpandEvent extends PanelBarEvent {
        item?: Element;
    }


interface PanelBarSelectEvent extends PanelBarEvent {
        item?: Element;
    }


interface PivotConfiguratorMessagesFieldMenuOperators {
        contains?: string;
        doesnotcontain?: string;
        startswith?: string;
        endswith?: string;
        eq?: string;
        neq?: string;
    }


interface PivotConfiguratorMessagesFieldMenu {
        info?: string;
        sortAscending?: string;
        sortDescending?: string;
        filterFields?: string;
        filter?: string;
        include?: string;
        title?: string;
        clear?: string;
        ok?: string;
        cancel?: string;
        operators?: PivotConfiguratorMessagesFieldMenuOperators;
    }


interface PivotConfiguratorMessages {
        measures?: string;
        columns?: string;
        rows?: string;
        measuresLabel?: string;
        rowsLabel?: string;
        columnsLabel?: string;
        fieldsLabel?: string;
        fieldMenu?: PivotConfiguratorMessagesFieldMenu;
    }


interface PivotConfiguratorSortable {
        allowUnsort?: boolean;
    }


interface PivotConfiguratorOptions {
        name?: string;
        dataSource?: any|kendo.data.PivotDataSource;
        filterable?: boolean;
        sortable?: boolean | PivotConfiguratorSortable;
        height?: number|string;
        messages?: PivotConfiguratorMessages;
    }


interface PivotConfiguratorEvent {
        sender: PivotConfigurator;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


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


interface PivotGridMessagesFieldMenuOperators {
        contains?: string;
        doesnotcontain?: string;
        startswith?: string;
        endswith?: string;
        eq?: string;
        neq?: string;
    }


interface PivotGridMessagesFieldMenu {
        info?: string;
        sortAscending?: string;
        sortDescending?: string;
        filterFields?: string;
        filter?: string;
        include?: string;
        title?: string;
        clear?: string;
        ok?: string;
        cancel?: string;
        operators?: PivotGridMessagesFieldMenuOperators;
    }


interface PivotGridMessages {
        measureFields?: string;
        columnFields?: string;
        rowFields?: string;
        fieldMenu?: PivotGridMessagesFieldMenu;
    }


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


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