import * as React from 'react';
import { HorizontalAlignment_$type } from "igniteui-react-core/ES2015/HorizontalAlignment";
import { UnknownValuePlotting_$type } from "igniteui-react-core/ES2015/UnknownValuePlotting";
import { TrendLineType_$type } from "igniteui-react-core/ES2015/TrendLineType";
import { ChartSeriesEventArgs } from './igr-chart-series-event-args';
import { brushToString, stringToBrush, toBrushCollection, fromBrushCollection, fromRect, toRect, ensureBool, ensureEnum, isValidProp, getModifiedProps } from "igniteui-react-core/ES2015/componentUtil";
import { MarkerType_$type } from "./MarkerType";
import { delegateCombine, delegateRemove } from "igniteui-react-core/ES2015/type";
import { DomainChartSeriesPointerEventArgs } from './igr-domain-chart-series-pointer-event-args';
import { MarkerTypeCollection as MarkerTypeCollection_internal } from './MarkerTypeCollection';
import { MarkerTypeCollection } from './igr-marker-type-collection';
import { SyncableObservableCollection$1 } from "igniteui-react-core/ES2015/SyncableObservableCollection$1";
import { ToolTipType_$type } from "igniteui-react-charts/ES2015/ToolTipType";
import { CrosshairsDisplayMode_$type } from "igniteui-react-charts/ES2015/CrosshairsDisplayMode";
import { CalloutStyleUpdatingEventArgs } from "igniteui-react-charts/ES2015/igr-callout-style-updating-event-args";
export class IgrDomainChart extends React.Component {
    constructor(props) {
        super(props);
        this._hasUserValues = new Set();
        this._calloutsDataSource = null;
        this._markerTypes = null;
        this._seriesAdded = null;
        this._seriesAdded_wrapped = null;
        this._seriesRemoved = null;
        this._seriesRemoved_wrapped = null;
        this._seriesPointerEnter = null;
        this._seriesPointerEnter_wrapped = null;
        this._seriesPointerLeave = null;
        this._seriesPointerLeave_wrapped = null;
        this._seriesPointerMove = null;
        this._seriesPointerMove_wrapped = null;
        this._seriesPointerDown = null;
        this._seriesPointerDown_wrapped = null;
        this._seriesPointerUp = null;
        this._seriesPointerUp_wrapped = null;
        this._calloutStyleUpdating = null;
        this._calloutStyleUpdating_wrapped = null;
        this._implementation = this.createImplementation();
        this._implementation.externalObject = this;
        this.onImplementationCreated();
    }
    createImplementation() {
        return null;
    }
    get i() {
        return this._implementation;
    }
    onImplementationCreated() {
    }
    get hasUserValues() {
        return this._hasUserValues;
    }
    componentDidMount() {
        for (const p of Object.keys(this.props)) {
            if (isValidProp(this, p)) {
                this._hasUserValues.add(p);
                this[p] = this.props[p];
            }
        }
    }
    shouldComponentUpdate(nextProps, nextState) {
        const mod = getModifiedProps(this.props, nextProps);
        for (const p of Object.keys(mod)) {
            if (isValidProp(this, p)) {
                this._hasUserValues.add(p);
                this[p] = mod[p];
            }
        }
        return true;
    }
    render() {
        return null;
    }
    /**
    * Sets or gets the template reference to use for tooltips for all the series.
    *
    *
    */
    get tooltipTemplate() {
        return this.i.tooltipTemplate;
    }
    set tooltipTemplate(v) {
        this.i.tooltipTemplate = v;
    }
    /**
    * Sets or gets the template references to use for tooltips for all the series, in order.
    *
    *
    */
    get tooltipTemplates() {
        let ret = [];
        if (this.i.tooltipTemplates) {
            for (let ii = 0; ii < this.i.tooltipTemplates.count; ii++) {
                ret.push(this.i.tooltipTemplates.item(ii));
            }
        }
        return ret;
    }
    set tooltipTemplates(v) {
        this.i.tooltipTemplates.clear();
        if (v) {
            for (let ii = 0; ii < v.length; ii++) {
                this.i.tooltipTemplates.add(v[ii]);
            }
        }
    }
    get legend() {
        if (this.i.legend != null)
            return this.i.legend.externalObject;
    }
    set legend(v) {
        if (v != undefined && v != null)
            this.i.legend = v.i;
    }
    set calloutsDataSource(value) {
        this._calloutsDataSource = value;
        this.bindCalloutsData();
    }
    get calloutsDataSource() {
        return this._calloutsDataSource;
    }
    bindCalloutsData() {
        if (this.i != null && this.i !== undefined) {
            this.i.calloutsItemsSource = this._calloutsDataSource;
        }
    }
    /**
 * Gets or sets the scaling value used to affect the pixel density of the control.
 * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
 * to appear blurry.
*/
    get pixelScalingRatio() {
        return this.i.ct;
    }
    set pixelScalingRatio(v) {
        this.i.ct = +v;
    }
    /**
     * Gets or sets the left margin of chart title
    *
    *  Use `titleLeftMargin` property for the left margin of chart title.
    *
    * ```ts
    * this.chart.titleLeftMargin = 10;
    * ```
    */
    get titleLeftMargin() {
        return this.i.c2;
    }
    set titleLeftMargin(v) {
        this.i.c2 = +v;
    }
    /**
     * Gets or sets the right margin of chart title
    *
    *  Use `titleLeftMargin` property for the right margin of chart title.
    *
    * ```ts
    * this.chart.titleRightMargin = 10;
    * ```
    */
    get titleRightMargin() {
        return this.i.c3;
    }
    set titleRightMargin(v) {
        this.i.c3 = +v;
    }
    /**
     * Gets or sets the top margin of chart title
    *
    *  Use `titleTopMargin` property for the top margin of chart title.
    *
    * ```ts
    * this.chart.titleTopMargin = 10;
    * ```
    */
    get titleTopMargin() {
        return this.i.c4;
    }
    set titleTopMargin(v) {
        this.i.c4 = +v;
    }
    /**
     * Gets or sets the bottom margin of chart title
    *
    *  Use `titleBottomMargin` property for the bottom margin of chart title.
    *
    * ```ts
    *  this.chart.titleBottomMargin = 5;
    * ```
    */
    get titleBottomMargin() {
        return this.i.c1;
    }
    set titleBottomMargin(v) {
        this.i.c1 = +v;
    }
    /**
     * Gets or sets the left margin of chart subtitle
    *
    * Use `subtitleLeftMargin` property for the left margin of chart subtitle.
    *
    * ```ts
    * this.chart.subtitleLeftMargin = 20 ;
    * ```
    */
    get subtitleLeftMargin() {
        return this.i.cx;
    }
    set subtitleLeftMargin(v) {
        this.i.cx = +v;
    }
    /**
     * Gets or sets the top margin of chart subtitle
    *
    * Use `subtitleTopMargin` property for the top margin of chart subtitle.
    *
    * ```ts
    * this.chart.subtitleTopMargin = 10;
    * ```
    */
    get subtitleTopMargin() {
        return this.i.cz;
    }
    set subtitleTopMargin(v) {
        this.i.cz = +v;
    }
    /**
     * Gets or sets the right margin of chart subtitle
    *
    * Use `subtitleRightMargin` property for the right margin of chart subtitle.
    *
    * ```ts
    *  this.chart.subtitleRightMargin = 20 ;
    * ```
    */
    get subtitleRightMargin() {
        return this.i.cy;
    }
    set subtitleRightMargin(v) {
        this.i.cy = +v;
    }
    /**
     * Gets or sets the bottom margin of chart subtitle
    *
    * Use `subtitleBottomMargin` property for the bottom margin of chart subtitle.
    *
    * ```ts
    * this.chart.subtitleBottomMargin = 10 ;
    * ```
    */
    get subtitleBottomMargin() {
        return this.i.cw;
    }
    set subtitleBottomMargin(v) {
        this.i.cw = +v;
    }
    /**
     * Gets or sets color of chart subtitle
    *
    * Use `subtitleTextColor` property to color the subtitle.
    *
    * ```ts
    * this.chart.subtitleTextColor = "#ff0000" ;
    * ```
    */
    get subtitleTextColor() {
        return brushToString(this.i.h1);
    }
    set subtitleTextColor(v) {
        this.i.h1 = stringToBrush(v);
    }
    /**
     * Gets or sets color of chart title
    *
    *  Use `titleTextColor` property to color the chart title
    *
    * ```ts
    *  this.chart.titleTextColor="red" ;
    * ```
    */
    get titleTextColor() {
        return brushToString(this.i.h2);
    }
    set titleTextColor(v) {
        this.i.h2 = stringToBrush(v);
    }
    /**
     * Gets or sets the left margin of the chart content.
    *
    * Use the 'leftMargin' property for the left margin of the chart content.
    *
    * ```ts
    *  this.chart.leftMargin = 20;
    * ```
    */
    get leftMargin() {
        return this.i.cs;
    }
    set leftMargin(v) {
        this.i.cs = +v;
    }
    /**
     * Gets or sets the top margin of the chart content.
    *
    * Use `topMargin` property for the margin of the chart content.
    *
    * ```ts
    * this.chart.topMargin=20;
    * ```
    */
    get topMargin() {
        return this.i.c5;
    }
    set topMargin(v) {
        this.i.c5 = +v;
    }
    /**
     * Gets or sets the right margin of the chart content.
    *
    * Use `rightMargin` property for the right margin of the chart content.
    *
    * ```ts
    *   this.chart.rightMargin = 20 ;
    * ```
    */
    get rightMargin() {
        return this.i.cv;
    }
    set rightMargin(v) {
        this.i.cv = +v;
    }
    /**
     * Gets or sets the bottom margin around the chart content.
    *
    * Use the `bottomMargin` property for the bottom margin around the chart content.
    *
    * ```ts
    * this.chart.bottomMargin=20;
    * ```
    */
    get bottomMargin() {
        return this.i.cr;
    }
    set bottomMargin(v) {
        this.i.cr = +v;
    }
    /**
     * Gets or sets the duration used for animating series plots when the data is changing
    *
    * Use the `transitionDuration` property to animating between data values.
    *
    * ```ts
    * this.chart.transitionDuration= 500;
    * ```
    */
    get transitionDuration() {
        return this.i.de;
    }
    set transitionDuration(v) {
        this.i.de = +v;
    }
    /**
     * Gets or sets the easing function used for animating series plots when the data is changing.
     * This can be set to one of the known values "linear" or "cubic," or it can be set to an easing function which takes a single numeric parameter and returns a number.
    *
    * The 'transitionInEasingFunction' property used for easing function for animating series plots when the chart is loading into view.
    *
    * ```ts
    * this.chart.transitionInEasingFunction=  this.cubicFunc;
    *
    * cubicFunc(time: number) : number
    *   {
    *     return time;
    *   }
    * ```
    */
    get transitionEasingFunction() {
        return this.i.a1;
    }
    set transitionEasingFunction(v) {
        this.i.a1 = v;
    }
    /**
     * Gets or sets CSS font property for the chart subtitle
    *
    * Use `subtitleTextStyle` property for the CSS font of the chart subtitle.
    *
    * ```ts
    * this.chart.subtitleTextStyle= "16pt Verdona";
    * ```
    */
    get subtitleTextStyle() {
        return this.i.e9;
    }
    set subtitleTextStyle(v) {
        this.i.e9 = v;
    }
    /**
     * Gets or sets CSS font property for the chart title
    *
    *  Use `titleTextStyle` property for the CSS font property of the chart title
    *
    * ```ts
    * this.chart.titleTextStyle = "24pt Verdona";
    * ```
    */
    get titleTextStyle() {
        return this.i.fk;
    }
    set titleTextStyle(v) {
        this.i.fk = v;
    }
    /**
     * Gets or sets a set of property paths that should be included for consideration by the category chart, leaving the remainder excluded. If null, all properties will be considered.
    *
    * The `includedProperties` property used to include the properties for the consideration of the category chart.
    *
    * ```ts
    * this.chart.includedProperties = ["ProductName", "Cost"];
    * ```
    */
    get includedProperties() {
        return this.i.d;
    }
    set includedProperties(v) {
        this.i.d = v;
    }
    /**
     * Gets or sets a set of property paths that should be excluded from consideration by the category chart.
    *
    * The `excludedProperties` property used for the property paths that should be excluded from consideration by the category chart.
    *
    * ```ts
    * this.chart.excludedProperties = ["ID", "Discount"];
    * ```
    */
    get excludedProperties() {
        return this.i.c;
    }
    set excludedProperties(v) {
        this.i.c = v;
    }
    /**
     * Gets or sets the palette of brushes to use for coloring the chart series.
     * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
    *
    * Use the `brushes` property to  set the brushes.
    *
    * ```ts
    * this.chart.brushes = ["#ff0000","#00ff00"];
    * ```
    */
    get brushes() {
        return fromBrushCollection(this.i.j);
    }
    set brushes(v) {
        this.i.j = toBrushCollection(v);
    }
    /**
     * Gets or sets the palette of brushes to use for outlines on the chart series.
     * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
    *
    *  Use the `outlines` property to sets the palette of brushes to use for outlines on the chart series
    */
    get outlines() {
        return fromBrushCollection(this.i.n);
    }
    set outlines(v) {
        this.i.n = toBrushCollection(v);
    }
    /**
     * Gets or sets whether the chart can be horizontally zoomed through user interactions.
    *
    * Use the `isHorizontalZoomEnabled` property to allow chart horizontally zoomed .
    *
    * ```ts
    * this.chart.isHorizontalZoomEnabled = true;
    * ```
    */
    get isHorizontalZoomEnabled() {
        return this.i.bq;
    }
    set isHorizontalZoomEnabled(v) {
        this.i.bq = ensureBool(v);
    }
    /**
     * Gets or sets whether the chart can be vertically zoomed through user interactions.
    *
    * Use the `isVerticalZoomEnabled` property to allow chart zoom vertically.
    *
    * ```ts
    *  this.chart.isVerticalZoomEnabled = true;
    * ```
    */
    get isVerticalZoomEnabled() {
        return this.i.bw;
    }
    set isVerticalZoomEnabled(v) {
        this.i.bw = ensureBool(v);
    }
    /**
     * Gets or sets whether the chart can highlight series through user interactions.
     * This property applies to Category Chart and Financial Chart controls.
    */
    get isSeriesHighlightingEnabled() {
        return this.i.bs;
    }
    set isSeriesHighlightingEnabled(v) {
        this.i.bs = ensureBool(v);
    }
    /**
     * Gets or sets the rectangle representing the current scroll and zoom state of the chart.
     * WindowRect is expressed as a Rectangle with coordinates and sizes between 0 and 1.
    *
    * Use `windowRect` property representing the current scroll and zoom state of the chart.
    *
    * ```ts
    * this.chart.windowRect =[0,0,1,1];
    * ```
    */
    get windowRect() {
        return fromRect(this.i.h6);
    }
    set windowRect(v) {
        this.i.h6 = toRect(v);
    }
    /**
     * Gets a rectangle representing the bounds of the plot area.
    *
    * `viewport` property representing the bounds of the plot area.
    *
    * ```ts
    * let viewport:Rect =  this.chart.viewport;
    * ```
    */
    get viewport() {
        return fromRect(this.i.h5);
    }
    /**
     * Gets or sets text to display above the plot area.
    *
    * Use the `chartTitle` property to display the text above the plot area.
    *
    * ```ts
    *  this.chart.title= "This is a Title";
    * ```
    */
    get chartTitle() {
        return this.i.fd;
    }
    set chartTitle(v) {
        this.i.fd = v;
    }
    /**
     * Gets or sets text to display below the Title, above the plot area.
    *
    * Use the `subtitle` property to display the text below  and above the plot area.
    *
    * ```ts
    *  this.chart.subtitle ="CategoryChart Subtitle" ;
    * ```
    */
    get subtitle() {
        return this.i.e2;
    }
    set subtitle(v) {
        this.i.e2 = v;
    }
    /**
     * Gets or sets horizontal alignment which determines the title position, relative to the left and right edges of the control.
    *
    * Use the `titleAlignment` property for the horizontal alignment of the title.
    *
    * ```ts
    * this.chart.titleAlignment = HorizontalAlignment.Center;
    * ```
    */
    get titleAlignment() {
        return this.i.hu;
    }
    set titleAlignment(v) {
        this.i.hu = ensureEnum(HorizontalAlignment_$type, v);
    }
    /**
     * Gets or sets horizontal alignment which determines the subtitle position, relative to the left and right edges of the control.
    *
    * Use the `subtitleAlignment` property to Gets or sets horizontal alignment.
    *
    * ```ts
    * this.chart.subtitleAlignment = HorizontalAlignment.Right;
    * ```
    */
    get subtitleAlignment() {
        return this.i.ht;
    }
    set subtitleAlignment(v) {
        this.i.ht = ensureEnum(HorizontalAlignment_$type, v);
    }
    /**
     * Gets or sets the behavior that determines how unknown values will be plotted on the chart.
     * Null and Double.NaN are two examples of unknown values.
    *
    * Use the `unknownValuePlotting` property to determines the behavior that how unknown values will be plotted on the chart.
    *
    * ```ts
    * this.chart.unknownValuePlotting =UnknownValuePlotting.DontPlot;
    * ```
    */
    get unknownValuePlotting() {
        return this.i.ax;
    }
    set unknownValuePlotting(v) {
        this.i.ax = ensureEnum(UnknownValuePlotting_$type, v);
    }
    /**
     * Gets or sets the rendering resolution for all series in this chart.
     * Where n = Resolution, for every n horizontal pixels, combine all items into a single datapoint.  When Resolution = 0, all datapoints will be rendered as graphical objects.  Charts with a higher resolution will have faster performance.
    *
    * Use the `resolution` property for all series in this chart.
    *
    * ```ts
    *   this.chart.resolution = 2 ;
    * ```
    */
    get resolution() {
        return this.i.cu;
    }
    set resolution(v) {
        this.i.cu = +v;
    }
    /**
     * Gets or sets the thickness for all series in this chart. Depending on the ChartType, this can be the main brush used, or just the outline.
    *
    * Use the `thickness` property for the thickness of all the series in this chart.
    *
    * ```ts
    * this.chart.thickness = 5;
    * ```
    */
    get thickness() {
        return this.i.c0;
    }
    set thickness(v) {
        this.i.c0 = +v;
    }
    /**
     * Gets or sets the marker shapes used for indicating location of data points in this chart.
     * This property applies only to these chart types: point, line, spline, bubble, and polygon
    */
    get markerTypes() {
        if (this._markerTypes === null) {
            let coll = new MarkerTypeCollection();
            let innerColl = this.i.ak;
            if (!innerColl) {
                innerColl = new MarkerTypeCollection_internal();
            }
            this._markerTypes = coll._fromInner(innerColl);
            this.i.ak = innerColl;
        }
        return this._markerTypes;
    }
    set markerTypes(v) {
        if (this._markerTypes !== null) {
            this._markerTypes._setSyncTarget(null);
            this._markerTypes = null;
        }
        let coll = new MarkerTypeCollection();
        this._markerTypes = coll._fromOuter(v);
        let syncColl = new SyncableObservableCollection$1(MarkerType_$type);
        let innerColl = this.i.ak;
        if (!innerColl) {
            innerColl = new MarkerTypeCollection_internal();
        }
        syncColl._inner = innerColl;
        syncColl.clear();
        this._markerTypes._setSyncTarget(syncColl);
        this.i.ak = innerColl;
    }
    /**
     * Gets or sets the palette of brushes used for rendering fill area of data point markers.
     * This property applies only to these chart types: point, line, spline, bubble, and polygon
    *
    * `markerBrushes` property used for rendering fill area of data point markers.
    *
    * ```ts
    *  this.chart.markerBrushes=[ "#ff0000", "#ffff00", "#00ffff" ];
    * ```
    */
    get markerBrushes() {
        return fromBrushCollection(this.i.l);
    }
    set markerBrushes(v) {
        this.i.l = toBrushCollection(v);
    }
    /**
     * Gets or sets the palette of brushes used for rendering outlines of data point markers.
     * This property applies only to these chart types: point, line, spline, bubble, and polygon
    *
    * `markerOutlines` property used for rendering outlines of data point markers.
    *
    * ```ts
    * this.chart.markerOutlines= ["#ff0000", "#ffff00", "#00ffff"] ;
    * ```
    */
    get markerOutlines() {
        return fromBrushCollection(this.i.m);
    }
    set markerOutlines(v) {
        this.i.m = toBrushCollection(v);
    }
    /**
     * Gets or sets the maximum number of markers displyed in the plot area of the chart.
    *
    * `markerMaxCount` property used to display maximum number of markers in the plot area of the chart.
    *
    * ```ts
    *  this.chart.markerMaxCount = 100 ;
    * ```
    */
    get markerMaxCount() {
        return this.i.dd;
    }
    set markerMaxCount(v) {
        this.i.dd = +v;
    }
    /**
     * Gets or sets whether the series animations should be allowed when a range change has been detected on an axis.
    */
    get animateSeriesWhenAxisRangeChanges() {
        return this.i.bg;
    }
    set animateSeriesWhenAxisRangeChanges(v) {
        this.i.bg = ensureBool(v);
    }
    /**
     * Gets or sets the palette of brushes to used for coloring trend lines in this chart.
     * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
    *
    * Use the `trendLineBrushes` property for coloring trend lines in the chart.
    *
    * ```ts
    * this.chart.trendLineBrushes=["#ff0000", "#ffff00", "#00ffff"]	;
    * ```
    */
    get trendLineBrushes() {
        return fromBrushCollection(this.i.o);
    }
    set trendLineBrushes(v) {
        this.i.o = toBrushCollection(v);
    }
    /**
     * Gets or sets the formula used for calculating trend lines in this chart.
     * This property applies only to these chart types: point, line, spline, and bubble
    *
    * Use the `trendLineType` property for calculating trend lines.
    *
    * ```ts
    * this.chart.trendLineType = TrendLineType.CubicFit;
    * ```
    */
    get trendLineType() {
        return this.i.av;
    }
    set trendLineType(v) {
        this.i.av = ensureEnum(TrendLineType_$type, v);
    }
    /**
     * Gets or sets the thickness of the trend lines in this chart.
     * This property applies only to these chart types: point, line, spline, and bubble
    *
    * Use the `trendLineThickness` property for the thickness of the trend lines in the chart.
    *
    * ```ts
    * this.chart.trendLineThickness=2;
    * ```
    */
    get trendLineThickness() {
        return this.i.c6;
    }
    set trendLineThickness(v) {
        this.i.c6 = +v;
    }
    /**
     * Gets or sets a value indicating whether grid and tick lines are aligned to device pixels.
    *
    * Use `alignsGridLinesToPixels` propert to indicat whether grid and tick lines are aligned to device pixels.
    *
    * ```ts
    *  this.chart.alignsGridLinesToPixels= true;
    * ```
    */
    get alignsGridLinesToPixels() {
        return this.i.bf;
    }
    set alignsGridLinesToPixels(v) {
        this.i.bf = ensureBool(v);
    }
    get trendLinePeriod() {
        return this.i.df;
    }
    set trendLinePeriod(v) {
        this.i.df = +v;
    }
    /**
     * Gets or sets the style of tooltip to be displayed.
    */
    get toolTipType() {
        return this.i.at;
    }
    set toolTipType(v) {
        this.i.at = ensureEnum(ToolTipType_$type, v);
    }
    /**
     * Gets or sets the crosshairs to be displayed.
    */
    get crosshairsDisplayMode() {
        return this.i.t;
    }
    set crosshairsDisplayMode(v) {
        this.i.t = ensureEnum(CrosshairsDisplayMode_$type, v);
    }
    /**
     * Gets or sets whether crosshairs will snap to the nearest data point.
    */
    get crosshairsSnapToData() {
        return this.i.bl;
    }
    set crosshairsSnapToData(v) {
        this.i.bl = ensureBool(v);
    }
    /**
     * Gets or sets whether annotations are shown along the axis for crosshair values
    */
    get crosshairsAnnotationEnabled() {
        return this.i.bk;
    }
    set crosshairsAnnotationEnabled(v) {
        this.i.bk = ensureBool(v);
    }
    /**
     * Gets or sets whether annotations for the final value of each series is displayed on the axis.
    */
    get finalValueAnnotationsVisible() {
        return this.i.bm;
    }
    set finalValueAnnotationsVisible(v) {
        this.i.bm = ensureBool(v);
    }
    /**
     * Gets or sets if callouts should be displayed.
    */
    get calloutsVisible() {
        return this.i.bj;
    }
    set calloutsVisible(v) {
        this.i.bj = ensureBool(v);
    }
    /**
     * Gets or sets if event annotations should be displayed.
    */
    get calloutStyleUpdatingEventEnabled() {
        return this.i.bi;
    }
    set calloutStyleUpdatingEventEnabled(v) {
        this.i.bi = ensureBool(v);
    }
    /**
     * Gets or sets the member path of the X data for the callouts.
    */
    get calloutsXMemberPath() {
        return this.i.ea;
    }
    set calloutsXMemberPath(v) {
        this.i.ea = v;
    }
    /**
     * Gets or sets the member path of the Y data for the callouts.
    */
    get calloutsYMemberPath() {
        return this.i.ec;
    }
    set calloutsYMemberPath(v) {
        this.i.ec = v;
    }
    /**
     * Gets or sets the member path of the label data for the callouts.
    */
    get calloutsLabelMemberPath() {
        return this.i.d6;
    }
    set calloutsLabelMemberPath(v) {
        this.i.d6 = v;
    }
    /**
     * Gets or sets the member path of the content data for the callouts.
    */
    get calloutsContentMemberPath() {
        return this.i.d3;
    }
    set calloutsContentMemberPath(v) {
        this.i.d3 = v;
    }
    /**
 * Provides a container for this control

*
* `provideContainer` method provide container for the control.
*
* ```ts
*     this.chart.provideContainer("Container");
* ```
*/
    provideContainer(container) {
        this.i.provideContainer(container);
    }
    /**
     * Destroy this control
    
    *
    * Use the `destroy` property to destroy the chart.
    *
    * ```ts
    * this.chart.destroy();
    * ```
    */
    destroy() {
        this.i.destroy();
    }
    /**
     * Called when the control has been resized.
    
    *
    * `notifyResized` method Called when the control has been resized.
    *
    * ```ts
    * this.chart.notifyResized();
    * ```
    */
    notifyResized() {
        this.i.notifyResized();
    }
    notifyVisualPropertiesChanged() {
        this.i.gv();
    }
    /**
     * Forces any pending refresh to the chart to be finished.
    
    *
    * Method `flush` used to Forces any pending deferred work to render on the chart before continuing.
    *
    * ```ts
    * this.chart.flush();
    * ```
    */
    flush() {
        this.i.f7();
    }
    /**
     * Hides the active main tooltip, if displayed.
    
    *
    * Use the `hideToolTip` method to hide the active tooltip.
    *
    * ```ts
    * this.chart.hideToolTip();
    * ```
    */
    hideToolTip() {
        this.i.ga();
    }
    notifySetItem(source_, index, oldItem, newItem) {
        this.i.gu(source_, index, oldItem, newItem);
    }
    /**
     * Used to manually notify the chart that the data source has reset or cleared its items.
    
    *
    * Use `notifyClearItems` method to notifies the chart that the items have been cleared from an associated data source.
    *
    * ```ts
    * this.chart.notifyClearItems(this.data);
    * ```
    */
    notifyClearItems(source_) {
        this.i.gq(source_);
    }
    notifyInsertItem(source_, index, newItem) {
        this.i.gr(source_, index, newItem);
    }
    notifyRemoveItem(source_, index, oldItem) {
        this.i.gs(source_, index, oldItem);
    }
    /**
     * Event raised when a series is initialized and added to this chart.
    *
    * `SeriesAdded` event raised when a series is initialized and added to this chart.
    *
    * ```ts
    * CategoryChart_SeriesAdded(sender:any ,aregs:ChartSeriesEventArgs)
    * {
    * }
    * ```
    */
    get seriesAdded() {
        return this._seriesAdded;
    }
    set seriesAdded(ev) {
        if (this._seriesAdded_wrapped !== null) {
            this.i.seriesAdded = delegateRemove(this.i.seriesAdded, this._seriesAdded_wrapped);
            this._seriesAdded_wrapped = null;
            this._seriesAdded = null;
        }
        this._seriesAdded = ev;
        this._seriesAdded_wrapped = (o, e) => {
            let outerArgs = new ChartSeriesEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesAdded) {
                this.beforeSeriesAdded(this, outerArgs);
            }
            if (this._seriesAdded) {
                this._seriesAdded(this, outerArgs);
            }
        };
        this.i.seriesAdded = delegateCombine(this.i.seriesAdded, this._seriesAdded_wrapped);
    }
    /**
     * Event raised when a series is removed from this chart.
    *
    * `SeriesRemoved` event raised when a series is removed from this chart.
    *
    * ```ts
    *  CategoryChart_seriesRemoved(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesRemoved() {
        return this._seriesRemoved;
    }
    set seriesRemoved(ev) {
        if (this._seriesRemoved_wrapped !== null) {
            this.i.seriesRemoved = delegateRemove(this.i.seriesRemoved, this._seriesRemoved_wrapped);
            this._seriesRemoved_wrapped = null;
            this._seriesRemoved = null;
        }
        this._seriesRemoved = ev;
        this._seriesRemoved_wrapped = (o, e) => {
            let outerArgs = new ChartSeriesEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesRemoved) {
                this.beforeSeriesRemoved(this, outerArgs);
            }
            if (this._seriesRemoved) {
                this._seriesRemoved(this, outerArgs);
            }
        };
        this.i.seriesRemoved = delegateCombine(this.i.seriesRemoved, this._seriesRemoved_wrapped);
    }
    /**
     * Occurs when the pointer enters a Series.
    *
    * `SeriesPointerEnter` event raised when the pointer enters a Series.
    *
    * ```ts
    * CategoryChart_seriesPointerEnter(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesPointerEnter() {
        return this._seriesPointerEnter;
    }
    set seriesPointerEnter(ev) {
        if (this._seriesPointerEnter_wrapped !== null) {
            this.i.seriesPointerEnter = delegateRemove(this.i.seriesPointerEnter, this._seriesPointerEnter_wrapped);
            this._seriesPointerEnter_wrapped = null;
            this._seriesPointerEnter = null;
        }
        this._seriesPointerEnter = ev;
        this._seriesPointerEnter_wrapped = (o, e) => {
            let outerArgs = new DomainChartSeriesPointerEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesPointerEnter) {
                this.beforeSeriesPointerEnter(this, outerArgs);
            }
            if (this._seriesPointerEnter) {
                this._seriesPointerEnter(this, outerArgs);
            }
        };
        this.i.seriesPointerEnter = delegateCombine(this.i.seriesPointerEnter, this._seriesPointerEnter_wrapped);
    }
    /**
     * Occurs when the pointer leaves a Series.
    *
    * `SeriesPointerLeave` event raised when the pointer leaves a Series.
    *
    * ```ts
    * CategoryChart_seriesPointerLeave(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesPointerLeave() {
        return this._seriesPointerLeave;
    }
    set seriesPointerLeave(ev) {
        if (this._seriesPointerLeave_wrapped !== null) {
            this.i.seriesPointerLeave = delegateRemove(this.i.seriesPointerLeave, this._seriesPointerLeave_wrapped);
            this._seriesPointerLeave_wrapped = null;
            this._seriesPointerLeave = null;
        }
        this._seriesPointerLeave = ev;
        this._seriesPointerLeave_wrapped = (o, e) => {
            let outerArgs = new DomainChartSeriesPointerEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesPointerLeave) {
                this.beforeSeriesPointerLeave(this, outerArgs);
            }
            if (this._seriesPointerLeave) {
                this._seriesPointerLeave(this, outerArgs);
            }
        };
        this.i.seriesPointerLeave = delegateCombine(this.i.seriesPointerLeave, this._seriesPointerLeave_wrapped);
    }
    /**
     * Occurs when the pointer moves over a Series.
    *
    * `SeriesPointerMove` event raised when the pointer moves over a Series.
    *
    * ```ts
    *  CategoryChart_seriesPointerMove(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesPointerMove() {
        return this._seriesPointerMove;
    }
    set seriesPointerMove(ev) {
        if (this._seriesPointerMove_wrapped !== null) {
            this.i.seriesPointerMove = delegateRemove(this.i.seriesPointerMove, this._seriesPointerMove_wrapped);
            this._seriesPointerMove_wrapped = null;
            this._seriesPointerMove = null;
        }
        this._seriesPointerMove = ev;
        this._seriesPointerMove_wrapped = (o, e) => {
            let outerArgs = new DomainChartSeriesPointerEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesPointerMove) {
                this.beforeSeriesPointerMove(this, outerArgs);
            }
            if (this._seriesPointerMove) {
                this._seriesPointerMove(this, outerArgs);
            }
        };
        this.i.seriesPointerMove = delegateCombine(this.i.seriesPointerMove, this._seriesPointerMove_wrapped);
    }
    /**
     * Occurs when the pointer is pressed down over a Series.
    *
    * `SeriesPointerDown` event raised when the pointer is pressed down over a Series
    *
    * ```ts
    * CategoryChart_seriesPointerDown(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesPointerDown() {
        return this._seriesPointerDown;
    }
    set seriesPointerDown(ev) {
        if (this._seriesPointerDown_wrapped !== null) {
            this.i.seriesPointerDown = delegateRemove(this.i.seriesPointerDown, this._seriesPointerDown_wrapped);
            this._seriesPointerDown_wrapped = null;
            this._seriesPointerDown = null;
        }
        this._seriesPointerDown = ev;
        this._seriesPointerDown_wrapped = (o, e) => {
            let outerArgs = new DomainChartSeriesPointerEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesPointerDown) {
                this.beforeSeriesPointerDown(this, outerArgs);
            }
            if (this._seriesPointerDown) {
                this._seriesPointerDown(this, outerArgs);
            }
        };
        this.i.seriesPointerDown = delegateCombine(this.i.seriesPointerDown, this._seriesPointerDown_wrapped);
    }
    /**
     * Occurs when the pointer is released over a Series.
    *
    * `SeriesPointerUp` event raised when the pointer is released over a Series.
    *
    * ```ts
    *  CategoryChart_seriesPointerUp(sender: any , aregs: ChartSeriesEventArgs)
    *   {
    *
    *   }
    * ```
    */
    get seriesPointerUp() {
        return this._seriesPointerUp;
    }
    set seriesPointerUp(ev) {
        if (this._seriesPointerUp_wrapped !== null) {
            this.i.seriesPointerUp = delegateRemove(this.i.seriesPointerUp, this._seriesPointerUp_wrapped);
            this._seriesPointerUp_wrapped = null;
            this._seriesPointerUp = null;
        }
        this._seriesPointerUp = ev;
        this._seriesPointerUp_wrapped = (o, e) => {
            let outerArgs = new DomainChartSeriesPointerEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesPointerUp) {
                this.beforeSeriesPointerUp(this, outerArgs);
            }
            if (this._seriesPointerUp) {
                this._seriesPointerUp(this, outerArgs);
            }
        };
        this.i.seriesPointerUp = delegateCombine(this.i.seriesPointerUp, this._seriesPointerUp_wrapped);
    }
    /**
     * Occurs when the style of a callout is updated.
    */
    get calloutStyleUpdating() {
        return this._calloutStyleUpdating;
    }
    set calloutStyleUpdating(ev) {
        if (this._calloutStyleUpdating_wrapped !== null) {
            this.i.calloutStyleUpdating = delegateRemove(this.i.calloutStyleUpdating, this._calloutStyleUpdating_wrapped);
            this._calloutStyleUpdating_wrapped = null;
            this._calloutStyleUpdating = null;
        }
        this._calloutStyleUpdating = ev;
        this._calloutStyleUpdating_wrapped = (o, e) => {
            let outerArgs = new CalloutStyleUpdatingEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeCalloutStyleUpdating) {
                this.beforeCalloutStyleUpdating(this, outerArgs);
            }
            if (this._calloutStyleUpdating) {
                this._calloutStyleUpdating(this, outerArgs);
            }
        };
        this.i.calloutStyleUpdating = delegateCombine(this.i.calloutStyleUpdating, this._calloutStyleUpdating_wrapped);
    }
}
