/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import * as tslib_1 from "tslib";
import * as React from 'react';
import { Visibility_$type } from "igniteui-react-core/ES5/Visibility";
import { TransitionInSpeedType_$type } from './TransitionInSpeedType';
import { SeriesHitTestMode_$type } from './SeriesHitTestMode';
import { brushToString, stringToBrush, toPoint, fromPoint, fromRect, stringToColor, colorToString, ensureEnum, ensureBool, isValidProp, getModifiedProps } from "igniteui-react-core/ES5/componentUtil";
import { RenderRequestedEventArgs } from './RenderRequestedEventArgs';
import { delegateCombine, delegateRemove, TypeRegistrar } from "igniteui-react-core/ES5/type";
/**
 * Represents the base class for all IgxDataChartComponent series.
*/
var IgrSeries = /** @class */ (function (_super) {
    tslib_1.__extends(IgrSeries, _super);
    function IgrSeries(props) {
        var _this = _super.call(this, props) || this;
        _this._chartLevelData = null;
        _this._dataSource = null;
        _this._tooltipTemplate = null;
        _this._tooltipContent = null;
        _this._tooltipContainerTemplate = null;
        _this._renderer = null;
        _this._renderRequested = null;
        _this._renderRequested_wrapped = null;
        _this._implementation = _this.createImplementation();
        _this._implementation.externalObject = _this;
        _this.onImplementationCreated();
        return _this;
    }
    Object.defineProperty(IgrSeries.prototype, "i", {
        get: function () {
            return this._implementation;
        },
        enumerable: true,
        configurable: true
    });
    IgrSeries.prototype.onImplementationCreated = function () {
    };
    IgrSeries.prototype.createImplementation = function () {
        return null;
    };
    IgrSeries.prototype.initializeProperties = 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[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; }
        }
    };
    IgrSeries.prototype.componentDidMount = function () {
        this.initializeProperties();
    };
    Object.defineProperty(IgrSeries.prototype, "seriesInternal", {
        get: function () {
            return this.i;
        },
        enumerable: true,
        configurable: true
    });
    IgrSeries.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[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;
    };
    IgrSeries.prototype.render = function () {
        return null;
    };
    Object.defineProperty(IgrSeries.prototype, "name", {
        get: function () {
            return this.i.name;
        },
        set: function (value) {
            this.i.name = value;
        },
        enumerable: true,
        configurable: true
    });
    IgrSeries.prototype.provideData = function (data) {
        this._chartLevelData = data;
        this.updateDataSource();
    };
    IgrSeries.prototype.updateDataSource = function () {
        if (this._dataSource == null) {
            this.i.itemsSource = this._chartLevelData;
        }
        else {
            this.i.itemsSource = this._dataSource;
        }
    };
    Object.defineProperty(IgrSeries.prototype, "dataSource", {
        get: function () {
            if (this._dataSource != null) {
                return this._dataSource;
            }
            return this.i.itemsSource;
        },
        set: function (value) {
            this._dataSource = value;
            this.updateDataSource();
            //console.log("setting axis data source: " + value)
        },
        enumerable: true,
        configurable: true
    });
    IgrSeries.prototype.bindAxes = function (axes) {
    };
    Object.defineProperty(IgrSeries.prototype, "tooltipTemplate", {
        get: function () {
            return this._tooltipTemplate;
        },
        set: function (value) {
            this._tooltipTemplate = value;
            if (value == null) {
                if (this._tooltipContent !== null) {
                    //this._tooltipContent.destroy();
                    this._tooltipContent = null;
                }
            }
            if (this._tooltipContent != null) {
                this._tooltipContent.template = this._tooltipTemplate;
            }
            else {
                if (this.owner != null) {
                    this.owner._ensureTooltipCreated(this);
                }
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "tooltipContainerTemplate", {
        get: function () {
            return this._tooltipContainerTemplate;
        },
        set: function (value) {
            this._tooltipContainerTemplate = value;
            if (this._tooltipContent != null) {
                this._tooltipContent.instance.containerTemplate = this._tooltipContainerTemplate;
            }
        },
        enumerable: true,
        configurable: true
    });
    IgrSeries.prototype._ensureTooltipCreated = function (createTooltip, createWrapper) {
        if (this._tooltipTemplate == null) {
            this.i.toolTip = null;
        }
        if (this._tooltipContent == null && this._tooltipTemplate != null) {
            var tooltip = createTooltip();
            if (tooltip == null) {
                return;
            }
            this._tooltipContent = tooltip;
            tooltip.tooltipTemplate = this._tooltipTemplate;
            this.i.toolTip = createWrapper(tooltip);
        }
    };
    IgrSeries.prototype._ensureTooltipDestroyed = function () {
        if (this._tooltipContent !== null) {
            //this._tooltipContent.destroy();
            this._tooltipContent = null;
        }
    };
    IgrSeries.prototype._provideRenderer = function (renderer) {
        this._renderer = renderer;
    };
    IgrSeries._createFromInternal = function (internal) {
        if (!internal) {
            return null;
        }
        if (!internal.$type) {
            return null;
        }
        var name = internal.$type.name;
        var externalName = "Igr" + name;
        if (!TypeRegistrar.isRegistered(externalName)) {
            return null;
        }
        return TypeRegistrar.create(externalName);
    };
    Object.defineProperty(IgrSeries.prototype, "isAnnotationLayer", {
        /**
     * Gets whether the series is an annotation layer.
    *
    * ```ts
    * let isAnnotationLayer: boolean = this.series.isAnnotationLayer;
    * ```
    */
        get: function () {
            return this.i.cj;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isVertical", {
        /**
         * Gets whether the current series is oriented vertically.
        *
        * ```ts
        * let isVertical: boolean = this.series.isVertical;
        * ```
        */
        get: function () {
            return this.i.isVertical;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isFragment", {
        /**
         * Gets whether the current series is a stack fragment.
        *
        * ```ts
        * let isFragment: boolean = this.series.isFragment;
        * ```
        */
        get: function () {
            return this.i.cs;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isAreaOrLine", {
        /**
         * Gets whether the current series shows an area or line shape.
        *
        * ```ts
        * let isAreaorLine: boolean = this.series.isAreaorLine;
        * ```
        */
        get: function () {
            return this.i.ck;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isPolar", {
        /**
         * Gets whether the current series is a polar type series.
        *
        * ```ts
        * let isPolar: boolean = this.series.isPolar;
        * ```
        */
        get: function () {
            return this.i.c0;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isScatter", {
        /**
         * Gets whether the current series is a scatter type series.
        *
        * ```ts
        * let isScatter: boolean = this.series.isScatter;
        * ```
        */
        get: function () {
            return this.i.c4;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isRadial", {
        /**
         * Gets whether the current series is a radial type series.
        *
        * ```ts
        * let isRadial: boolean = this.series.isRadial;
        * ```
        */
        get: function () {
            return this.i.c2;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isStacked", {
        /**
         * Gets whether the current series is a stacked type series.
        *
        * ```ts
        * let isStacked: boolean = this.series.isStacked;
        * ```
        */
        get: function () {
            return this.i.isStacked;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isFinancial", {
        /**
         * Gets whether the current series is a financial type series.
        *
        * ```ts
        * let isFinancial: boolean = this.series.isFinancial;
        * ```
        */
        get: function () {
            return this.i.cr;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isRange", {
        /**
         * Gets whether the current series is a range type series.
        *
        * ```ts
        * let isRange: boolean = this.series.isRange;
        * ```
        */
        get: function () {
            return this.i.c3;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isCategory", {
        /**
         * Gets whether the current series is a category type series.
        *
        * ```ts
        * let isCategory: boolean = this.series.isCategory;
        * ```
        */
        get: function () {
            return this.i.cl;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isGeographic", {
        /**
         * Gets whether the current seires is a geogrpahic series.
        *
        * ```ts
        * let isGeographic: boolean = this.series.isGeographic;
        * ```
        */
        get: function () {
            return this.i.ct;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isShape", {
        /**
         * Gets whether the current series is a shape type series.
        */
        get: function () {
            return this.i.c5;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isDefaultCrosshairBehaviorDisabled", {
        /**
         * Gets whether the default crosshair behavior should be disabled if this series is present.
        *
        * `isDefaultCrosshairBehaviorDisabled` defaults to true for annotation layers. When not using annotaion layers, you can show crosshairs by setting the chart's `CrosshairVisibility` to true.
        *
        * ```ts
        * let isDefaultCrosshairBehaviorDisabled: boolean = this.series.isDefaultCrosshairBehaviorDisabled;
        * ```
        */
        get: function () {
            return this.i.cm;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isDefaultTooltipBehaviorDisabled", {
        /**
         * Gets whether the default tooltip behavior should be disabled if this series is present.
        *
        * ```ts
        *  let isDefaultTooltipBehaviorDisabled: boolean = this.series.isDefaultTooltipBehaviorDisabled;
        * ```
        */
        get: function () {
            return this.i.cn;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "hasMarkers", {
        /**
         * Returns whether the current series supports visual markers.
        *
        * ```ts
        * let hasMarkers: boolean = this.series.hasMarkers;
        * ```
        */
        get: function () {
            return this.i.hasMarkers;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isIndexed", {
        /**
         * Gets if the series uses an index, which can be used to auto-assign it a color.
        *
        * ```ts
        * let isIndexed: boolean = this.series.isIndexed;
        * ```
        */
        get: function () {
            return this.i.cw;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isUsableInLegend", {
        /**
         * Gets if the series should appear in any legends.
        *
        * ```ts
        * let isUsableInLegend: boolean = this.series.isUsableInLegend;
        * ```
        */
        get: function () {
            return this.i.isUsableInLegend;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "legendItemVisibility", {
        /**
         * Gets or sets the legend item visibility for the current series object.
        *
        * The `LegendItemVisibilty` can be used to exclude only certain `IgrSeries` from the `IgrLegend`.
        */
        get: function () {
            return this.i.ls;
        },
        set: function (v) {
            this.i.ls = ensureEnum(Visibility_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "legendItemBadgeTemplate", {
        /**
         * Gets or sets the LegendItemBadgeTemplate property.
         * The legend item badge is created according to the LegendItemBadgeTemplate on-demand by
         * the series object itself.
        *
        * The `legendItemBadgeTemplate` is used to describe the visual structure of the badge icon for each legend item.
        */
        get: function () {
            return this.i.legendItemBadgeTemplate;
        },
        set: function (v) {
            this.i.legendItemBadgeTemplate = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "legendItemTemplate", {
        /**
         * Gets or sets the LegendItemTemplate property.
         * The legend item control content is created according to the LegendItemTemplate on-demand by
         * the series object itself.
        *
        * The `legendItemTemplate` is used to describe the visual structure of each legend item in the `IgrLegend`.
        */
        get: function () {
            return this.i.legendItemTemplate;
        },
        set: function (v) {
            this.i.legendItemTemplate = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "discreteLegendItemTemplate", {
        /**
         * Gets or sets the DiscreteLegendItemTemplate property.
         * The legend item control content is created according to the DiscreteLegendItemTemplate on-demand by
         * the series object itself.
        *
        * The legend item control content is created according to the DiscreteLegendItemTemplate on-demand by the series object itself
        */
        get: function () {
            return this.i.jr;
        },
        set: function (v) {
            this.i.jr = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "transitionEasingFunction", {
        /**
         * Gets or sets the easing function used to morph the current series.
        *
        * The `TransitioninDuration` and `transitionEasingFunction` can be used to play animation when data is added or removed from a `IgrSeries`. To play an initial animation see `transitionInDuration`.
        *
        * ```ts
        * this.series.transitionEasingFunction =  EasingFunctions.cubicEase;
        * ```
        */
        get: function () {
            return this.i.bu;
        },
        set: function (v) {
            this.i.bu = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "transitionInEasingFunction", {
        /**
         * Gets or sets the EasingFunction used to morph the current series during the initial transition.
        *
        * The `transitionInEasingFunction` can be used with `IsTransitionInEnabled` to cofigure the animation when a new datasource is loaded.
        *
        * ```ts
        * this.series.transitionInEasingFunction =  EasingFunctions.cubicEase;
        * ```
        */
        get: function () {
            return this.i.bv;
        },
        set: function (v) {
            this.i.bv = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "transitionDuration", {
        /**
         * Gets or sets the duration of the current series's morph.
        *
        * The `transitionDuration` can be used to play animation when data is added or removed from a `IgrSeries`. To play an initial animation see `transitionInDuration`.
        *
        * ```ts
        * this.series.transitionDuration = 500;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isTransitionInEnabled=true
        *     transitionInSpeedType="indexScaled"
        *     transitionDuration=500
        *     transitionInDuration=500 />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.ff;
        },
        set: function (v) {
            this.i.ff = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "resolution", {
        /**
         * Gets or sets the current series object's rendering resolution.
        *
        * Setting the `resolution` on a Series to a higher value can help with performance, but it will lower the graphical fidelity of the line. As such, it can be increased up until the fidelity is unacceptable.
        *
        * ```ts
        * this.series.resolution = 1.5;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     resolution=1.5 />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.er;
        },
        set: function (v) {
            this.i.er = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "title", {
        /**
         * Gets or sets the Title property.
         * The legend item control is created according to the Title on-demand by
         * the series object itself.
        *
        * The `IgrSeries` `title` may be used in tooltips and legends.
        *
        * ```ts
        * this.series.title = "InStock Items";
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *    title="InStock Items" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.fs;
        },
        set: function (v) {
            this.i.fs = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "brush", {
        /**
         * Gets or sets the brush to use for the series.
        *
        * The `brush` along with the `outline` and `Negative Brush` can be used to affect the visuals of the `IgrSeries`.
        *
        * ```ts
        * this.series.brush = "red";
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     brush="Gray"
        *     outline="Black" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return brushToString(this.i.ky);
        },
        set: function (v) {
            this.i.ky = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "actualBrush", {
        /**
         * Gets the effective brush for the current series object.
        *
        * ```ts
        * let actualBrush: string = series.actualBrush;
        * ```
        */
        get: function () {
            return brushToString(this.i.kw);
        },
        set: function (v) {
            this.i.kw = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "outline", {
        /**
         * Gets or sets the brush to use for the outline of the series.
         * Some series types, such as LineSeries, do not display outlines.  Therefore, this property does not affect some charts.
        *
        * The `outline` along with the `brush` and `NegativeBrush` can be used to affect the visuals of the `IgrSeries`.
        *
        * ```ts
        * this.series.brush = "red";
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     brush="Gray"
        *     outline="Black" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return brushToString(this.i.k1);
        },
        set: function (v) {
            this.i.k1 = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "actualOutline", {
        /**
         * Gets the effective outline for the current series object.
        *
        * ```ts
        * let actualOutline: string = series.ActualOutline;
        * ```
        */
        get: function () {
            return brushToString(this.i.kx);
        },
        set: function (v) {
            this.i.kx = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "thickness", {
        /**
         * Gets or sets the width of the current series object's line thickness.
        *
        * Depending on the `IgrSeries` type, this can be the main brush used, or just the outline. For example, when using a `IgrLineSeries` it will affect the thickness of the lines drawn, whereas when using a `IgrColumnSeries` it will affect the outer border thickness of the columns.
        *
        * ```ts
        * this.series.thickness=5;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     thickness=5 />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.ev;
        },
        set: function (v) {
            this.i.ev = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isHighlightingEnabled", {
        /**
         * Gets or sets whether highlighting should be enabled for this series, if this type of series supports highlighting.
        *
        * ```ts
        * this.series.isHighlightingEnabled = true;
        * ```
        *
        * ```ts
        * <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isHighlightingEnabled="true" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.cu;
        },
        set: function (v) {
            this.i.cu = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isDropShadowEnabled", {
        /**
         * Gets or sets whether drop shadow should be enabled for this series.
        *
        * `isDropShadowEnabled` is used to decide whether drop shadow should be enabled for this series.
        *
        * ```ts
        * this.series.isDropShadowEnabled = true;
        * ```
        *
        * ```ts
        * <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isDropShadowEnabled="true" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.cp;
        },
        set: function (v) {
            this.i.cp = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "shadowBlur", {
        /**
         * Gets or sets the shadow blur.
         * This property is ignored when Series.UseSingleShadow is set to true.
        *
        * `shadowBlur` can be set in conjection with `isDropShadowEnabled` to further define the drop shadow effect.
        *
        * ```ts
        * this.series.shadowBlur = 7;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     shadowBlur="7"
        *     shadowColor="blue" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.es;
        },
        set: function (v) {
            this.i.es = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "shadowColor", {
        /**
         * Gets or sets the drop shadow color.
        *
        * `shadowColor` can be set in conjection with `isDropShadowEnabled` to further define the drop shadow effect.
        *
        * ```ts
        * this.series.shadowColor = "blue";
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     shadowBlur="7"
        *     shadowColor="blue" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return colorToString(this.i.k3);
        },
        set: function (v) {
            this.i.k3 = stringToColor(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "useSingleShadow", {
        /**
         * Gets or sets whether drop shadow is applied to the whole series visual or to each of the individual shapes forming the series.
         * When this property is set to true, no Series.ShadowBlur is applied.
        *
        * ```ts
        * this.series.useSingleShadow = true;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isDropShadowEnabled=true
        *     markerType="circle"
        *     useSingleShadow=true />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.dt;
        },
        set: function (v) {
            this.i.dt = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "shadowOffsetX", {
        /**
         * Gets or sets the drop shadow x-offset.
        *
        * `shadowOffsetX` can be set in conjection with `isDropShadowEnabled` to further define the drop shadow effect.
        *
        * ```ts
        * this.series.shadowOffsetX = 10;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     shadowOffsetX="10"
        *     shadowOffsetY="10" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.et;
        },
        set: function (v) {
            this.i.et = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "shadowOffsetY", {
        /**
         * Gets or sets the drop shadow y-offset.
        *
        * `shadowOffsetY` can be set in conjection with `isDropShadowEnabled` to further define the drop shadow effect.
        *
        * ```ts
        * this.series.shadowOffsetY = 10;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     shadowOffsetX="10"
        *     shadowOffsetY="10" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.eu;
        },
        set: function (v) {
            this.i.eu = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "areaFillOpacity", {
        /**
         * Gets or sets the opacity applied to the area fill visual.
         * This property only applies to series that have area visual.
        */
        get: function () {
            return this.i.d4;
        },
        set: function (v) {
            this.i.d4 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "actualAreaFillOpacity", {
        /**
         * Gets the actual opacity applied to the area fill visual.
        *
        * ```ts
        * let actualFillOpacity: number = series.actualAreaFillOpacity;
        * ```
        */
        get: function () {
            return this.i.d3;
        },
        set: function (v) {
            this.i.d3 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isDefaultToolTipSelected", {
        /**
         * Gets if the default tooltip has been selected for display.
        *
        * To use the default tooltip set `showDefaultTooltip` to true.
        *
        * ```ts
        * let isDefaultToolTipSelected: boolean = this.series.isDefaultToolTipSelected;
        * ```
        */
        get: function () {
            return this.i.co;
        },
        set: function (v) {
            this.i.co = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "showDefaultTooltip", {
        /**
         * Gets or sets whether default tooltip will be shown.
        *
        * The default tooltips display all the information relevant to the particular series item (series title, data values, axis values etc.) and are styled to match the series' style. When using default tooltips, you should also set the series `title`.
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     showDefaultTooltip="true"
        *     title="InStock Items" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.dc;
        },
        set: function (v) {
            this.i.dc = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "transitionInDuration", {
        /**
         * Gets or sets the duration of the current series's transition in morph.
        *
        * The `transitionInDuration` can be used with `IsTransitionInEnabled` to cofigure the animation when a new datasource is loaded.
        *
        * ```ts
        * this.series.transitionDuration = 500;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isTransitionInEnabled=true
        *     transitionInSpeedType="indexScaled"
        *     transitionDuration=500
        *     transitionInDuration=500 />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.fg;
        },
        set: function (v) {
            this.i.fg = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "transitionInSpeedType", {
        /**
         * Gets or sets the duration of the current series's transition in morph.
        *
        * The `transitionInSpeedType` can be used with `IsTransitionInEnabled` to cofigure the animation when a new datasource is loaded.
        *
        * ```ts
        * this.series.transitionInSpeedType = TransitionInSpeedType.IndexScaled;
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="Value"
        *     isTransitionInEnabled=true
        *     transitionInSpeedType="indexScaled"
        *     transitionDuration=500
        *     transitionInDuration=500 />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.bp;
        },
        set: function (v) {
            this.i.bp = ensureEnum(TransitionInSpeedType_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "mouseOverEnabled", {
        /**
         * Gets or sets the whether the chart reacts to mouse move events.
        */
        get: function () {
            return this.i.c6;
        },
        set: function (v) {
            this.i.c6 = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "coercionMethods", {
        /**
         * Gets or sets the coercion methods to use when loading data from data sources.
         * Should be specified before setting any member paths, if being used. Setting it later
         * will not cause data to be reimported into the chart.
        *
        * &lt;-- position: content member-->
        *
        * ```ts
        * cMethods: any = {
        *     ValueCoercion: function(value:number): number {return value+2;}
        *  }
        * ```
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource}
        *     width="700px"
        *     height="500px">
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrScatterPolygonSeries
        *      name="series1"
        *      shapeMemberPath="Points"
        *      title="House Floor Plan"
        *      brush="Gray"
        *      outline="Black" />
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.coercionMethods;
        },
        set: function (v) {
            this.i.coercionMethods = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "expectFunctions", {
        /**
         * Gets or sets whether the series should expect that properties in its items source may be functions that need to be
         * evaluated to yield their value. This defaults to false, as there will be a subtle performance impact to using this feature.
         * This value must be set before assigning an item's source to take effect.
        *
        * `expectFunctions` is used to decide whether the series should expect that its data source members need to be called as functions to get their values.
        *
        * ```ts
        *  <IgrDataChart
        *     dataSource={this.state.dataSource} >
        *
        *     <IgrNumericXAxis name="xAxis" />
        *     <IgrNumericYAxis name="yAxis" />
        *
        *     <IgrAreaSeries
        *      name="series1"
        *     xAxisName="xAxis"
        * 	yAxisName="yAxis"
        * 	valueMemberPath="MyFunction"
        *     expectFunctions="true"/>
        *  </IgrDataChart>
        * ```
        */
        get: function () {
            return this.i.expectFunctions;
        },
        set: function (v) {
            this.i.expectFunctions = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "hitTestMode", {
        /**
         * Method of hit testing to use when pointing to items in this series.
        *
        * The `hitTestMode` can be set to either:
        *
        * -   `Auto`: automatically decide the appropriate hit test mode for the series.
        * -   `ColorEncoded`: use a color encoded off screen buffer for hit testing. Should always be O(1) time for determining a hit series. This increases frame render time and memory usage, however. Consider using this if hit testing time is degrading performance.
        * -   `Computational`: use a computational based approach to determine whether the series has been hit. This uses loose bounding boxes, in some cases, and can range in time complexity between O(1) and O(log n) to find a hit. This decreases frame render time compared to color encoded
        *
        * ```ts
        * this.series.hitTestMode = SeriesHitTestMode.Computational;
        * ```
        */
        get: function () {
            return this.i.be;
        },
        set: function (v) {
            this.i.be = ensureEnum(SeriesHitTestMode_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "actualHitTestMode", {
        /**
         * Resolved method of hit testing to use when pointing to items in the chart.
        *
        * ```ts
        * let hitTestMode: SeriesHitTestMode = this.series.actualHitTestMode;
        * ```
        */
        get: function () {
            return this.i.bc;
        },
        set: function (v) {
            this.i.bc = ensureEnum(SeriesHitTestMode_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isNegativeColorSupported", {
        /**
         * Overridden by derived series classes to indicate when negative colors are supported or not.
        */
        get: function () {
            return this.i.cz;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "isMarkerlessDisplayPreferred", {
        /**
         * Overridden by derived series classes to indicate when markerless display is preferred or not.
        */
        get: function () {
            return this.i.cy;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "finalValue", {
        /**
         * The final value of this series.
        */
        get: function () {
            return this.i.d5;
        },
        set: function (v) {
            this.i.d5 = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrSeries.prototype, "percentChange", {
        /**
         * The percent change from the beginning to the end of this series.
        */
        get: function () {
            return this.i.eq;
        },
        set: function (v) {
            this.i.eq = +v;
        },
        enumerable: true,
        configurable: true
    });
    /**
 * Gets the brush for tooltip labels.

*/
    IgrSeries.prototype.resolveTooltipBrush = function () {
        var iv = this.i.gp();
        return (iv);
    };
    /**
     * Gets the precise item index, if possible, based on the closeness to the previous or next whole integer. If the series cannot provide this information, GetExactItemIndex will return the same integer value as GetItemIndex.
    
    * @param world  * The world position for which to return the index.
    *
    * ```ts
    * let index: number = this.series.getExactItemIndex({x:.5,y:.5});
    * ```
    */
    IgrSeries.prototype.getExactItemIndex = function (world) {
        var iv = this.i.d8(toPoint(world));
        return (iv);
    };
    /**
     * Gets the item item index associated with the specified world position
    
    *
    * ```ts
    * let index: number = this.series.getItemIndex({x:.5,y:.5});
    * ```
    */
    IgrSeries.prototype.getItemIndex = function (world) {
        var iv = this.i.e5(toPoint(world));
        return (iv);
    };
    /**
     * Gets the item that is the best match for the specified world coordinates.
    
    * @param world  * The world coordinates to use.
    *
    * ```ts
    * let item: number = this.series.getItem({x:.5,y:.5});
    * ```
    */
    IgrSeries.prototype.getItem = function (world) {
        var iv = this.i.fm(toPoint(world));
        return (iv);
    };
    IgrSeries.prototype.getPreviousOrExactIndex = function (world, skipUnknowns) {
        var iv = this.i.fb(toPoint(world), skipUnknowns);
        return (iv);
    };
    IgrSeries.prototype.getNextOrExactIndex = function (world, skipUnknowns) {
        var iv = this.i.e9(toPoint(world), skipUnknowns);
        return (iv);
    };
    IgrSeries.prototype.getSeriesValue = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.ek(toPoint(world), useInterpolation, skipUnknowns);
        return (iv);
    };
    IgrSeries.prototype.getSeriesValuePosition = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.le(toPoint(world), useInterpolation, skipUnknowns);
        return fromPoint(iv);
    };
    /**
     * If possible, will return the best available value bounding box within the series that has the best value match for the world position provided.
    
    * @param world  * The world coordinate for which to get a value bounding box for
    */
    IgrSeries.prototype.getSeriesValueBoundingBox = function (world) {
        var iv = this.i.ln(toPoint(world));
        return fromRect(iv);
    };
    /**
     * If possible, will return the best available value marker bounding box within the series that has the best value match for the world position provided.
    
    * @param world  * The world coordinates for which to get a value marker bounding box for
    */
    IgrSeries.prototype.getSeriesValueMarkerBoundingBox = function (world) {
        var iv = this.i.lp(toPoint(world));
        return fromRect(iv);
    };
    IgrSeries.prototype.getSeriesHighValue = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.eg(toPoint(world), useInterpolation, skipUnknowns);
        return (iv);
    };
    IgrSeries.prototype.getSeriesHighValuePosition = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.la(toPoint(world), useInterpolation, skipUnknowns);
        return fromPoint(iv);
    };
    IgrSeries.prototype.getSeriesLowValue = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.ei(toPoint(world), useInterpolation, skipUnknowns);
        return (iv);
    };
    IgrSeries.prototype.getSeriesLowValuePosition = function (world, useInterpolation, skipUnknowns) {
        var iv = this.i.lc(toPoint(world), useInterpolation, skipUnknowns);
        return fromPoint(iv);
    };
    IgrSeries.prototype.getSeriesValuePositionFromSeriesPixel = function (mouse, useInterpolation, skipUnknowns) {
        var iv = this.i.lf(toPoint(mouse), useInterpolation, skipUnknowns);
        return fromPoint(iv);
    };
    IgrSeries.prototype.getSeriesValueFromSeriesPixel = function (mouse, useInterpolation, skipUnknowns) {
        var iv = this.i.el(toPoint(mouse), useInterpolation, skipUnknowns);
        return (iv);
    };
    /**
     * For a category plotted series, returns the current width of the items within the categories. This only returns a value if the items have some form of width (e.g. columns, bars, etc.) otherwise 0 is returned.
    
    *
    * ```ts
    * let span: number = this.series.getItemSpan();
    * ```
    */
    IgrSeries.prototype.getItemSpan = function () {
        var iv = this.i.ed();
        return (iv);
    };
    /**
     * Converts a point from coordinates within the series plot area to a world position within axis space.
    
    * @param seriesPoint  * The pixel location within the plot area of the series.
    *
    * ```ts
    * this.series.toWorldPosition({x:500,y:500});
    * ```
    */
    IgrSeries.prototype.toWorldPosition = function (seriesPoint) {
        var iv = this.i.lh(toPoint(seriesPoint));
        return fromPoint(iv);
    };
    /**
     * Converts a point from world coordinates to coordinates within the viewport of the series.
    
    * @param world  * The world position from which to convert.
    */
    IgrSeries.prototype.fromWorldPosition = function (world) {
        var iv = this.i.k9(toPoint(world));
        return fromPoint(iv);
    };
    /**
     * Requests that the provided item should be brought into view if possible.
    
    * @param item  * The item to attempt to bring into view.
    *
    * ```ts
    * this.series.scrollIntoView(dataItem);
    * ```
    */
    IgrSeries.prototype.scrollIntoView = function (item) {
        var iv = this.i.c8(item);
        return (iv);
    };
    /**
     * Renders the series.
    
    * @param animate  * True if the change should be animated.
    *
    * ```ts
    * this.series.renderSeries(true);
    * ```
    */
    IgrSeries.prototype.renderSeries = function (animate) {
        this.i.i6(animate);
    };
    /**
     * Gets the effective viewport, adjusted to account for margins and other factors.
    
    */
    IgrSeries.prototype.getEffectiveViewport = function () {
        var iv = this.i.getEffectiveViewport();
        return fromRect(iv);
    };
    /**
     * Removes all alternate views of this series.
    
    */
    IgrSeries.prototype.removeAllAlternateViews = function () {
        this.i.i0();
    };
    /**
     * Removes an alternate view of this series.
    
    * @param viewIdentifier  * The string identifier for the view to remove.
    */
    IgrSeries.prototype.removeAlternateView = function (viewIdentifier) {
        this.i.i2(viewIdentifier);
    };
    /**
     * Replays the assigned transition in animation, if any.
    
    *
    * ```ts
    * this.series.replayTransitionIn();
    * ```
    */
    IgrSeries.prototype.replayTransitionIn = function () {
        this.i.i9();
    };
    /**
     * Call to null out the axes of the series;
    
    */
    IgrSeries.prototype.removeAxes = function () {
        this.i.i3();
    };
    /**
     * Simulates a pointer hover over the series surface.
    
    * @param point  * The pointer position relative to the series viewport over which to hover.
    *
    * When tooltips are enabled, `simulateHover` can be used to automatically display the tooltip over a particular series item.
    *
    * ```ts
    * this.series.simulateHover({x:250,y:250});
    * ```
    */
    IgrSeries.prototype.simulateHover = function (point) {
        this.i.jd(toPoint(point));
    };
    /**
     * Called when this series' Style is updated.
    
    */
    IgrSeries.prototype.styleUpdated = function () {
        this.i.jf();
    };
    IgrSeries.prototype.setNegativeColors = function (negativeBrush, negativeOutline) {
        this.i.jb(stringToBrush(negativeBrush), stringToBrush(negativeOutline));
    };
    /**
     * Moves the cursor point to the provided world position. Some series may react to the current cursor position.
    
    * @param point  * The cursor point, in world coordinates.
    *
    * `moveCursorPoint` can be used on annotation layers to programitically show the annotation at the given point.
    *
    * ```ts
    * this.crosshair.moveCursorPoint({x:.5,y:.5});
    * ```
    */
    IgrSeries.prototype.moveCursorPoint = function (point) {
        this.i.h5(toPoint(point));
    };
    Object.defineProperty(IgrSeries.prototype, "renderRequested", {
        /**
         * This event is raised every time a render has been requested from a series.
        */
        get: function () {
            return this._renderRequested;
        },
        set: function (ev) {
            var _this = this;
            if (this._renderRequested_wrapped !== null) {
                this.i.renderRequested = delegateRemove(this.i.renderRequested, this._renderRequested_wrapped);
                this._renderRequested_wrapped = null;
                this._renderRequested = null;
            }
            this._renderRequested = ev;
            this._renderRequested_wrapped = function (o, e) {
                var outerArgs = new RenderRequestedEventArgs();
                outerArgs._provideImplementation(e);
                if (_this.beforeRenderRequested) {
                    _this.beforeRenderRequested(_this, outerArgs);
                }
                if (_this._renderRequested) {
                    _this._renderRequested(_this, outerArgs);
                }
            };
            this.i.renderRequested = delegateCombine(this.i.renderRequested, this._renderRequested_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    return IgrSeries;
}(React.Component));
export { IgrSeries };
