interface ChartCategoryAxisItemLabels {
        background?: string;
        border?: ChartCategoryAxisItemLabelsBorder;
        color?: string;
        culture?: string;
        dateFormats?: ChartCategoryAxisItemLabelsDateFormats;
        font?: string;
        format?: string;
        margin?: number | ChartCategoryAxisItemLabelsMargin;
        mirror?: boolean;
        padding?: number | ChartCategoryAxisItemLabelsPadding;
        rotation?: string | number | ChartCategoryAxisItemLabelsRotation;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        visual?: Function;
    }


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


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


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


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


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


interface ChartCategoryAxisItemNotesDataItemIconBorder {
        color?: string;
        width?: number;
    }


interface ChartCategoryAxisItemNotesDataItemIcon {
        background?: string;
        border?: ChartCategoryAxisItemNotesDataItemIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartCategoryAxisItemNotesDataItemLabel {
        background?: string;
        border?: ChartCategoryAxisItemNotesDataItemLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        text?: string;
        position?: string;
    }


interface ChartCategoryAxisItemNotesDataItemLine {
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartCategoryAxisItemNotesDataItem {
        value?: any;
        position?: string;
        icon?: ChartCategoryAxisItemNotesDataItemIcon;
        label?: ChartCategoryAxisItemNotesDataItemLabel;
        line?: ChartCategoryAxisItemNotesDataItemLine;
    }


interface ChartCategoryAxisItemNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartCategoryAxisItemNotesIcon {
        background?: string;
        border?: ChartCategoryAxisItemNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartCategoryAxisItemNotesLabel {
        background?: string;
        border?: ChartCategoryAxisItemNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartCategoryAxisItemNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartCategoryAxisItemNotes {
        position?: string;
        icon?: ChartCategoryAxisItemNotesIcon;
        label?: ChartCategoryAxisItemNotesLabel;
        line?: ChartCategoryAxisItemNotesLine;
        data?: ChartCategoryAxisItemNotesDataItem[];
        visual?: Function;
    }


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


interface ChartCategoryAxisItemSelectMousewheel {
        reverse?: boolean;
        zoom?: string;
    }


interface ChartCategoryAxisItemSelect {
        from?: any;
        max?: any;
        min?: any;
        mousewheel?: ChartCategoryAxisItemSelectMousewheel;
        to?: any;
    }


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


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


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


interface ChartCategoryAxisItemTitle {
        background?: string;
        border?: ChartCategoryAxisItemTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartCategoryAxisItemTitleMargin;
        padding?: ChartCategoryAxisItemTitlePadding;
        position?: string;
        rotation?: number;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartCategoryAxisItem {
        autoBaseUnitSteps?: ChartCategoryAxisItemAutoBaseUnitSteps;
        axisCrossingValue?: any|Date|any;
        background?: string;
        baseUnit?: string;
        baseUnitStep?: any;
        categories?: any;
        color?: string;
        crosshair?: ChartCategoryAxisItemCrosshair;
        field?: string;
        justified?: boolean;
        labels?: ChartCategoryAxisItemLabels;
        line?: ChartCategoryAxisItemLine;
        majorGridLines?: ChartCategoryAxisItemMajorGridLines;
        majorTicks?: ChartCategoryAxisItemMajorTicks;
        max?: any;
        maxDateGroups?: number;
        maxDivisions?: number;
        min?: any;
        minorGridLines?: ChartCategoryAxisItemMinorGridLines;
        minorTicks?: ChartCategoryAxisItemMinorTicks;
        name?: string;
        pane?: string;
        plotBands?: ChartCategoryAxisItemPlotBand[];
        reverse?: boolean;
        roundToBaseUnit?: boolean;
        select?: ChartCategoryAxisItemSelect;
        startAngle?: number;
        title?: ChartCategoryAxisItemTitle;
        type?: string;
        visible?: boolean;
        weekStartDay?: number;
        notes?: ChartCategoryAxisItemNotes;
    }


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


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


interface ChartChartArea {
        background?: string;
        border?: ChartChartAreaBorder;
        height?: number;
        margin?: number | ChartChartAreaMargin;
        opacity?: number;
        width?: number;
    }


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


interface ChartLegendInactiveItemsLabels {
        color?: string;
        font?: string;
        template?: string|Function;
    }


interface ChartLegendInactiveItems {
        labels?: ChartLegendInactiveItemsLabels;
    }


interface ChartLegendItem {
        cursor?: string;
        visual?: Function;
    }


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


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


interface ChartLegendLabels {
        color?: string;
        font?: string;
        margin?: number | ChartLegendLabelsMargin;
        padding?: ChartLegendLabelsPadding;
        template?: string|Function;
    }


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


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


interface ChartLegend {
        align?: string;
        background?: string;
        border?: ChartLegendBorder;
        height?: number;
        inactiveItems?: ChartLegendInactiveItems;
        item?: ChartLegendItem;
        labels?: ChartLegendLabels;
        margin?: number | ChartLegendMargin;
        offsetX?: number;
        offsetY?: number;
        orientation?: string;
        padding?: number | ChartLegendPadding;
        position?: string;
        reverse?: boolean;
        spacing?: number;
        visible?: boolean;
        width?: number;
    }


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


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


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


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


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


interface ChartPaneTitle {
        background?: string;
        border?: ChartPaneTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartPaneTitleMargin;
        position?: string;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartPane {
        background?: string;
        border?: ChartPaneBorder;
        clip?: boolean;
        height?: number;
        margin?: number | ChartPaneMargin;
        name?: string;
        padding?: ChartPanePadding;
        title?: string | ChartPaneTitle;
    }


interface ChartPannable {
        key?: string;
        lock?: string;
    }


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


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


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


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


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


interface ChartPlotArea {
        background?: string;
        border?: ChartPlotAreaBorder;
        margin?: number| ChartPlotAreaMargin;
        opacity?: number;
        padding?: number | ChartPlotAreaPadding;
    }


interface ChartSeriesItemBorder {
        color?: string|Function;
        dashType?: string|Function;
        opacity?: number|Function;
        width?: number|Function;
    }


interface ChartSeriesItemConnectors {
        color?: string|Function;
        padding?: number;
        width?: number;
    }


interface ChartSeriesItemErrorBarsLine {
        width?: number;
        dashType?: string;
    }


interface ChartSeriesItemErrorBars {
        value?: string|number|any|Function;
        visual?: Function;
        xValue?: string|number|any|Function;
        yValue?: string|number|any|Function;
        endCaps?: boolean;
        color?: string;
        line?: ChartSeriesItemErrorBarsLine;
    }


interface ChartSeriesItemExtremesBorder {
        color?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemExtremes {
        background?: string|Function;
        border?: Function | ChartSeriesItemExtremesBorder;
        size?: number|Function;
        type?: string|Function;
        rotation?: number|Function;
    }


interface ChartSeriesItemHighlightBorder {
        color?: string;
        opacity?: number;
        width?: number;
    }


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


interface ChartSeriesItemHighlight {
        border?: ChartSeriesItemHighlightBorder;
        color?: string;
        inactiveOpacity?: number;
        line?: ChartSeriesItemHighlightLine;
        opacity?: number;
        toggle?: Function;
        visible?: boolean;
        visual?: Function;
    }


interface ChartSeriesItemLabelsBorder {
        color?: string|Function;
        dashType?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemLabelsFromBorder {
        color?: string|Function;
        dashType?: string|Function;
        width?: number|Function;
    }


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


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


interface ChartSeriesItemLabelsFrom {
        background?: string|Function;
        border?: ChartSeriesItemLabelsFromBorder;
        color?: string|Function;
        font?: string|Function;
        format?: string|Function;
        margin?: number | ChartSeriesItemLabelsFromMargin;
        padding?: number | ChartSeriesItemLabelsFromPadding;
        position?: string|Function;
        template?: string|Function;
        visible?: boolean|Function;
    }


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


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


interface ChartSeriesItemLabelsToBorder {
        color?: string|Function;
        dashType?: string|Function;
        width?: number|Function;
    }


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


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


interface ChartSeriesItemLabelsTo {
        background?: string|Function;
        border?: ChartSeriesItemLabelsToBorder;
        color?: string|Function;
        font?: string|Function;
        format?: string|Function;
        margin?: number | ChartSeriesItemLabelsToMargin;
        padding?: number | ChartSeriesItemLabelsToPadding;
        position?: string|Function;
        template?: string|Function;
        visible?: boolean|Function;
    }


interface ChartSeriesItemLabels {
        align?: string;
        background?: string|Function;
        border?: ChartSeriesItemLabelsBorder;
        color?: string|Function;
        distance?: number;
        font?: string|Function;
        format?: string|Function;
        margin?: number | ChartSeriesItemLabelsMargin;
        padding?: number | ChartSeriesItemLabelsPadding;
        position?: string|Function;
        rotation?: string|number;
        template?: string|Function;
        visible?: boolean|Function;
        visual?: Function;
        from?: ChartSeriesItemLabelsFrom;
        to?: ChartSeriesItemLabelsTo;
    }


interface ChartSeriesItemLine {
        color?: string;
        opacity?: number;
        width?: number;
        style?: string;
    }


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


interface ChartSeriesItemMarkersBorder {
        color?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemMarkersFromBorder {
        color?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemMarkersFrom {
        background?: string|Function;
        border?: Function | ChartSeriesItemMarkersFromBorder;
        size?: number|Function;
        type?: string|Function;
        visible?: boolean|Function;
        visual?: Function;
        rotation?: number|Function;
    }


interface ChartSeriesItemMarkersToBorder {
        color?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemMarkersTo {
        background?: string|Function;
        border?: Function | ChartSeriesItemMarkersToBorder;
        size?: number|Function;
        type?: string|Function;
        visible?: boolean|Function;
        visual?: Function;
        rotation?: number|Function;
    }


interface ChartSeriesItemMarkers {
        background?: string|Function;
        border?: Function | ChartSeriesItemMarkersBorder;
        from?: ChartSeriesItemMarkersFrom;
        size?: number|Function;
        to?: ChartSeriesItemMarkersTo;
        type?: string|Function;
        visible?: boolean|Function;
        visual?: Function;
        rotation?: number|Function;
    }


interface ChartSeriesItemNegativeValues {
        color?: string;
        visible?: boolean;
    }


interface ChartSeriesItemNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartSeriesItemNotesIcon {
        background?: string;
        border?: ChartSeriesItemNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartSeriesItemNotesLabel {
        background?: string;
        border?: ChartSeriesItemNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartSeriesItemNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartSeriesItemNotes {
        position?: string;
        icon?: ChartSeriesItemNotesIcon;
        label?: ChartSeriesItemNotesLabel;
        line?: ChartSeriesItemNotesLine;
        visual?: Function;
    }


interface ChartSeriesItemOutliersBorder {
        color?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemOutliers {
        background?: string|Function;
        border?: Function | ChartSeriesItemOutliersBorder;
        size?: number|Function;
        type?: string|Function;
        rotation?: number|Function;
    }


interface ChartSeriesItemOverlay {
        gradient?: string;
    }


interface ChartSeriesItemStack {
        type?: string;
        group?: string;
    }


interface ChartSeriesItemTargetBorder {
        color?: string|Function;
        dashType?: string|Function;
        width?: number|Function;
    }


interface ChartSeriesItemTargetLine {
        width?: number|Function;
    }


interface ChartSeriesItemTarget {
        border?: Function | ChartSeriesItemTargetBorder;
        color?: string|Function;
        line?: ChartSeriesItemTargetLine;
    }


interface ChartSeriesItemTooltipBorder {
        color?: string;
        width?: number;
    }


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


interface ChartSeriesItemTooltip {
        background?: string;
        border?: ChartSeriesItemTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartSeriesItemTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartSeriesItem {
        aggregate?: string|Function;
        axis?: string;
        border?: ChartSeriesItemBorder;
        categoryAxis?: string;
        categoryField?: string;
        closeField?: string;
        color?: string|Function;
        colorField?: string;
        connectors?: ChartSeriesItemConnectors;
        currentField?: string;
        dashType?: string;
        data?: any;
        downColor?: string|Function;
        downColorField?: string;
        segmentSpacing?: number;
        summaryField?: string;
        neckRatio?: number;
        dynamicSlope?: boolean;
        dynamicHeight?: boolean;
        errorBars?: ChartSeriesItemErrorBars;
        errorLowField?: string;
        errorHighField?: string;
        xErrorLowField?: string;
        xErrorHighField?: string;
        yErrorLowField?: string;
        yErrorHighField?: string;
        explodeField?: string;
        field?: string;
        fromField?: string;
        toField?: string;
        noteTextField?: string;
        lowerField?: string;
        q1Field?: string;
        medianField?: string;
        q3Field?: string;
        upperField?: string;
        meanField?: string;
        outliersField?: string;
        gap?: number;
        highField?: string;
        highlight?: ChartSeriesItemHighlight;
        holeSize?: number;
        labels?: ChartSeriesItemLabels;
        line?: string | ChartSeriesItemLine;
        lowField?: string;
        margin?: number | ChartSeriesItemMargin;
        markers?: ChartSeriesItemMarkers;
        outliers?: ChartSeriesItemOutliers;
        extremes?: ChartSeriesItemExtremes;
        maxSize?: number;
        minSize?: number;
        missingValues?: string;
        style?: string;
        name?: string;
        negativeColor?: string;
        negativeValues?: ChartSeriesItemNegativeValues;
        opacity?: number;
        openField?: string;
        overlay?: ChartSeriesItemOverlay;
        padding?: number;
        size?: number;
        sizeField?: string;
        spacing?: number;
        stack?: boolean | string | ChartSeriesItemStack;
        startAngle?: number;
        target?: ChartSeriesItemTarget;
        targetField?: string;
        tooltip?: ChartSeriesItemTooltip;
        type?: string;
        visible?: boolean;
        visibleInLegend?: boolean;
        visibleInLegendField?: string;
        visual?: Function;
        width?: number;
        xAxis?: string;
        xField?: string;
        yAxis?: string;
        yField?: string;
        notes?: ChartSeriesItemNotes;
        zIndex?: number;
    }


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


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


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


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


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


interface ChartSeriesDefaultsLabelsFrom {
        background?: string;
        border?: ChartSeriesDefaultsLabelsFromBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | ChartSeriesDefaultsLabelsFromMargin;
        padding?: number | ChartSeriesDefaultsLabelsFromPadding;
        template?: string|Function;
        visible?: boolean;
    }


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


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


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


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


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


interface ChartSeriesDefaultsLabelsTo {
        background?: string;
        border?: ChartSeriesDefaultsLabelsToBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | ChartSeriesDefaultsLabelsToMargin;
        padding?: number | ChartSeriesDefaultsLabelsToPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartSeriesDefaultsLabels {
        background?: string;
        border?: ChartSeriesDefaultsLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | ChartSeriesDefaultsLabelsMargin;
        padding?: number | ChartSeriesDefaultsLabelsPadding;
        rotation?: string|number;
        template?: string|Function;
        position?: string|Function;
        visible?: boolean;
        visual?: Function;
        from?: ChartSeriesDefaultsLabelsFrom;
        to?: ChartSeriesDefaultsLabelsTo;
    }


interface ChartSeriesDefaultsNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartSeriesDefaultsNotesIcon {
        background?: string;
        border?: ChartSeriesDefaultsNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartSeriesDefaultsNotesLabel {
        background?: string;
        border?: ChartSeriesDefaultsNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartSeriesDefaultsNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartSeriesDefaultsNotes {
        icon?: ChartSeriesDefaultsNotesIcon;
        label?: ChartSeriesDefaultsNotesLabel;
        line?: ChartSeriesDefaultsNotesLine;
        visual?: Function;
    }


interface ChartSeriesDefaultsOverlay {
        gradient?: string;
    }


interface ChartSeriesDefaultsStack {
        type?: string;
    }


interface ChartSeriesDefaultsTooltipBorder {
        color?: string;
        width?: number;
    }


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


interface ChartSeriesDefaultsTooltip {
        background?: string;
        border?: ChartSeriesDefaultsTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartSeriesDefaultsTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartSeriesDefaults {
        area?: any;
        bar?: any;
        border?: ChartSeriesDefaultsBorder;
        bubble?: any;
        candlestick?: any;
        column?: any;
        donut?: any;
        gap?: number;
        labels?: ChartSeriesDefaultsLabels;
        line?: any;
        ohlc?: any;
        overlay?: ChartSeriesDefaultsOverlay;
        pie?: any;
        rangeArea?: any;
        scatter?: any;
        scatterLine?: any;
        spacing?: number;
        stack?: boolean | ChartSeriesDefaultsStack;
        type?: string;
        tooltip?: ChartSeriesDefaultsTooltip;
        verticalArea?: any;
        verticalLine?: any;
        verticalRangeArea?: any;
        visual?: Function;
        notes?: ChartSeriesDefaultsNotes;
    }


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


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


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


interface ChartTitle {
        align?: string;
        background?: string;
        border?: ChartTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartTitleMargin;
        padding?: number | ChartTitlePadding;
        position?: string;
        text?: string;
        visible?: boolean;
    }


interface ChartTooltipBorder {
        color?: string;
        width?: number;
    }


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


interface ChartTooltip {
        background?: string;
        border?: ChartTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        opacity?: number;
        padding?: ChartTooltipPadding;
        shared?: boolean;
        sharedTemplate?: string|Function;
        template?: string|Function;
        visible?: boolean;
    }


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


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


interface ChartValueAxisItemCrosshairTooltip {
        background?: string;
        border?: ChartValueAxisItemCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartValueAxisItemCrosshairTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartValueAxisItemCrosshair {
        color?: string;
        dashType?: string;
        opacity?: number;
        tooltip?: ChartValueAxisItemCrosshairTooltip;
        visible?: boolean;
        width?: number;
    }


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


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


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


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


interface ChartValueAxisItemLabels {
        background?: string;
        border?: ChartValueAxisItemLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | ChartValueAxisItemLabelsMargin;
        mirror?: boolean;
        padding?: number | ChartValueAxisItemLabelsPadding;
        rotation?: string | number | ChartValueAxisItemLabelsRotation;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        visual?: Function;
    }


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


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


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


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


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


interface ChartValueAxisItemNotesDataItemIconBorder {
        color?: string;
        width?: number;
    }


interface ChartValueAxisItemNotesDataItemIcon {
        background?: string;
        border?: ChartValueAxisItemNotesDataItemIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartValueAxisItemNotesDataItemLabel {
        background?: string;
        border?: ChartValueAxisItemNotesDataItemLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        text?: string;
        position?: string;
    }


interface ChartValueAxisItemNotesDataItemLine {
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartValueAxisItemNotesDataItem {
        value?: any;
        position?: string;
        icon?: ChartValueAxisItemNotesDataItemIcon;
        label?: ChartValueAxisItemNotesDataItemLabel;
        line?: ChartValueAxisItemNotesDataItemLine;
    }


interface ChartValueAxisItemNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartValueAxisItemNotesIcon {
        background?: string;
        border?: ChartValueAxisItemNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartValueAxisItemNotesLabel {
        background?: string;
        border?: ChartValueAxisItemNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartValueAxisItemNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartValueAxisItemNotes {
        position?: string;
        icon?: ChartValueAxisItemNotesIcon;
        label?: ChartValueAxisItemNotesLabel;
        line?: ChartValueAxisItemNotesLine;
        data?: ChartValueAxisItemNotesDataItem[];
        visual?: Function;
    }


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


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


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


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


interface ChartValueAxisItemTitle {
        background?: string;
        border?: ChartValueAxisItemTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartValueAxisItemTitleMargin;
        padding?: number | ChartValueAxisItemTitlePadding;
        position?: string;
        rotation?: number;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartValueAxisItem {
        axisCrossingValue?: any|Date|any;
        background?: string;
        color?: string;
        crosshair?: ChartValueAxisItemCrosshair;
        labels?: ChartValueAxisItemLabels;
        line?: ChartValueAxisItemLine;
        majorGridLines?: ChartValueAxisItemMajorGridLines;
        majorUnit?: number;
        max?: number;
        min?: number;
        minorGridLines?: ChartValueAxisItemMinorGridLines;
        majorTicks?: ChartValueAxisItemMajorTicks;
        minorTicks?: ChartValueAxisItemMinorTicks;
        minorUnit?: number;
        name?: string;
        narrowRange?: boolean;
        pane?: string;
        plotBands?: ChartValueAxisItemPlotBand[];
        reverse?: boolean;
        title?: ChartValueAxisItemTitle;
        type?: string;
        visible?: boolean;
        notes?: ChartValueAxisItemNotes;
    }


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


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


interface ChartXAxisItemCrosshairTooltip {
        background?: string;
        border?: ChartXAxisItemCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartXAxisItemCrosshairTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartXAxisItemCrosshair {
        color?: string;
        dashType?: string;
        opacity?: number;
        tooltip?: ChartXAxisItemCrosshairTooltip;
        visible?: boolean;
        width?: number;
    }


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


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


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


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


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


interface ChartXAxisItemLabels {
        background?: string;
        border?: ChartXAxisItemLabelsBorder;
        color?: string;
        culture?: string;
        dateFormats?: ChartXAxisItemLabelsDateFormats;
        font?: string;
        format?: string;
        margin?: number | ChartXAxisItemLabelsMargin;
        mirror?: boolean;
        padding?: number | ChartXAxisItemLabelsPadding;
        rotation?: string | number | ChartXAxisItemLabelsRotation;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        visual?: Function;
    }


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


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


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


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


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


interface ChartXAxisItemNotesDataItemIconBorder {
        color?: string;
        width?: number;
    }


interface ChartXAxisItemNotesDataItemIcon {
        background?: string;
        border?: ChartXAxisItemNotesDataItemIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartXAxisItemNotesDataItemLabel {
        background?: string;
        border?: ChartXAxisItemNotesDataItemLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        text?: string;
        position?: string;
    }


interface ChartXAxisItemNotesDataItemLine {
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartXAxisItemNotesDataItem {
        value?: any;
        position?: string;
        icon?: ChartXAxisItemNotesDataItemIcon;
        label?: ChartXAxisItemNotesDataItemLabel;
        line?: ChartXAxisItemNotesDataItemLine;
    }


interface ChartXAxisItemNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartXAxisItemNotesIcon {
        background?: string;
        border?: ChartXAxisItemNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartXAxisItemNotesLabel {
        background?: string;
        border?: ChartXAxisItemNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartXAxisItemNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartXAxisItemNotes {
        position?: string;
        icon?: ChartXAxisItemNotesIcon;
        label?: ChartXAxisItemNotesLabel;
        line?: ChartXAxisItemNotesLine;
        data?: ChartXAxisItemNotesDataItem[];
        visual?: Function;
    }


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


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


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


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


interface ChartXAxisItemTitle {
        background?: string;
        border?: ChartXAxisItemTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartXAxisItemTitleMargin;
        padding?: number | ChartXAxisItemTitlePadding;
        position?: string;
        rotation?: number;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartXAxisItem {
        axisCrossingValue?: any|Date|any;
        background?: string;
        baseUnit?: string;
        color?: string;
        crosshair?: ChartXAxisItemCrosshair;
        labels?: ChartXAxisItemLabels;
        line?: ChartXAxisItemLine;
        majorGridLines?: ChartXAxisItemMajorGridLines;
        minorGridLines?: ChartXAxisItemMinorGridLines;
        minorTicks?: ChartXAxisItemMinorTicks;
        majorTicks?: ChartXAxisItemMajorTicks;
        majorUnit?: number;
        max?: any;
        min?: any;
        minorUnit?: number;
        name?: string;
        narrowRange?: boolean;
        pane?: string;
        plotBands?: ChartXAxisItemPlotBand[];
        reverse?: boolean;
        startAngle?: number;
        title?: ChartXAxisItemTitle;
        type?: string;
        visible?: boolean;
        notes?: ChartXAxisItemNotes;
    }


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


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


interface ChartYAxisItemCrosshairTooltip {
        background?: string;
        border?: ChartYAxisItemCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: ChartYAxisItemCrosshairTooltipPadding;
        template?: string|Function;
        visible?: boolean;
    }


interface ChartYAxisItemCrosshair {
        color?: string;
        dashType?: string;
        opacity?: number;
        tooltip?: ChartYAxisItemCrosshairTooltip;
        visible?: boolean;
        width?: number;
    }


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


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


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


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


interface ChartYAxisItemLabelsRotation {
        align?: string;
        angle?: number;
    }


interface ChartYAxisItemLabels {
        background?: string;
        border?: ChartYAxisItemLabelsBorder;
        color?: string;
        culture?: string;
        dateFormats?: ChartYAxisItemLabelsDateFormats;
        font?: string;
        format?: string;
        margin?: number | ChartYAxisItemLabelsMargin;
        mirror?: boolean;
        padding?: number | ChartYAxisItemLabelsPadding;
        rotation?: number |ChartYAxisItemLabelsRotation;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        visual?: Function;
    }


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


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


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


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


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


interface ChartYAxisItemNotesDataItemIconBorder {
        color?: string;
        width?: number;
    }


interface ChartYAxisItemNotesDataItemIcon {
        background?: string;
        border?: ChartYAxisItemNotesDataItemIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartYAxisItemNotesDataItemLabel {
        background?: string;
        border?: ChartYAxisItemNotesDataItemLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        text?: string;
        position?: string;
    }


interface ChartYAxisItemNotesDataItemLine {
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartYAxisItemNotesDataItem {
        value?: any;
        position?: string;
        icon?: ChartYAxisItemNotesDataItemIcon;
        label?: ChartYAxisItemNotesDataItemLabel;
        line?: ChartYAxisItemNotesDataItemLine;
    }


interface ChartYAxisItemNotesIconBorder {
        color?: string;
        width?: number;
    }


interface ChartYAxisItemNotesIcon {
        background?: string;
        border?: ChartYAxisItemNotesIconBorder;
        size?: number;
        type?: string;
        visible?: boolean;
    }


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


interface ChartYAxisItemNotesLabel {
        background?: string;
        border?: ChartYAxisItemNotesLabelBorder;
        color?: string;
        font?: string;
        template?: string|Function;
        visible?: boolean;
        rotation?: number;
        format?: string;
        position?: string;
    }


interface ChartYAxisItemNotesLine {
        dashType?: string;
        width?: number;
        color?: string;
        length?: number;
    }


interface ChartYAxisItemNotes {
        position?: string;
        icon?: ChartYAxisItemNotesIcon;
        label?: ChartYAxisItemNotesLabel;
        line?: ChartYAxisItemNotesLine;
        data?: ChartYAxisItemNotesDataItem[];
        visual?: Function;
    }


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


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


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


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


interface ChartYAxisItemTitle {
        background?: string;
        border?: ChartYAxisItemTitleBorder;
        color?: string;
        font?: string;
        margin?: number | ChartYAxisItemTitleMargin;
        padding?: number | ChartYAxisItemTitlePadding;
        position?: string;
        rotation?: number;
        text?: string;
        visible?: boolean;
        visual?: Function;
    }


interface ChartYAxisItem {
        axisCrossingValue?: any|Date|any;
        background?: string;
        baseUnit?: string;
        color?: string;
        crosshair?: ChartYAxisItemCrosshair;
        labels?: ChartYAxisItemLabels;
        line?: ChartYAxisItemLine;
        majorGridLines?: ChartYAxisItemMajorGridLines;
        minorGridLines?: ChartYAxisItemMinorGridLines;
        minorTicks?: ChartYAxisItemMinorTicks;
        majorTicks?: ChartYAxisItemMajorTicks;
        majorUnit?: number;
        max?: any;
        min?: any;
        minorUnit?: number;
        name?: string;
        narrowRange?: boolean;
        pane?: string;
        plotBands?: ChartYAxisItemPlotBand[];
        reverse?: boolean;
        title?: ChartYAxisItemTitle;
        type?: string;
        visible?: boolean;
        notes?: ChartYAxisItemNotes;
    }


interface ChartZoomableMousewheel {
        lock?: string;
    }


interface ChartZoomableSelection {
        key?: string;
        lock?: string;
    }


interface ChartZoomable {
        mousewheel?: boolean | ChartZoomableMousewheel;
        selection?: boolean | ChartZoomableSelection;
    }


interface ChartExportImageOptions {
        width?: string;
        height?: string;
        cors?: string;
    }


interface ChartExportSVGOptions {
        raw?: boolean;
    }


interface ChartToggleHighlightOptions {
        series?: string;
        category?: string;
    }


interface ChartSeriesClickEventSeries {
        type?: string;
        name?: string;
        data?: any;
        field?: string;
    }


interface ChartSeriesHoverEventSeries {
        type?: string;
        name?: string;
        data?: any;
        field?: string;
    }


interface ChartSeriesOverEventSeries {
        type?: string;
        name?: string;
        data?: any;
    }


interface ChartSeriesLeaveEventSeries {
        type?: string;
        name?: string;
        data?: any;
    }


interface ChartOptions {
        name?: string;
        autoBind?: boolean;
        axisDefaults?: ChartAxisDefaults;
        categoryAxis?: ChartCategoryAxisItem | ChartCategoryAxisItem[];
        chartArea?: ChartChartArea;
        dataSource?: any|any|kendo.data.DataSource;
        legend?: ChartLegend;
        panes?: ChartPane[];
        pannable?: boolean | ChartPannable;
        pdf?: ChartPdf;
        persistSeriesVisibility?: boolean;
        plotArea?: ChartPlotArea;
        renderAs?: string;
        series?: ChartSeriesItem[];
        seriesColors?: any;
        seriesDefaults?: ChartSeriesDefaults;
        theme?: string;
        title?: string | ChartTitle;
        tooltip?: ChartTooltip;
        transitions?: boolean;
        valueAxis?: ChartValueAxisItem | ChartValueAxisItem[];
        xAxis?: ChartXAxisItem | ChartXAxisItem[];
        yAxis?: ChartYAxisItem | ChartYAxisItem[];
        zoomable?: boolean | ChartZoomable;
        axisLabelClick?(e: ChartAxisLabelClickEvent): void;
        dataBound?(e: ChartDataBoundEvent): void;
        drag?(e: ChartDragEvent): void;
        dragEnd?(e: ChartDragEndEvent): void;
        dragStart?(e: ChartDragStartEvent): void;
        legendItemClick?(e: ChartLegendItemClickEvent): void;
        legendItemHover?(e: ChartLegendItemHoverEvent): void;
        legendItemLeave?(e: ChartLegendItemLeaveEvent): void;
        noteClick?(e: ChartNoteClickEvent): void;
        noteHover?(e: ChartNoteHoverEvent): void;
        noteLeave?(e: ChartNoteLeaveEvent): void;
        paneRender?(e: ChartPaneRenderEvent): void;
        plotAreaClick?(e: ChartPlotAreaClickEvent): void;
        plotAreaHover?(e: ChartPlotAreaHoverEvent): void;
        plotAreaLeave?(e: ChartPlotAreaLeaveEvent): void;
        render?(e: ChartRenderEvent): void;
        select?(e: ChartSelectEvent): void;
        selectEnd?(e: ChartSelectEndEvent): void;
        selectStart?(e: ChartSelectStartEvent): void;
        seriesClick?(e: ChartSeriesClickEvent): void;
        seriesHover?(e: ChartSeriesHoverEvent): void;
        seriesOver?(e: ChartSeriesOverEvent): void;
        seriesLeave?(e: ChartSeriesLeaveEvent): void;
        zoom?(e: ChartZoomEvent): void;
        zoomEnd?(e: ChartZoomEndEvent): void;
        zoomStart?(e: ChartZoomStartEvent): void;
    }


interface ChartEvent {
        sender: Chart;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface ChartAxisLabelClickEvent extends ChartEvent {
        axis?: any;
        dataItem?: any;
        element?: any;
        index?: any;
        text?: string;
        value?: any;
    }


interface ChartDataBoundEvent extends ChartEvent {
    }


interface ChartDragEvent extends ChartEvent {
        axisRanges?: any;
        originalEvent?: any;
    }


interface ChartDragEndEvent extends ChartEvent {
        axisRanges?: any;
        originalEvent?: any;
    }


interface ChartDragStartEvent extends ChartEvent {
        axisRanges?: any;
        originalEvent?: any;
    }


interface ChartLegendItemClickEvent extends ChartEvent {
        pointIndex?: number;
        series?: any;
        seriesIndex?: number;
        text?: string;
        element?: any;
    }


interface ChartLegendItemHoverEvent extends ChartEvent {
        element?: any;
        pointIndex?: number;
        series?: any;
        seriesIndex?: number;
        text?: string;
    }


interface ChartLegendItemLeaveEvent extends ChartEvent {
        element?: any;
        pointIndex?: number;
        series?: any;
        seriesIndex?: number;
        text?: string;
    }


interface ChartNoteClickEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        series?: any;
        value?: any;
        visual?: any;
    }


interface ChartNoteHoverEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        series?: any;
        value?: any;
        visual?: any;
    }


interface ChartNoteLeaveEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        series?: any;
        value?: any;
        visual?: any;
    }


interface ChartPaneRenderEvent extends ChartEvent {
        pane?: kendo.dataviz.ChartPane;
        name?: string;
        index?: number;
    }


interface ChartPlotAreaClickEvent extends ChartEvent {
        category?: any;
        element?: any;
        originalEvent?: any;
        value?: any;
        x?: any;
        y?: any;
    }


interface ChartPlotAreaHoverEvent extends ChartEvent {
        category?: any;
        element?: any;
        originalEvent?: any;
        value?: any;
        x?: any;
        y?: any;
    }


interface ChartPlotAreaLeaveEvent extends ChartEvent {
    }


interface ChartRenderEvent extends ChartEvent {
    }


interface ChartSelectEvent extends ChartEvent {
        axis?: any;
        from?: any;
        to?: any;
    }


interface ChartSelectEndEvent extends ChartEvent {
        axis?: any;
        from?: any;
        to?: any;
    }


interface ChartSelectStartEvent extends ChartEvent {
        axis?: any;
        from?: any;
        to?: any;
    }


interface ChartSeriesClickEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        originalEvent?: any;
        percentage?: any;
        series?: ChartSeriesClickEventSeries;
        stackValue?: any;
        value?: any;
    }


interface ChartSeriesHoverEvent extends ChartEvent {
        category?: any;
        categoryPoints?: any;
        dataItem?: any;
        element?: any;
        originalEvent?: any;
        percentage?: any;
        series?: ChartSeriesHoverEventSeries;
        stackValue?: any;
        value?: any;
    }


interface ChartSeriesOverEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        originalEvent?: any;
        percentage?: any;
        series?: ChartSeriesOverEventSeries;
        stackValue?: any;
        value?: any;
    }


interface ChartSeriesLeaveEvent extends ChartEvent {
        category?: any;
        dataItem?: any;
        element?: any;
        originalEvent?: any;
        percentage?: any;
        series?: ChartSeriesLeaveEventSeries;
        stackValue?: any;
        value?: any;
    }


interface ChartZoomEvent extends ChartEvent {
        axisRanges?: any;
        delta?: number;
        originalEvent?: any;
    }


interface ChartZoomEndEvent extends ChartEvent {
        axisRanges?: any;
        originalEvent?: any;
    }


interface ChartZoomStartEvent extends ChartEvent {
        axisRanges?: any;
        originalEvent?: any;
    }


interface DiagramConnectionDefaultsContent {
        color?: string;
        fontFamily?: string;
        fontSize?: number;
        fontStyle?: string;
        fontWeight?: string;
        template?: string|Function;
        text?: string;
        visual?: Function;
    }


interface DiagramConnectionDefaultsEditableTool {
        name?: string;
    }


interface DiagramConnectionDefaultsEditable {
        drag?: boolean;
        remove?: boolean;
        tools?: DiagramConnectionDefaultsEditableTool[];
    }


interface DiagramConnectionDefaultsEndCapFill {
        color?: string;
    }


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


interface DiagramConnectionDefaultsEndCap {
        fill?: string | DiagramConnectionDefaultsEndCapFill;
        stroke?: string | DiagramConnectionDefaultsEndCapStroke;
        type?: string;
    }


interface DiagramConnectionDefaultsHoverStroke {
        color?: string;
    }


interface DiagramConnectionDefaultsHover {
        stroke?: DiagramConnectionDefaultsHoverStroke;
    }


interface DiagramConnectionDefaultsSelectionHandlesFill {
        color?: string;
    }


interface DiagramConnectionDefaultsSelectionHandlesStroke {
        color?: string;
    }


interface DiagramConnectionDefaultsSelectionHandles {
        fill?: string | DiagramConnectionDefaultsSelectionHandlesFill;
        stroke?: DiagramConnectionDefaultsSelectionHandlesStroke;
        width?: number;
        height?: number;
    }


interface DiagramConnectionDefaultsSelection {
        handles?: DiagramConnectionDefaultsSelectionHandles;
    }


interface DiagramConnectionDefaultsStartCapFill {
        color?: string;
    }


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


interface DiagramConnectionDefaultsStartCap {
        fill?: string | DiagramConnectionDefaultsStartCapFill;
        stroke?: string | DiagramConnectionDefaultsStartCapStroke;
        type?: string;
    }


interface DiagramConnectionDefaultsStroke {
        color?: string;
        width?: number;
    }


interface DiagramConnectionDefaults {
        content?: DiagramConnectionDefaultsContent;
        editable?: boolean | DiagramConnectionDefaultsEditable;
        endCap?: string | DiagramConnectionDefaultsEndCap;
        fromConnector?: string;
        hover?: DiagramConnectionDefaultsHover;
        selectable?: boolean;
        selection?: DiagramConnectionDefaultsSelection;
        startCap?: string | DiagramConnectionDefaultsStartCap;
        stroke?: DiagramConnectionDefaultsStroke;
        toConnector?: string;
        type?: string;
    }


interface DiagramConnectionContent {
        color?: string;
        fontFamily?: string;
        fontSize?: number;
        fontStyle?: string;
        fontWeight?: string;
        template?: string|Function;
        text?: string;
        visual?: Function;
    }


interface DiagramConnectionEditableTool {
        name?: string;
    }


interface DiagramConnectionEditable {
        tools?: DiagramConnectionEditableTool[];
    }


interface DiagramConnectionEndCapFill {
        color?: string;
    }


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


interface DiagramConnectionEndCap {
        fill?: string | DiagramConnectionEndCapFill;
        stroke?: string | DiagramConnectionEndCapStroke;
        type?: string;
    }


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


interface DiagramConnectionHoverStroke {
        color?: string;
    }


interface DiagramConnectionHover {
        stroke?: DiagramConnectionHoverStroke;
    }


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


interface DiagramConnectionSelectionHandlesFill {
        color?: string;
    }


interface DiagramConnectionSelectionHandlesStroke {
        color?: string;
    }


interface DiagramConnectionSelectionHandles {
        fill?: string | DiagramConnectionSelectionHandlesFill;
        stroke?: DiagramConnectionSelectionHandlesStroke;
        width?: number;
        height?: number;
    }


interface DiagramConnectionSelection {
        handles?: DiagramConnectionSelectionHandles;
    }


interface DiagramConnectionStartCapFill {
        color?: string;
    }


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


interface DiagramConnectionStartCap {
        fill?: string | DiagramConnectionStartCapFill;
        stroke?: string | DiagramConnectionStartCapStroke;
        type?: string;
    }


interface DiagramConnectionStroke {
        color?: string;
        width?: number;
    }


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


interface DiagramConnection {
        content?: DiagramConnectionContent;
        editable?: boolean | DiagramConnectionEditable;
        endCap?: string | DiagramConnectionEndCap;
        from?: string | DiagramConnectionFrom;
        fromConnector?: string;
        hover?: DiagramConnectionHover;
        points?: DiagramConnectionPoint[];
        selection?: DiagramConnectionSelection;
        startCap?: string | DiagramConnectionStartCap;
        stroke?: DiagramConnectionStroke;
        to?: string | DiagramConnectionTo;
        toConnector?: string;
        type?: string;
    }


interface DiagramEditableDragSnap {
        size?: number;
    }


interface DiagramEditableDrag {
        snap?: boolean | DiagramEditableDragSnap;
    }


interface DiagramEditableResizeHandlesFill {
        color?: string;
        opacity?: number;
    }


interface DiagramEditableResizeHandlesHoverFill {
        color?: string;
        opacity?: number;
    }


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


interface DiagramEditableResizeHandlesHover {
        fill?: string | DiagramEditableResizeHandlesHoverFill;
        stroke?: DiagramEditableResizeHandlesHoverStroke;
    }


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


interface DiagramEditableResizeHandles {
        fill?: string | DiagramEditableResizeHandlesFill;
        height?: number;
        hover?: DiagramEditableResizeHandlesHover;
        stroke?: DiagramEditableResizeHandlesStroke;
        width?: number;
    }


interface DiagramEditableResize {
        handles?: DiagramEditableResizeHandles;
    }


interface DiagramEditableRotateFill {
        color?: string;
        opacity?: number;
    }


interface DiagramEditableRotateStroke {
        color?: string;
        width?: number;
    }


interface DiagramEditableRotate {
        fill?: DiagramEditableRotateFill;
        stroke?: DiagramEditableRotateStroke;
    }


interface DiagramEditableTool {
        name?: string;
        step?: number;
    }


interface DiagramEditable {
        connectionTemplate?: string|Function;
        drag?: boolean | DiagramEditableDrag;
        remove?: boolean;
        resize?: boolean | DiagramEditableResize;
        rotate?: boolean | DiagramEditableRotate;
        shapeTemplate?: string|Function;
        tools?: DiagramEditableTool[];
    }


interface DiagramLayoutGrid {
        componentSpacingX?: number;
        componentSpacingY?: number;
        offsetX?: number;
        offsetY?: number;
        width?: number;
    }


interface DiagramLayout {
        endRadialAngle?: number;
        grid?: DiagramLayoutGrid;
        horizontalSeparation?: number;
        iterations?: number;
        layerSeparation?: number;
        nodeDistance?: number;
        radialFirstLevelSeparation?: number;
        radialSeparation?: number;
        startRadialAngle?: number;
        subtype?: string;
        tipOverTreeStartLevel?: number;
        type?: string;
        underneathHorizontalOffset?: number;
        underneathVerticalSeparation?: number;
        underneathVerticalTopOffset?: number;
        verticalSeparation?: number;
    }


interface DiagramPannable {
        key?: string;
    }


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


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


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


interface DiagramSelectable {
        key?: string;
        multiple?: boolean;
        stroke?: DiagramSelectableStroke;
    }


interface DiagramShapeDefaultsConnectorDefaultsFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeDefaultsConnectorDefaultsHoverFill {
        color?: string;
        opacity?: number;
    }


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


interface DiagramShapeDefaultsConnectorDefaultsHover {
        fill?: string | DiagramShapeDefaultsConnectorDefaultsHoverFill;
        stroke?: string | DiagramShapeDefaultsConnectorDefaultsHoverStroke;
    }


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


interface DiagramShapeDefaultsConnectorDefaults {
        width?: number;
        height?: number;
        hover?: DiagramShapeDefaultsConnectorDefaultsHover;
        fill?: string | DiagramShapeDefaultsConnectorDefaultsFill;
        stroke?: string | DiagramShapeDefaultsConnectorDefaultsStroke;
    }


interface DiagramShapeDefaultsConnectorFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeDefaultsConnectorHoverFill {
        color?: string;
        opacity?: number;
    }


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


interface DiagramShapeDefaultsConnectorHover {
        fill?: string | DiagramShapeDefaultsConnectorHoverFill;
        stroke?: string | DiagramShapeDefaultsConnectorHoverStroke;
    }


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


interface DiagramShapeDefaultsConnector {
        name?: string;
        position?: Function;
        width?: number;
        height?: number;
        hover?: DiagramShapeDefaultsConnectorHover;
        fill?: string | DiagramShapeDefaultsConnectorFill;
        stroke?: string | DiagramShapeDefaultsConnectorStroke;
    }


interface DiagramShapeDefaultsContent {
        align?: string;
        color?: string;
        fontFamily?: string;
        fontSize?: number;
        fontStyle?: string;
        fontWeight?: string;
        template?: string|Function;
        text?: string;
    }


interface DiagramShapeDefaultsEditableTool {
        name?: string;
        step?: number;
    }


interface DiagramShapeDefaultsEditable {
        connect?: boolean;
        drag?: boolean;
        remove?: boolean;
        tools?: DiagramShapeDefaultsEditableTool[];
    }


interface DiagramShapeDefaultsFillGradientStop {
        offset?: number;
        color?: string;
        opacity?: number;
    }


interface DiagramShapeDefaultsFillGradient {
        type?: string;
        center?: any;
        radius?: number;
        start?: any;
        end?: any;
        stops?: DiagramShapeDefaultsFillGradientStop[];
    }


interface DiagramShapeDefaultsFill {
        color?: string;
        opacity?: number;
        gradient?: DiagramShapeDefaultsFillGradient;
    }


interface DiagramShapeDefaultsHoverFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeDefaultsHover {
        fill?: string | DiagramShapeDefaultsHoverFill;
    }


interface DiagramShapeDefaultsRotation {
        angle?: number;
    }


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


interface DiagramShapeDefaults {
        connectors?: DiagramShapeDefaultsConnector[];
        connectorDefaults?: DiagramShapeDefaultsConnectorDefaults;
        content?: DiagramShapeDefaultsContent;
        editable?: boolean | DiagramShapeDefaultsEditable;
        fill?: string | DiagramShapeDefaultsFill;
        height?: number;
        hover?: DiagramShapeDefaultsHover;
        minHeight?: number;
        minWidth?: number;
        path?: string;
        rotation?: DiagramShapeDefaultsRotation;
        selectable?: boolean;
        source?: string;
        stroke?: DiagramShapeDefaultsStroke;
        type?: string;
        visual?: Function;
        width?: number;
        x?: number;
        y?: number;
    }


interface DiagramShapeConnectorDefaultsFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeConnectorDefaultsHoverFill {
        color?: string;
        opacity?: number;
    }


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


interface DiagramShapeConnectorDefaultsHover {
        fill?: string | DiagramShapeConnectorDefaultsHoverFill;
        stroke?: string | DiagramShapeConnectorDefaultsHoverStroke;
    }


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


interface DiagramShapeConnectorDefaults {
        width?: number;
        height?: number;
        hover?: DiagramShapeConnectorDefaultsHover;
        fill?: string | DiagramShapeConnectorDefaultsFill;
        stroke?: string | DiagramShapeConnectorDefaultsStroke;
    }


interface DiagramShapeConnectorFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeConnectorHoverFill {
        color?: string;
        opacity?: number;
    }


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


interface DiagramShapeConnectorHover {
        fill?: string | DiagramShapeConnectorHoverFill;
        stroke?: string | DiagramShapeConnectorHoverStroke;
    }


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


interface DiagramShapeConnector {
        description?: string;
        name?: string;
        position?: Function;
        width?: number;
        height?: number;
        hover?: DiagramShapeConnectorHover;
        fill?: string | DiagramShapeConnectorFill;
        stroke?: string | DiagramShapeConnectorStroke;
    }


interface DiagramShapeContent {
        align?: string;
        color?: string;
        fontFamily?: string;
        fontSize?: number;
        fontStyle?: string;
        fontWeight?: string;
        template?: string|Function;
        text?: string;
    }


interface DiagramShapeEditableTool {
        name?: string;
        step?: number;
    }


interface DiagramShapeEditable {
        connect?: boolean;
        tools?: DiagramShapeEditableTool[];
    }


interface DiagramShapeFillGradientStop {
        offset?: number;
        color?: string;
        opacity?: number;
    }


interface DiagramShapeFillGradient {
        type?: string;
        center?: any;
        radius?: number;
        start?: any;
        end?: any;
        stops?: DiagramShapeFillGradientStop[];
    }


interface DiagramShapeFill {
        color?: string;
        opacity?: number;
        gradient?: DiagramShapeFillGradient;
    }


interface DiagramShapeHoverFill {
        color?: string;
        opacity?: number;
    }


interface DiagramShapeHover {
        fill?: string | DiagramShapeHoverFill;
    }


interface DiagramShapeRotation {
        angle?: number;
    }


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


interface DiagramShape {
        connectors?: DiagramShapeConnector[];
        connectorDefaults?: DiagramShapeConnectorDefaults;
        content?: DiagramShapeContent;
        editable?: boolean | DiagramShapeEditable;
        fill?: string | DiagramShapeFill;
        height?: number;
        hover?: DiagramShapeHover;
        id?: string;
        minHeight?: number;
        minWidth?: number;
        path?: string;
        rotation?: DiagramShapeRotation;
        source?: string;
        stroke?: DiagramShapeStroke;
        type?: string;
        visual?: Function;
        width?: number;
        x?: number;
        y?: number;
    }


interface DiagramExportImageOptions {
        width?: string;
        height?: string;
        cors?: string;
    }


interface DiagramExportSVGOptions {
        raw?: boolean;
    }


interface DiagramSelectOptions {
        addToSelection?: boolean;
    }


interface DiagramOptions {
        name?: string;
        autoBind?: boolean;
        connectionDefaults?: DiagramConnectionDefaults;
        connections?: DiagramConnection[];
        connectionsDataSource?: any|any|kendo.data.DataSource;
        dataSource?: any|any|kendo.data.DataSource;
        editable?: boolean | DiagramEditable;
        layout?: DiagramLayout;
        pannable?: boolean | DiagramPannable;
        pdf?: DiagramPdf;
        selectable?: boolean | DiagramSelectable;
        shapeDefaults?: DiagramShapeDefaults;
        shapes?: DiagramShape[];
        template?: string|Function;
        theme?: string;
        zoom?: number;
        zoomMax?: number;
        zoomMin?: number;
        zoomRate?: number;
        add?(e: DiagramAddEvent): void;
        cancel?(e: DiagramCancelEvent): void;
        change?(e: DiagramChangeEvent): void;
        click?(e: DiagramClickEvent): void;
        dataBound?(e: DiagramDataBoundEvent): void;
        drag?(e: DiagramDragEvent): void;
        dragEnd?(e: DiagramDragEndEvent): void;
        dragStart?(e: DiagramDragStartEvent): void;
        edit?(e: DiagramEditEvent): void;
        itemBoundsChange?(e: DiagramItemBoundsChangeEvent): void;
        itemRotate?(e: DiagramItemRotateEvent): void;
        mouseEnter?(e: DiagramMouseEnterEvent): void;
        mouseLeave?(e: DiagramMouseLeaveEvent): void;
        pan?(e: DiagramPanEvent): void;
        remove?(e: DiagramRemoveEvent): void;
        save?(e: DiagramSaveEvent): void;
        select?(e: DiagramSelectEvent): void;
        toolBarClick?(e: DiagramToolBarClickEvent): void;
        zoomEnd?(e: DiagramZoomEndEvent): void;
        zoomStart?(e: DiagramZoomStartEvent): void;
    }


interface DiagramEvent {
        sender: Diagram;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface DiagramAddEvent extends DiagramEvent {
        connection?: kendo.dataviz.diagram.Connection;
        shape?: kendo.dataviz.diagram.Shape;
    }


interface DiagramCancelEvent extends DiagramEvent {
        container?: JQuery;
        connection?: kendo.data.Model;
        shape?: kendo.data.Model;
    }


interface DiagramChangeEvent extends DiagramEvent {
        added?: any;
        removed?: any;
    }


interface DiagramClickEvent extends DiagramEvent {
        item?: any;
        meta?: any;
        point?: kendo.dataviz.diagram.Point;
    }


interface DiagramDataBoundEvent extends DiagramEvent {
    }


interface DiagramDragEvent extends DiagramEvent {
        connectionHandle?: string;
        connections?: any;
        shapes?: any;
    }


interface DiagramDragEndEvent extends DiagramEvent {
        connectionHandle?: string;
        connections?: any;
        shapes?: any;
    }


interface DiagramDragStartEvent extends DiagramEvent {
        connectionHandle?: string;
        connections?: any;
        shapes?: any;
    }


interface DiagramEditEvent extends DiagramEvent {
        container?: JQuery;
        connection?: kendo.data.Model;
        shape?: kendo.data.Model;
    }


interface DiagramItemBoundsChangeEvent extends DiagramEvent {
        bounds?: kendo.dataviz.diagram.Rect;
        item?: kendo.dataviz.diagram.Shape;
    }


interface DiagramItemRotateEvent extends DiagramEvent {
        item?: kendo.dataviz.diagram.Shape;
    }


interface DiagramMouseEnterEvent extends DiagramEvent {
        item?: any;
    }


interface DiagramMouseLeaveEvent extends DiagramEvent {
        item?: any;
    }


interface DiagramPanEvent extends DiagramEvent {
        pan?: kendo.dataviz.diagram.Point;
    }


interface DiagramRemoveEvent extends DiagramEvent {
        connection?: kendo.dataviz.diagram.Connection;
        shape?: kendo.dataviz.diagram.Shape;
    }


interface DiagramSaveEvent extends DiagramEvent {
        container?: JQuery;
        connection?: kendo.data.Model;
        shape?: kendo.data.Model;
    }


interface DiagramSelectEvent extends DiagramEvent {
        selected?: any;
        deselected?: any;
    }


interface DiagramToolBarClickEvent extends DiagramEvent {
        action?: string;
        shapes?: any;
        connections?: any;
        target?: JQuery;
    }


interface DiagramZoomEndEvent extends DiagramEvent {
        point?: kendo.dataviz.diagram.Point;
        zoom?: number;
    }


interface DiagramZoomStartEvent extends DiagramEvent {
        point?: kendo.dataviz.diagram.Point;
        zoom?: number;
    }


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


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


interface LinearGaugeGaugeArea {
        background?: string;
        border?: LinearGaugeGaugeAreaBorder;
        height?: number;
        margin?: number | LinearGaugeGaugeAreaMargin;
        width?: number;
    }


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


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


interface LinearGaugePointerItemTrack {
        border?: LinearGaugePointerItemTrackBorder;
        color?: string;
        opacity?: number;
        size?: number;
        visible?: boolean;
    }


interface LinearGaugePointerItem {
        border?: LinearGaugePointerItemBorder;
        color?: string;
        margin?: number|any;
        opacity?: number;
        shape?: string;
        size?: number;
        track?: LinearGaugePointerItemTrack;
        value?: number;
    }


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


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


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


interface LinearGaugeScaleLabels {
        background?: string;
        border?: LinearGaugeScaleLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | LinearGaugeScaleLabelsMargin;
        padding?: number | LinearGaugeScaleLabelsPadding;
        template?: string|Function;
        visible?: boolean;
    }


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


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


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


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


interface LinearGaugeScale {
        line?: LinearGaugeScaleLine;
        labels?: LinearGaugeScaleLabels;
        majorTicks?: LinearGaugeScaleMajorTicks;
        majorUnit?: number;
        max?: number;
        min?: number;
        minorTicks?: LinearGaugeScaleMinorTicks;
        minorUnit?: number;
        mirror?: boolean;
        ranges?: LinearGaugeScaleRange[];
        rangePlaceholderColor?: string;
        rangeSize?: number;
        reverse?: boolean;
        vertical?: boolean;
    }


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


interface LinearGaugeExportSVGOptions {
        raw?: boolean;
    }


interface LinearGaugeOptions {
        name?: string;
        gaugeArea?: LinearGaugeGaugeArea;
        pointer?: LinearGaugePointerItem[];
        renderAs?: string;
        scale?: LinearGaugeScale;
        theme?: string;
        transitions?: boolean;
    }


interface LinearGaugeEvent {
        sender: LinearGauge;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MapControlsAttribution {
        position?: string;
    }


interface MapControlsNavigator {
        position?: string;
    }


interface MapControlsZoom {
        position?: string;
    }


interface MapControls {
        attribution?: boolean | MapControlsAttribution;
        navigator?: boolean | MapControlsNavigator;
        zoom?: boolean | MapControlsZoom;
    }


interface MapLayerDefaultsBing {
        attribution?: string;
        opacity?: number;
        key?: string;
        imagerySet?: string;
        culture?: string;
    }


interface MapLayerDefaultsBubbleStyleFill {
        color?: string;
        opacity?: number;
    }


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


interface MapLayerDefaultsBubbleStyle {
        fill?: MapLayerDefaultsBubbleStyleFill;
        stroke?: MapLayerDefaultsBubbleStyleStroke;
    }


interface MapLayerDefaultsBubble {
        attribution?: string;
        opacity?: number;
        maxSize?: number;
        minSize?: number;
        style?: MapLayerDefaultsBubbleStyle;
        symbol?: string|Function;
    }


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


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


interface MapLayerDefaultsMarkerTooltipAnimation {
        close?: MapLayerDefaultsMarkerTooltipAnimationClose;
        open?: MapLayerDefaultsMarkerTooltipAnimationOpen;
    }


interface MapLayerDefaultsMarkerTooltipContent {
        url?: string;
    }


interface MapLayerDefaultsMarkerTooltip {
        autoHide?: boolean;
        animation?: MapLayerDefaultsMarkerTooltipAnimation;
        content?: string | Function | MapLayerDefaultsMarkerTooltipContent;
        template?: string;
        callout?: boolean;
        iframe?: boolean;
        height?: number;
        width?: number;
        position?: string;
        showAfter?: number;
        showOn?: string;
    }


interface MapLayerDefaultsMarker {
        shape?: string;
        tooltip?: MapLayerDefaultsMarkerTooltip;
        opacity?: number;
    }


interface MapLayerDefaultsShapeStyleFill {
        color?: string;
        opacity?: number;
    }


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


interface MapLayerDefaultsShapeStyle {
        fill?: MapLayerDefaultsShapeStyleFill;
        stroke?: MapLayerDefaultsShapeStyleStroke;
    }


interface MapLayerDefaultsShape {
        attribution?: string;
        opacity?: number;
        style?: MapLayerDefaultsShapeStyle;
    }


interface MapLayerDefaultsTile {
        urlTemplate?: string;
        attribution?: string;
        subdomains?: any;
        opacity?: number;
    }


interface MapLayerDefaults {
        marker?: MapLayerDefaultsMarker;
        shape?: MapLayerDefaultsShape;
        bubble?: MapLayerDefaultsBubble;
        tileSize?: number;
        tile?: MapLayerDefaultsTile;
        bing?: MapLayerDefaultsBing;
    }


interface MapLayerStyleFill {
        color?: string;
        opacity?: number;
    }


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


interface MapLayerStyle {
        fill?: MapLayerStyleFill;
        stroke?: MapLayerStyleStroke;
    }


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


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


interface MapLayerTooltipAnimation {
        close?: MapLayerTooltipAnimationClose;
        open?: MapLayerTooltipAnimationOpen;
    }


interface MapLayerTooltipContent {
        url?: string;
    }


interface MapLayerTooltip {
        autoHide?: boolean;
        animation?: MapLayerTooltipAnimation;
        content?: string | Function | MapLayerTooltipContent;
        template?: string;
        callout?: boolean;
        iframe?: boolean;
        height?: number;
        width?: number;
        position?: string;
        showAfter?: number;
        showOn?: string;
    }


interface MapLayer {
        attribution?: string;
        autoBind?: boolean;
        dataSource?: any|any|kendo.data.DataSource;
        extent?: any|kendo.dataviz.map.Extent;
        key?: string;
        imagerySet?: string;
        culture?: string;
        locationField?: string;
        shape?: string;
        tileSize?: number;
        titleField?: string;
        tooltip?: MapLayerTooltip;
        maxSize?: number;
        minSize?: number;
        maxZoom?: number;
        minZoom?: number;
        opacity?: number;
        subdomains?: any;
        symbol?: string|Function;
        type?: string;
        style?: MapLayerStyle;
        urlTemplate?: string;
        valueField?: string;
        zIndex?: number;
    }


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


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


interface MapMarkerDefaultsTooltipAnimation {
        close?: MapMarkerDefaultsTooltipAnimationClose;
        open?: MapMarkerDefaultsTooltipAnimationOpen;
    }


interface MapMarkerDefaultsTooltipContent {
        url?: string;
    }


interface MapMarkerDefaultsTooltip {
        autoHide?: boolean;
        animation?: MapMarkerDefaultsTooltipAnimation;
        content?: string | Function | MapMarkerDefaultsTooltipContent;
        template?: string;
        callout?: boolean;
        iframe?: boolean;
        height?: number;
        width?: number;
        position?: string;
        showAfter?: number;
        showOn?: string;
    }


interface MapMarkerDefaults {
        shape?: string;
        tooltip?: MapMarkerDefaultsTooltip;
    }


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


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


interface MapMarkerTooltipAnimation {
        close?: MapMarkerTooltipAnimationClose;
        open?: MapMarkerTooltipAnimationOpen;
    }


interface MapMarkerTooltipContent {
        url?: string;
    }


interface MapMarkerTooltip {
        autoHide?: boolean;
        animation?: MapMarkerTooltipAnimation;
        content?: string | Function | MapMarkerTooltipContent;
        template?: string;
        callout?: boolean;
        iframe?: boolean;
        height?: number;
        width?: number;
        position?: string;
        showAfter?: number;
        showOn?: string;
    }


interface MapMarker {
        location?: any|kendo.dataviz.map.Location;
        shape?: string;
        title?: string;
        tooltip?: MapMarkerTooltip;
    }


interface MapOptions {
        name?: string;
        center?: any|kendo.dataviz.map.Location;
        controls?: MapControls;
        layerDefaults?: MapLayerDefaults;
        layers?: MapLayer[];
        markerDefaults?: MapMarkerDefaults;
        markers?: MapMarker[];
        minZoom?: number;
        maxZoom?: number;
        minSize?: number;
        pannable?: boolean;
        wraparound?: boolean;
        zoom?: number;
        zoomable?: boolean;
        beforeReset?(e: MapBeforeResetEvent): void;
        click?(e: MapClickEvent): void;
        markerActivate?(e: MapMarkerActivateEvent): void;
        markerCreated?(e: MapMarkerCreatedEvent): void;
        markerClick?(e: MapMarkerClickEvent): void;
        pan?(e: MapPanEvent): void;
        panEnd?(e: MapPanEndEvent): void;
        reset?(e: MapResetEvent): void;
        shapeClick?(e: MapShapeClickEvent): void;
        shapeCreated?(e: MapShapeCreatedEvent): void;
        shapeFeatureCreated?(e: MapShapeFeatureCreatedEvent): void;
        shapeMouseEnter?(e: MapShapeMouseEnterEvent): void;
        shapeMouseLeave?(e: MapShapeMouseLeaveEvent): void;
        zoomStart?(e: MapZoomStartEvent): void;
        zoomEnd?(e: MapZoomEndEvent): void;
    }


interface MapEvent {
        sender: Map;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface MapBeforeResetEvent extends MapEvent {
    }


interface MapClickEvent extends MapEvent {
        location?: kendo.dataviz.map.Location;
        originalEvent?: any;
    }


interface MapMarkerActivateEvent extends MapEvent {
        marker?: kendo.dataviz.map.Marker;
        layer?: kendo.dataviz.map.Marker;
    }


interface MapMarkerCreatedEvent extends MapEvent {
        marker?: kendo.dataviz.map.Marker;
        layer?: kendo.dataviz.map.Marker;
    }


interface MapMarkerClickEvent extends MapEvent {
        marker?: kendo.dataviz.map.Marker;
        layer?: kendo.dataviz.map.Marker;
    }


interface MapPanEvent extends MapEvent {
        origin?: kendo.dataviz.map.Location;
        center?: kendo.dataviz.map.Location;
        originalEvent?: any;
    }


interface MapPanEndEvent extends MapEvent {
        origin?: kendo.dataviz.map.Location;
        center?: kendo.dataviz.map.Location;
        originalEvent?: any;
    }


interface MapResetEvent extends MapEvent {
    }


interface MapShapeClickEvent extends MapEvent {
        layer?: kendo.dataviz.map.layer.Shape;
        shape?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface MapShapeCreatedEvent extends MapEvent {
        layer?: kendo.dataviz.map.layer.Shape;
        shape?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface MapShapeFeatureCreatedEvent extends MapEvent {
        dataItem?: any;
        layer?: kendo.dataviz.map.layer.Shape;
        group?: kendo.drawing.Group;
        properties?: any;
    }


interface MapShapeMouseEnterEvent extends MapEvent {
        layer?: kendo.dataviz.map.layer.Shape;
        shape?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface MapShapeMouseLeaveEvent extends MapEvent {
        layer?: kendo.dataviz.map.layer.Shape;
        shape?: kendo.drawing.Element;
        originalEvent?: any;
    }


interface MapZoomStartEvent extends MapEvent {
        originalEvent?: any;
    }


interface MapZoomEndEvent extends MapEvent {
        originalEvent?: any;
    }


interface QRCodeBorder {
        color?: string;
        width?: number;
    }


interface QRCodeOverlay {
        height?: number;
        type?: string;
        url?: string;
        width?: string;
    }


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


interface QRCodeExportSVGOptions {
        raw?: boolean;
    }


interface QRCodeOptions {
        name?: string;
        background?: string;
        border?: QRCodeBorder;
        color?: string;
        encoding?: string;
        errorCorrection?: string;
        overlay?: QRCodeOverlay;
        padding?: number;
        renderAs?: string;
        size?: number|string;
        value?: number|string;
    }


interface QRCodeEvent {
        sender: QRCode;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


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


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


interface RadialGaugeGaugeArea {
        background?: string;
        border?: RadialGaugeGaugeAreaBorder;
        height?: number;
        margin?: number | RadialGaugeGaugeAreaMargin;
        width?: number;
    }


interface RadialGaugePointerItemCap {
        color?: string;
        size?: number;
    }


interface RadialGaugePointerItem {
        cap?: RadialGaugePointerItemCap;
        color?: string;
        length?: number;
        value?: number;
    }


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


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


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


interface RadialGaugeScaleLabels {
        background?: string;
        border?: RadialGaugeScaleLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number | RadialGaugeScaleLabelsMargin;
        padding?: number | RadialGaugeScaleLabelsPadding;
        position?: string;
        template?: string|Function;
        visible?: boolean;
    }


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


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


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


interface RadialGaugeScale {
        endAngle?: number;
        labels?: RadialGaugeScaleLabels;
        majorTicks?: RadialGaugeScaleMajorTicks;
        majorUnit?: number;
        max?: number;
        min?: number;
        minorTicks?: RadialGaugeScaleMinorTicks;
        minorUnit?: number;
        ranges?: RadialGaugeScaleRange[];
        rangePlaceholderColor?: string;
        rangeSize?: number;
        rangeDistance?: number;
        reverse?: boolean;
        startAngle?: number;
    }


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


interface RadialGaugeExportSVGOptions {
        raw?: boolean;
    }


interface RadialGaugeOptions {
        name?: string;
        gaugeArea?: RadialGaugeGaugeArea;
        pointer?: RadialGaugePointerItem[];
        renderAs?: string;
        scale?: RadialGaugeScale;
        theme?: string;
        transitions?: boolean;
    }


interface RadialGaugeEvent {
        sender: RadialGauge;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface SparklineCategoryAxisItemCrosshairTooltipBorder {
        color?: string;
        width?: number;
    }


interface SparklineCategoryAxisItemCrosshairTooltip {
        background?: string;
        border?: SparklineCategoryAxisItemCrosshairTooltipBorder;
        color?: string;
        font?: string;
        format?: string;
        padding?: number|any;
        template?: string|Function;
        visible?: boolean;
    }


interface SparklineCategoryAxisItemCrosshair {
        color?: string;
        width?: number;
        opacity?: number;
        dashType?: number;
        visible?: boolean;
        tooltip?: SparklineCategoryAxisItemCrosshairTooltip;
    }


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


interface SparklineCategoryAxisItemLabels {
        background?: string;
        border?: SparklineCategoryAxisItemLabelsBorder;
        color?: string;
        font?: string;
        format?: string;
        margin?: number|any;
        mirror?: boolean;
        padding?: number|any;
        rotation?: number;
        skip?: number;
        step?: number;
        template?: string|Function;
        visible?: boolean;
        culture?: string;
        dateFormats?: any;
    }


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


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