import * as tslib_1 from "tslib";
import * as React from 'react';
import { delegateCombine, delegateRemove } from "igniteui-react-core/ES5/type";
import { LabelsPosition_$type } from "./LabelsPosition";
import { Visibility_$type } from "igniteui-react-core/ES5/Visibility";
import { LeaderLineType_$type } from "./LeaderLineType";
import { OthersCategoryType_$type } from "./OthersCategoryType";
import { IndexCollection } from "./igr-index-collection";
import { SweepDirection_$type } from "igniteui-react-core/ES5/SweepDirection";
import { SliceSelectionMode_$type } from "./SliceSelectionMode";
import { LabelClickEventArgs } from "./igr-label-click-event-args";
import { SelectedItemChangingEventArgs } from "./igr-selected-item-changing-event-args";
import { SelectedItemsChangingEventArgs } from "./igr-selected-items-changing-event-args";
import { SelectedItemChangedEventArgs } from "./igr-selected-item-changed-event-args";
import { SelectedItemsChangedEventArgs } from "./igr-selected-items-changed-event-args";
import { SliceClickEventArgs } from "./igr-slice-click-event-args";
import { getModifiedProps, isValidProp, ensureEnum, brushToString, stringToBrush, ensureBool, toBrushCollection, fromBrushCollection, toPoint } from "igniteui-react-core/ES5/componentUtil";
import { IndexCollection as IndexCollection_internal } from "./IndexCollection";
/**
 * Represents the base class for the pie chart.
*/
var IgrPieChartBase = /** @class */ (function (_super) {
    tslib_1.__extends(IgrPieChartBase, _super);
    function IgrPieChartBase(props) {
        var _this = _super.call(this, props) || this;
        _this._explodedSlices = null;
        _this._labelClick = null;
        _this._labelClick_wrapped = null;
        _this._selectedItemChanging = null;
        _this._selectedItemChanging_wrapped = null;
        _this._selectedItemsChanging = null;
        _this._selectedItemsChanging_wrapped = null;
        _this._selectedItemChanged = null;
        _this._selectedItemChanged_wrapped = null;
        _this._selectedItemsChanged = null;
        _this._selectedItemsChanged_wrapped = null;
        _this._sliceClick = null;
        _this._sliceClick_wrapped = null;
        _this._implementation = _this.createImplementation();
        _this._implementation.externalObject = _this;
        _this.onImplementationCreated();
        return _this;
    }
    IgrPieChartBase.prototype.createImplementation = function () {
        return null;
    };
    Object.defineProperty(IgrPieChartBase.prototype, "i", {
        get: function () {
            return this._implementation;
        },
        enumerable: true,
        configurable: true
    });
    IgrPieChartBase.prototype.onImplementationCreated = function () {
    };
    IgrPieChartBase.prototype.componentDidMount = function () {
        try {
            for (var _a = tslib_1.__values(Object.keys(this.props)), _b = _a.next(); !_b.done; _b = _a.next()) {
                var p = _b.value;
                if (isValidProp(this, p)) {
                    this[p] = this.props[p];
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
            }
            finally { if (e_1) throw e_1.error; }
        }
        var e_1, _c;
    };
    IgrPieChartBase.prototype.shouldComponentUpdate = function (nextProps, nextState) {
        var mod = getModifiedProps(this.props, nextProps);
        try {
            for (var _a = tslib_1.__values(Object.keys(mod)), _b = _a.next(); !_b.done; _b = _a.next()) {
                var p = _b.value;
                if (isValidProp(this, p)) {
                    this[p] = mod[p];
                }
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
            }
            finally { if (e_2) throw e_2.error; }
        }
        return true;
        var e_2, _c;
    };
    IgrPieChartBase.prototype.render = function () {
        return null;
    };
    Object.defineProperty(IgrPieChartBase.prototype, "innerExtent", {
        /**
         * Gets or sets the amount of space between the center and the start of the arc. This property should be set between 0 and 1.
         * If InnerExtent is set to a value greater than 1, it will be interpreted as a percentage, effectively divided by 100.
        */
        get: function () {
            return this.i.cl;
        },
        set: function (v) {
            this.i.cl = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "valueMemberPath", {
        /**
         * Gets or Sets the property name that contains the values.
        */
        get: function () {
            return this.i.eg;
        },
        set: function (v) {
            this.i.eg = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "labelMemberPath", {
        /**
         * Gets or sets the property name that contains the labels.
        */
        get: function () {
            return this.i.di;
        },
        set: function (v) {
            this.i.di = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "legendLabelMemberPath", {
        /**
         * Gets or sets the property name that contains the legend labels.
        */
        get: function () {
            return this.i.dv;
        },
        set: function (v) {
            this.i.dv = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "labelsPosition", {
        /**
         * Gets or sets the position of chart labels.
        */
        get: function () {
            return this.i.ao;
        },
        set: function (v) {
            this.i.ao = ensureEnum(LabelsPosition_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "labelOuterColor", {
        /**
         * Gets or sets the color for labels rendered outside of the pie chart.
        */
        get: function () {
            return brushToString(this.i.gw);
        },
        set: function (v) {
            this.i.gw = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "labelInnerColor", {
        /**
         * Gets or sets the color for labels rendered inside of the pie chart.
        */
        get: function () {
            return brushToString(this.i.gv);
        },
        set: function (v) {
            this.i.gv = stringToBrush(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "leaderLineVisibility", {
        /**
         * Gets or sets whether the leader lines are visible.
        */
        get: function () {
            return this.i.g8;
        },
        set: function (v) {
            this.i.g8 = ensureEnum(Visibility_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "leaderLineType", {
        /**
         * Gets or sets what type of leader lines will be used for the outside end labels.
        */
        get: function () {
            return this.i.ap;
        },
        set: function (v) {
            this.i.ap = ensureEnum(LeaderLineType_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "leaderLineMargin", {
        /**
         * Gets or sets the margin between a label and the end of its leader line. The default is 6 pixels.
        */
        get: function () {
            return this.i.cn;
        },
        set: function (v) {
            this.i.cn = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "toolTip", {
        /**
         * Gets or sets the ToolTip for the chart.
        */
        get: function () {
            return this.i.c0;
        },
        set: function (v) {
            this.i.c0 = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "othersCategoryThreshold", {
        /**
         * Gets or sets the threshold value that determines if slices are grouped into the Others slice.
        */
        get: function () {
            return this.i.co;
        },
        set: function (v) {
            this.i.co = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "othersCategoryType", {
        /**
         * Gets or sets whether to use numeric or percent-based threshold value.
        */
        get: function () {
            return this.i.aq;
        },
        set: function (v) {
            this.i.aq = ensureEnum(OthersCategoryType_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "othersCategoryText", {
        /**
         * Gets or sets the label of the Others slice.
        */
        get: function () {
            return this.i.dz;
        },
        set: function (v) {
            this.i.dz = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "explodedRadius", {
        /**
         * Determines how much the exploded slice is offset from the center. Value between 0 and 1.
        */
        get: function () {
            return this.i.cg;
        },
        set: function (v) {
            this.i.cg = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "radiusFactor", {
        /**
         * Gets or sets the scaling factor of the chart's radius. Value between 0 and 1.
        */
        get: function () {
            return this.i.cr;
        },
        set: function (v) {
            this.i.cr = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "allowSliceSelection", {
        /**
         * Gets or sets whether the slices can be selected.
        */
        get: function () {
            return this.i.bq;
        },
        set: function (v) {
            this.i.bq = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "allowSliceExplosion", {
        /**
         * Gets or sets whether the slices can be exploded.
        */
        get: function () {
            return this.i.bp;
        },
        set: function (v) {
            this.i.bp = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "explodedSlices", {
        /**
         * Gets or sets the collection of exploded slice indices.
        */
        get: function () {
            if (this._explodedSlices === null) {
                var coll = new IndexCollection();
                var innerColl = this.i.al;
                var wasNull = false;
                if (!innerColl) {
                    wasNull = true;
                    innerColl = new IndexCollection_internal();
                }
                this._explodedSlices = coll._fromInner(innerColl);
                if (wasNull) {
                    this.i.al = innerColl;
                }
            }
            return this._explodedSlices;
        },
        set: function (v) {
            var coll = new IndexCollection();
            this._explodedSlices = coll._fromOuter(v);
            var innerColl = new IndexCollection_internal();
            var va = typeof v == 'string' ? coll._splitOuter(v) : v;
            innerColl._inner = va.map(function (item) { return coll._ensureOuter(item); });
            this.i.al = innerColl;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "legend", {
        /**
         * Gets or sets the legend used for the current chart.
        */
        get: function () {
            return this.i.ai;
        },
        set: function (v) {
            this.i.ai = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "labelExtent", {
        /**
         * Gets or sets the pixel amount by which the labels are offset from the edge of the slices.
        */
        get: function () {
            return this.i.cm;
        },
        set: function (v) {
            this.i.cm = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "startAngle", {
        /**
         * Gets or sets the starting angle of the chart.
         * The default zero value is equivalent to 3 o'clock.
        */
        get: function () {
            return this.i.ct;
        },
        set: function (v) {
            this.i.ct = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "sweepDirection", {
        /**
         * Gets or sets the rotational direction of the chart.
        */
        get: function () {
            return this.i.gx;
        },
        set: function (v) {
            this.i.gx = ensureEnum(SweepDirection_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "brushes", {
        /**
         * Gets or sets the palette of brushes to use for coloring the slices.
        */
        get: function () {
            return fromBrushCollection(this.i.ag);
        },
        set: function (v) {
            this.i.ag = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "outlines", {
        /**
         * Gets or sets the palette of brushes to use for outlines on the slices.
        */
        get: function () {
            return fromBrushCollection(this.i.ah);
        },
        set: function (v) {
            this.i.ah = toBrushCollection(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "legendItemTemplate", {
        /**
         * Gets or sets the LegendItemTemplate property.
         * The legend item control content is created according to the LegendItemTemplate on-demand by
         * the chart object itself.
        */
        get: function () {
            return this.i.legendItemTemplate;
        },
        set: function (v) {
            this.i.legendItemTemplate = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "legendItemBadgeTemplate", {
        /**
         * Gets or sets the LegendItemBadgeTemplate property.
         * The legend item badge is created according to the LegendItemBadgeTemplate on-demand by
         * the chart object itself.
        */
        get: function () {
            return this.i.legendItemBadgeTemplate;
        },
        set: function (v) {
            this.i.legendItemBadgeTemplate = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "isSurfaceInteractionDisabled", {
        /**
         * Gets or sets whether all surface interactions with the plot area should be disabled.
        */
        get: function () {
            return this.i.bv;
        },
        set: function (v) {
            this.i.bv = ensureBool(v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "formatLabel", {
        /**
         * Sets or gets a function which takes an object that produces a formatted label for displaying in the chart.
        */
        get: function () {
            return this.i.at;
        },
        set: function (v) {
            this.i.at = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "formatLegendLabel", {
        /**
         * Sets or gets a function which takes an object that produces a formatted label for displaying in the chart's legend.
        */
        get: function () {
            return this.i.au;
        },
        set: function (v) {
            this.i.au = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.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.cq;
        },
        set: function (v) {
            this.i.cq = +v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "actualPixelScalingRatio", {
        /**
         * Resolved pixel scaling ratio. Unless explicitly overridden by the PieChartBase.PixelScalingRatio property,
         * this one returns the default ratio enforced by device. High resolution devices will initialize this property
         * to a higher value.
        */
        get: function () {
            return this.i.cd;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectionMode", {
        /**
         * Gets or sets which mode to use for selecting slices.
        */
        get: function () {
            return this.i.a3;
        },
        set: function (v) {
            this.i.a3 = ensureEnum(SliceSelectionMode_$type, v);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectedItem", {
        /**
         * Gets or sets the currently selected data item.  If a different data item is provided the pie chart
         * will select the slice associated with the new item.
        */
        get: function () {
            return this.i.selectedItem;
        },
        set: function (v) {
            this.i.selectedItem = v;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "textStyle", {
        /**
         * Manually overrides the style to use for the labels.
        */
        get: function () {
            return this.i.eb;
        },
        set: function (v) {
            this.i.eb = v;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Returns the chart visuals expressed as a serialized string.
    
    */
    IgrPieChartBase.prototype.exportSerializedVisualData = function () {
        var iv = this.i.c8();
        return (iv);
    };
    /**
     * Simulates a mouse click action at the specified point.
    
    * @param point  * The point to click at.
    */
    IgrPieChartBase.prototype.simulateLeftClick = function (point) {
        this.i.fl(toPoint(point));
    };
    /**
     * Invoked by the containing object to provide reference to the container.
    
    * @param container  * Reference to the container.
    */
    IgrPieChartBase.prototype.provideContainer = function (container) {
        this.i.provideContainer(container);
    };
    /**
     * Notification from the containing object that the container has been resized.
    
    */
    IgrPieChartBase.prototype.notifyContainerResized = function () {
        this.i.notifyContainerResized();
    };
    /**
     * Invoked when the instance is being destroyed.
    
    */
    IgrPieChartBase.prototype.destroy = function () {
        this.i.destroy();
    };
    /**
     * Use to force the pie chart to finish any deferred work before printing or evaluating its visual.
     * This should only be called if the visual of the pie chart needs to be synchronously saved or evaluated.
     * Calling this method too often will hinder the performance of the pie chart.
    
    */
    IgrPieChartBase.prototype.flush = function () {
        this.i.el();
    };
    IgrPieChartBase.prototype.notifySetItem = function (source_, index, oldItem, newItem) {
        this.i.eu(source_, index, oldItem, newItem);
    };
    /**
     * Manually notifies the pie chart's data source that the data it has bound to has been cleared and needs to be re-examined.
     * This should not be called if the data that the pie chart is bound to is already observable.
    
    * @param source_  * The data source.
    */
    IgrPieChartBase.prototype.notifyClearItems = function (source_) {
        this.i.eq(source_);
    };
    IgrPieChartBase.prototype.notifyInsertItem = function (source_, index, newItem) {
        this.i.es(source_, index, newItem);
    };
    IgrPieChartBase.prototype.notifyRemoveItem = function (source_, index, oldItem) {
        this.i.et(source_, index, oldItem);
    };
    /**
     * Assigns data source for the items.
    
    * @param source_  * Array of the data source items.
    */
    IgrPieChartBase.prototype.setWidgetLevelDataSource = function (source_) {
        this.i.fk(source_);
    };
    /**
     * Resets items data source.
    
    */
    IgrPieChartBase.prototype.removeWidgetLevelDataSource = function () {
        this.i.fb();
    };
    /**
     * Invoked when style is updated.
    
    */
    IgrPieChartBase.prototype.styleUpdated = function () {
        this.i.fp();
    };
    Object.defineProperty(IgrPieChartBase.prototype, "labelClick", {
        /**
         * Raised when the slice's label is clicked.
        */
        get: function () {
            return this._labelClick;
        },
        set: function (ev) {
            var _this = this;
            if (this._labelClick !== null) {
                this.i.labelClick = delegateRemove(this.i.labelClick, this._labelClick_wrapped);
                this._labelClick_wrapped = null;
                this._labelClick = null;
            }
            this._labelClick = ev;
            this._labelClick_wrapped = function (o, e) {
                var outerArgs = new LabelClickEventArgs();
                outerArgs._provideImplementation(e);
                _this._labelClick(_this, outerArgs);
            };
            this.i.labelClick = delegateCombine(this.i.labelClick, this._labelClick_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectedItemChanging", {
        /**
         * Raised when the SelectedItem property is changing.  This event is cancelable.
        */
        get: function () {
            return this._selectedItemChanging;
        },
        set: function (ev) {
            var _this = this;
            if (this._selectedItemChanging !== null) {
                this.i.selectedItemChanging = delegateRemove(this.i.selectedItemChanging, this._selectedItemChanging_wrapped);
                this._selectedItemChanging_wrapped = null;
                this._selectedItemChanging = null;
            }
            this._selectedItemChanging = ev;
            this._selectedItemChanging_wrapped = function (o, e) {
                var outerArgs = new SelectedItemChangingEventArgs();
                outerArgs._provideImplementation(e);
                _this._selectedItemChanging(_this, outerArgs);
            };
            this.i.selectedItemChanging = delegateCombine(this.i.selectedItemChanging, this._selectedItemChanging_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectedItemsChanging", {
        /**
         * Raised when the SelectedItems collection is changing.  This event is cancelable.
        */
        get: function () {
            return this._selectedItemsChanging;
        },
        set: function (ev) {
            var _this = this;
            if (this._selectedItemsChanging !== null) {
                this.i.selectedItemsChanging = delegateRemove(this.i.selectedItemsChanging, this._selectedItemsChanging_wrapped);
                this._selectedItemsChanging_wrapped = null;
                this._selectedItemsChanging = null;
            }
            this._selectedItemsChanging = ev;
            this._selectedItemsChanging_wrapped = function (o, e) {
                var outerArgs = new SelectedItemsChangingEventArgs();
                outerArgs._provideImplementation(e);
                _this._selectedItemsChanging(_this, outerArgs);
            };
            this.i.selectedItemsChanging = delegateCombine(this.i.selectedItemsChanging, this._selectedItemsChanging_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectedItemChanged", {
        /**
         * Raised when the SelectedItem property has changed.
        */
        get: function () {
            return this._selectedItemChanged;
        },
        set: function (ev) {
            var _this = this;
            if (this._selectedItemChanged !== null) {
                this.i.selectedItemChanged = delegateRemove(this.i.selectedItemChanged, this._selectedItemChanged_wrapped);
                this._selectedItemChanged_wrapped = null;
                this._selectedItemChanged = null;
            }
            this._selectedItemChanged = ev;
            this._selectedItemChanged_wrapped = function (o, e) {
                var outerArgs = new SelectedItemChangedEventArgs();
                outerArgs._provideImplementation(e);
                _this._selectedItemChanged(_this, outerArgs);
            };
            this.i.selectedItemChanged = delegateCombine(this.i.selectedItemChanged, this._selectedItemChanged_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "selectedItemsChanged", {
        /**
         * Raised when the SelectedItems collection has changed.
        */
        get: function () {
            return this._selectedItemsChanged;
        },
        set: function (ev) {
            var _this = this;
            if (this._selectedItemsChanged !== null) {
                this.i.selectedItemsChanged = delegateRemove(this.i.selectedItemsChanged, this._selectedItemsChanged_wrapped);
                this._selectedItemsChanged_wrapped = null;
                this._selectedItemsChanged = null;
            }
            this._selectedItemsChanged = ev;
            this._selectedItemsChanged_wrapped = function (o, e) {
                var outerArgs = new SelectedItemsChangedEventArgs();
                outerArgs._provideImplementation(e);
                _this._selectedItemsChanged(_this, outerArgs);
            };
            this.i.selectedItemsChanged = delegateCombine(this.i.selectedItemsChanged, this._selectedItemsChanged_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(IgrPieChartBase.prototype, "sliceClick", {
        /**
         * Raised when the slice is clicked.
        */
        get: function () {
            return this._sliceClick;
        },
        set: function (ev) {
            var _this = this;
            if (this._sliceClick !== null) {
                this.i.sliceClick = delegateRemove(this.i.sliceClick, this._sliceClick_wrapped);
                this._sliceClick_wrapped = null;
                this._sliceClick = null;
            }
            this._sliceClick = ev;
            this._sliceClick_wrapped = function (o, e) {
                var outerArgs = new SliceClickEventArgs();
                outerArgs._provideImplementation(e);
                _this._sliceClick(_this, outerArgs);
            };
            this.i.sliceClick = delegateCombine(this.i.sliceClick, this._sliceClick_wrapped);
        },
        enumerable: true,
        configurable: true
    });
    return IgrPieChartBase;
}(React.Component));
export { IgrPieChartBase };
