import * as tslib_1 from "tslib";
import * as React from 'react';
import { HorizontalAlignment_$type } from "igniteui-react-core/ES5/HorizontalAlignment";
import { UnknownValuePlotting_$type } from "igniteui-react-core/ES5/UnknownValuePlotting";
import { TrendLineType_$type } from "igniteui-react-core/ES5/TrendLineType";
import { ChartSeriesEventArgs } from './igr-chart-series-event-args';
import { brushToString, stringToBrush, toBrushCollection, fromBrushCollection, fromRect, toRect, ensureBool, ensureEnum, isValidProp, getModifiedProps } from "igniteui-react-core/ES5/componentUtil";
import { MarkerType_$type } from "./MarkerType";
import { delegateCombine, delegateRemove } from "igniteui-react-core/ES5/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/ES5/SyncableObservableCollection$1";
import { ToolTipType_$type } from "igniteui-react-charts/ES5/ToolTipType";
import { CrosshairsDisplayMode_$type } from "igniteui-react-charts/ES5/CrosshairsDisplayMode";
import { CalloutStyleUpdatingEventArgs } from "igniteui-react-charts/ES5/igr-callout-style-updating-event-args";
var IgrDomainChart = /** @class */ (function (_super) {
    tslib_1.__extends(IgrDomainChart, _super);
    function IgrDomainChart(props) {
        var _this = _super.call(this, props) || this;
        _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();
        return _this;
    }
    IgrDomainChart.prototype.createImplementation = function () {
        return null;
    };
    Object.defineProperty(IgrDomainChart.prototype, "i", {
        get: function () {
            return this._implementation;
        },
        enumerable: true,
        configurable: true
    });
    IgrDomainChart.prototype.onImplementationCreated = function () {
    };
    Object.defineProperty(IgrDomainChart.prototype, "hasUserValues", {
        get: function () {
            return this._hasUserValues;
        },
        enumerable: true,
        configurable: true
    });
    IgrDomainChart.prototype.componentDidMount = function () {
        var e_1, _a;
        try {
            for (var _b = tslib_1.__values(Object.keys(this.props)), _c = _b.next(); !_c.done; _c = _b.next()) {
                var p = _c.value;
                if (isValidProp(this, p)) {
                    this._hasUserValues.add(p);
                    this[p] = this.props[p];
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_1) throw e_1.error; }
        }
    };
    IgrDomainChart.prototype.shouldComponentUpdate = function (nextProps, nextState) {
        var e_2, _a;
        var mod = getModifiedProps(this.props, nextProps);
        try {
            for (var _b = tslib_1.__values(Object.keys(mod)), _c = _b.next(); !_c.done; _c = _b.next()) {
                var p = _c.value;
                if (isValidProp(this, p)) {
                    this._hasUserValues.add(p);
                    this[p] = mod[p];
                }
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_2) throw e_2.error; }
        }
        return true;
    };
    IgrDomainChart.prototype.render = function () {
        return null;
    };
    Object.defineProperty(IgrDomainChart.prototype, "tooltipTemplate", {
        /**
        * Sets or gets the template reference to use for tooltips for all the series.
        *
        *
        */
        get: function () {
            return this.i.tooltipTemplate;
        },
        set: function (v) {
            this.i.tooltipTemplate = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "tooltipTemplates", {
        /**
        * Sets or gets the template references to use for tooltips for all the series, in order.
        *
        *
        */
        get: function () {
            var ret = [];
            if (this.i.tooltipTemplates) {
                for (var ii = 0; ii < this.i.tooltipTemplates.count; ii++) {
                    ret.push(this.i.tooltipTemplates.item(ii));
                }
            }
            return ret;
        },
        set: function (v) {
            this.i.tooltipTemplates.clear();
            if (v) {
                for (var ii = 0; ii < v.length; ii++) {
                    this.i.tooltipTemplates.add(v[ii]);
                }
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "legend", {
        get: function () {
            if (this.i.legend != null)
                return this.i.legend.externalObject;
        },
        set: function (v) {
            if (v != undefined && v != null)
                this.i.legend = v.i;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsDataSource", {
        get: function () {
            return this._calloutsDataSource;
        },
        set: function (value) {
            this._calloutsDataSource = value;
            this.bindCalloutsData();
        },
        enumerable: true,
        configurable: true
    });
    IgrDomainChart.prototype.bindCalloutsData = function () {
        if (this.i != null && this.i !== undefined) {
            this.i.calloutsItemsSource = this._calloutsDataSource;
        }
    };
    Object.defineProperty(IgrDomainChart.prototype, "pixelScalingRatio", {
        /**
     * 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: function () {
            return this.i.ct;
        },
        set: function (v) {
            this.i.ct = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleLeftMargin", {
        /**
         * Gets or sets the left margin of chart title
        */
        get: function () {
            return this.i.c2;
        },
        set: function (v) {
            this.i.c2 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleRightMargin", {
        /**
         * Gets or sets the right margin of chart title
        */
        get: function () {
            return this.i.c3;
        },
        set: function (v) {
            this.i.c3 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleTopMargin", {
        /**
         * Gets or sets the top margin of chart title
        */
        get: function () {
            return this.i.c4;
        },
        set: function (v) {
            this.i.c4 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleBottomMargin", {
        /**
         * Gets or sets the bottom margin of chart title
        */
        get: function () {
            return this.i.c1;
        },
        set: function (v) {
            this.i.c1 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleLeftMargin", {
        /**
         * Gets or sets the left margin of chart subtitle
        */
        get: function () {
            return this.i.cx;
        },
        set: function (v) {
            this.i.cx = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleTopMargin", {
        /**
         * Gets or sets the top margin of chart subtitle
        */
        get: function () {
            return this.i.cz;
        },
        set: function (v) {
            this.i.cz = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleRightMargin", {
        /**
         * Gets or sets the right margin of chart subtitle
        */
        get: function () {
            return this.i.cy;
        },
        set: function (v) {
            this.i.cy = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleBottomMargin", {
        /**
         * Gets or sets the bottom margin of chart subtitle
        */
        get: function () {
            return this.i.cw;
        },
        set: function (v) {
            this.i.cw = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleTextColor", {
        /**
         * Gets or sets color of chart subtitle
        */
        get: function () {
            return brushToString(this.i.h1);
        },
        set: function (v) {
            this.i.h1 = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleTextColor", {
        /**
         * Gets or sets color of chart title
        */
        get: function () {
            return brushToString(this.i.h2);
        },
        set: function (v) {
            this.i.h2 = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "leftMargin", {
        /**
         * Gets or sets the left margin of the chart content.
        */
        get: function () {
            return this.i.cs;
        },
        set: function (v) {
            this.i.cs = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "topMargin", {
        /**
         * Gets or sets the top margin of the chart content.
        */
        get: function () {
            return this.i.c5;
        },
        set: function (v) {
            this.i.c5 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "rightMargin", {
        /**
         * Gets or sets the right margin of the chart content.
        */
        get: function () {
            return this.i.cv;
        },
        set: function (v) {
            this.i.cv = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "bottomMargin", {
        /**
         * Gets or sets the bottom margin around the chart content.
        */
        get: function () {
            return this.i.cr;
        },
        set: function (v) {
            this.i.cr = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "transitionDuration", {
        /**
         * Gets or sets the duration used for animating series plots when the data is changing
        */
        get: function () {
            return this.i.de;
        },
        set: function (v) {
            this.i.de = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "transitionEasingFunction", {
        /**
         * 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.
        */
        get: function () {
            return this.i.a1;
        },
        set: function (v) {
            this.i.a1 = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleTextStyle", {
        /**
         * Gets or sets CSS font property for the chart subtitle
        */
        get: function () {
            return this.i.e9;
        },
        set: function (v) {
            this.i.e9 = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleTextStyle", {
        /**
         * Gets or sets CSS font property for the chart title
        */
        get: function () {
            return this.i.fk;
        },
        set: function (v) {
            this.i.fk = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "includedProperties", {
        /**
         * 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.
        */
        get: function () {
            return this.i.d;
        },
        set: function (v) {
            this.i.d = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "excludedProperties", {
        /**
         * Gets or sets a set of property paths that should be excluded from consideration by the category chart.
        */
        get: function () {
            return this.i.c;
        },
        set: function (v) {
            this.i.c = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "brushes", {
        /**
         * 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
        */
        get: function () {
            return fromBrushCollection(this.i.j);
        },
        set: function (v) {
            this.i.j = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "outlines", {
        /**
         * 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
        */
        get: function () {
            return fromBrushCollection(this.i.n);
        },
        set: function (v) {
            this.i.n = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "isHorizontalZoomEnabled", {
        /**
         * Gets or sets whether the chart can be horizontally zoomed through user interactions.
        */
        get: function () {
            return this.i.bq;
        },
        set: function (v) {
            this.i.bq = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "isVerticalZoomEnabled", {
        /**
         * Gets or sets whether the chart can be vertically zoomed through user interactions.
        */
        get: function () {
            return this.i.bw;
        },
        set: function (v) {
            this.i.bw = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "isSeriesHighlightingEnabled", {
        /**
         * Gets or sets whether the chart can highlight series through user interactions.
         * This property applies to Category Chart and Financial Chart controls.
        */
        get: function () {
            return this.i.bs;
        },
        set: function (v) {
            this.i.bs = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "windowRect", {
        /**
         * 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.
        */
        get: function () {
            return fromRect(this.i.h6);
        },
        set: function (v) {
            this.i.h6 = toRect(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "viewport", {
        /**
         * Gets a rectangle representing the bounds of the plot area.
        */
        get: function () {
            return fromRect(this.i.h5);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "chartTitle", {
        /**
         * Gets or sets text to display above the plot area.
        */
        get: function () {
            return this.i.fd;
        },
        set: function (v) {
            this.i.fd = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitle", {
        /**
         * Gets or sets text to display below the Title, above the plot area.
        */
        get: function () {
            return this.i.e2;
        },
        set: function (v) {
            this.i.e2 = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "titleAlignment", {
        /**
         * Gets or sets horizontal alignment which determines the title position, relative to the left and right edges of the control.
        */
        get: function () {
            return this.i.hu;
        },
        set: function (v) {
            this.i.hu = ensureEnum(HorizontalAlignment_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "subtitleAlignment", {
        /**
         * Gets or sets horizontal alignment which determines the subtitle position, relative to the left and right edges of the control.
        */
        get: function () {
            return this.i.ht;
        },
        set: function (v) {
            this.i.ht = ensureEnum(HorizontalAlignment_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "unknownValuePlotting", {
        /**
         * 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.
        */
        get: function () {
            return this.i.ax;
        },
        set: function (v) {
            this.i.ax = ensureEnum(UnknownValuePlotting_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "resolution", {
        /**
         * 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.
        */
        get: function () {
            return this.i.cu;
        },
        set: function (v) {
            this.i.cu = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "thickness", {
        /**
         * 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.
        */
        get: function () {
            return this.i.c0;
        },
        set: function (v) {
            this.i.c0 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "markerTypes", {
        /**
         * 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: function () {
            if (this._markerTypes === null) {
                var coll = new MarkerTypeCollection();
                var innerColl = this.i.ak;
                if (!innerColl) {
                    innerColl = new MarkerTypeCollection_internal();
                }
                this._markerTypes = coll._fromInner(innerColl);
                this.i.ak = innerColl;
            }
            return this._markerTypes;
        },
        set: function (v) {
            if (this._markerTypes !== null) {
                this._markerTypes._setSyncTarget(null);
                this._markerTypes = null;
            }
            var coll = new MarkerTypeCollection();
            this._markerTypes = coll._fromOuter(v);
            var syncColl = new SyncableObservableCollection$1(MarkerType_$type);
            var innerColl = this.i.ak;
            if (!innerColl) {
                innerColl = new MarkerTypeCollection_internal();
            }
            syncColl._inner = innerColl;
            syncColl.clear();
            this._markerTypes._setSyncTarget(syncColl);
            this.i.ak = innerColl;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "markerBrushes", {
        /**
         * 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
        */
        get: function () {
            return fromBrushCollection(this.i.l);
        },
        set: function (v) {
            this.i.l = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "markerOutlines", {
        /**
         * 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
        */
        get: function () {
            return fromBrushCollection(this.i.m);
        },
        set: function (v) {
            this.i.m = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "markerMaxCount", {
        /**
         * Gets or sets the maximum number of markers displyed in the plot area of the chart.
        */
        get: function () {
            return this.i.dd;
        },
        set: function (v) {
            this.i.dd = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "animateSeriesWhenAxisRangeChanges", {
        /**
         * Gets or sets whether the series animations should be allowed when a range change has been detected on an axis.
        */
        get: function () {
            return this.i.bg;
        },
        set: function (v) {
            this.i.bg = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "trendLineBrushes", {
        /**
         * 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
        */
        get: function () {
            return fromBrushCollection(this.i.o);
        },
        set: function (v) {
            this.i.o = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "trendLineType", {
        /**
         * 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
        */
        get: function () {
            return this.i.av;
        },
        set: function (v) {
            this.i.av = ensureEnum(TrendLineType_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "trendLineThickness", {
        /**
         * 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
        */
        get: function () {
            return this.i.c6;
        },
        set: function (v) {
            this.i.c6 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "alignsGridLinesToPixels", {
        /**
         * Gets or sets a value indicating whether grid and tick lines are aligned to device pixels.
        */
        get: function () {
            return this.i.bf;
        },
        set: function (v) {
            this.i.bf = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "trendLinePeriod", {
        get: function () {
            return this.i.df;
        },
        set: function (v) {
            this.i.df = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "toolTipType", {
        /**
         * Gets or sets the style of tooltip to be displayed.
        */
        get: function () {
            return this.i.at;
        },
        set: function (v) {
            this.i.at = ensureEnum(ToolTipType_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "crosshairsDisplayMode", {
        /**
         * Gets or sets the crosshairs to be displayed.
        */
        get: function () {
            return this.i.t;
        },
        set: function (v) {
            this.i.t = ensureEnum(CrosshairsDisplayMode_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "crosshairsSnapToData", {
        /**
         * Gets or sets whether crosshairs will snap to the nearest data point.
        */
        get: function () {
            return this.i.bl;
        },
        set: function (v) {
            this.i.bl = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "crosshairsAnnotationEnabled", {
        /**
         * Gets or sets whether annotations are shown along the axis for crosshair values
        */
        get: function () {
            return this.i.bk;
        },
        set: function (v) {
            this.i.bk = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "finalValueAnnotationsVisible", {
        /**
         * Gets or sets whether annotations for the final value of each series is displayed on the axis.
        */
        get: function () {
            return this.i.bm;
        },
        set: function (v) {
            this.i.bm = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsVisible", {
        /**
         * Gets or sets if callouts should be displayed.
        */
        get: function () {
            return this.i.bj;
        },
        set: function (v) {
            this.i.bj = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutStyleUpdatingEventEnabled", {
        /**
         * Gets or sets if event annotations should be displayed.
        */
        get: function () {
            return this.i.bi;
        },
        set: function (v) {
            this.i.bi = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsXMemberPath", {
        /**
         * Gets or sets the member path of the X data for the callouts.
        */
        get: function () {
            return this.i.ea;
        },
        set: function (v) {
            this.i.ea = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsYMemberPath", {
        /**
         * Gets or sets the member path of the Y data for the callouts.
        */
        get: function () {
            return this.i.ec;
        },
        set: function (v) {
            this.i.ec = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsLabelMemberPath", {
        /**
         * Gets or sets the member path of the label data for the callouts.
        */
        get: function () {
            return this.i.d6;
        },
        set: function (v) {
            this.i.d6 = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutsContentMemberPath", {
        /**
         * Gets or sets the member path of the content data for the callouts.
        */
        get: function () {
            return this.i.d3;
        },
        set: function (v) {
            this.i.d3 = v;
        },
        enumerable: true,
        configurable: true
    });
    /**
 * Provides a container for this control

*/
    IgrDomainChart.prototype.provideContainer = function (container) {
        this.i.provideContainer(container);
    };
    /**
     * Destroy this control
    
    */
    IgrDomainChart.prototype.destroy = function () {
        this.i.destroy();
    };
    /**
     * Called when the control has been resized.
    
    */
    IgrDomainChart.prototype.notifyResized = function () {
        this.i.notifyResized();
    };
    IgrDomainChart.prototype.notifyVisualPropertiesChanged = function () {
        this.i.gv();
    };
    /**
     * Forces any pending refresh to the chart to be finished.
    
    */
    IgrDomainChart.prototype.flush = function () {
        this.i.f7();
    };
    /**
     * Hides the active main tooltip, if displayed.
    
    */
    IgrDomainChart.prototype.hideToolTip = function () {
        this.i.ga();
    };
    IgrDomainChart.prototype.notifySetItem = function (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.
    
    */
    IgrDomainChart.prototype.notifyClearItems = function (source_) {
        this.i.gq(source_);
    };
    IgrDomainChart.prototype.notifyInsertItem = function (source_, index, newItem) {
        this.i.gr(source_, index, newItem);
    };
    IgrDomainChart.prototype.notifyRemoveItem = function (source_, index, oldItem) {
        this.i.gs(source_, index, oldItem);
    };
    Object.defineProperty(IgrDomainChart.prototype, "seriesAdded", {
        /**
         * Event raised when a series is initialized and added to this chart.
        */
        get: function () {
            return this._seriesAdded;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesRemoved", {
        /**
         * Event raised when a series is removed from this chart.
        */
        get: function () {
            return this._seriesRemoved;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesPointerEnter", {
        /**
         * Occurs when the pointer enters a Series.
        */
        get: function () {
            return this._seriesPointerEnter;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesPointerLeave", {
        /**
         * Occurs when the pointer leaves a Series.
        */
        get: function () {
            return this._seriesPointerLeave;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesPointerMove", {
        /**
         * Occurs when the pointer moves over a Series.
        */
        get: function () {
            return this._seriesPointerMove;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesPointerDown", {
        /**
         * Occurs when the pointer is pressed down over a Series.
        */
        get: function () {
            return this._seriesPointerDown;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "seriesPointerUp", {
        /**
         * Occurs when the pointer is released over a Series.
        */
        get: function () {
            return this._seriesPointerUp;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrDomainChart.prototype, "calloutStyleUpdating", {
        /**
         * Occurs when the style of a callout is updated.
        */
        get: function () {
            return this._calloutStyleUpdating;
        },
        set: function (ev) {
            var _this = this;
            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 = function (o, e) {
                var 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);
        },
        enumerable: true,
        configurable: true
    });
    return IgrDomainChart;
}(React.Component));
export { IgrDomainChart };
