import * as React from 'react';
import { delegateCombine, delegateRemove } from "igniteui-react-core";
import { SeriesHighlightingMode_$type } from "./SeriesHighlightingMode";
import { SeriesHighlightingBehavior_$type } from "./SeriesHighlightingBehavior";
import { LegendHighlightingMode_$type } from "./LegendHighlightingMode";
import { ChartHitTestMode_$type } from "./ChartHitTestMode";
import { WindowResponse_$type } from "./WindowResponse";
import { Visibility_$type } from "igniteui-react-core";
import { ZoomCoercionMode_$type } from "./ZoomCoercionMode";
import { InteractionState_$type } from "igniteui-react-core";
import { ModifierKeys_$type } from "igniteui-react-core";
import { HorizontalAlignment_$type } from "igniteui-react-core";
import { IgrPlotAreaMouseButtonEventArgs } from "./igr-plot-area-mouse-button-event-args";
import { IgrPlotAreaMouseEventArgs } from "./igr-plot-area-mouse-event-args";
import { IgrChartCursorEventArgs } from "./igr-chart-cursor-event-args";
import { IgrDataChartMouseButtonEventArgs } from "./igr-data-chart-mouse-button-event-args";
import { IgrChartMouseEventArgs } from "./igr-chart-mouse-event-args";
import { IgrSeriesViewerManipulationEventArgs } from "./igr-series-viewer-manipulation-event-args";
import { IgrRectChangedEventArgs } from "igniteui-react-core";
import { IgrRefreshCompletedEventArgs } from "./igr-refresh-completed-event-args";
import { TypeRegistrar } from "igniteui-react-core";
import { NamePatcher, getModifiedProps, isValidProp, fromPoint, toPoint, ensureBool, ensureEnum, fromRect, toRect, brushToString, stringToBrush, toSpinal, initializePropertiesFromCss } from "igniteui-react-core";
/**
 * Represents a control for viewing series objects.
*/
export class IgrSeriesViewer extends React.Component {
    constructor(props) {
        super(props);
        this.__p = null;
        this._hasUserValues = new Set();
        this._stylingContainer = null;
        this._stylingParent = null;
        this._inStyling = false;
        this._plotAreaMouseLeftButtonDown = null;
        this._plotAreaMouseLeftButtonDown_wrapped = null;
        this._plotAreaMouseLeftButtonUp = null;
        this._plotAreaMouseLeftButtonUp_wrapped = null;
        this._plotAreaClicked = null;
        this._plotAreaClicked_wrapped = null;
        this._plotAreaMouseEnter = null;
        this._plotAreaMouseEnter_wrapped = null;
        this._plotAreaMouseLeave = null;
        this._plotAreaMouseLeave_wrapped = null;
        this._plotAreaMouseOver = null;
        this._plotAreaMouseOver_wrapped = null;
        this._seriesCursorMouseMove = null;
        this._seriesCursorMouseMove_wrapped = null;
        this._seriesMouseLeftButtonDown = null;
        this._seriesMouseLeftButtonDown_wrapped = null;
        this._seriesMouseLeftButtonUp = null;
        this._seriesMouseLeftButtonUp_wrapped = null;
        this._seriesMouseMove = null;
        this._seriesMouseMove_wrapped = null;
        this._seriesMouseEnter = null;
        this._seriesMouseEnter_wrapped = null;
        this._seriesMouseLeave = null;
        this._seriesMouseLeave_wrapped = null;
        this._viewerManipulationStarting = null;
        this._viewerManipulationStarting_wrapped = null;
        this._viewerManipulationEnding = null;
        this._viewerManipulationEnding_wrapped = null;
        this._windowRectChanged = null;
        this._windowRectChanged_wrapped = null;
        this._sizeChanged = null;
        this._sizeChanged_wrapped = null;
        this._actualWindowRectChanged = null;
        this._actualWindowRectChanged_wrapped = null;
        this._gridAreaRectChanged = null;
        this._gridAreaRectChanged_wrapped = null;
        this._refreshCompleted = null;
        this._refreshCompleted_wrapped = null;
        if (this._styling) {
            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(this));
        }
        this._implementation = this.createImplementation();
        this._implementation.externalObject = this;
        this.onImplementationCreated();
    }
    createImplementation() {
        return null;
    }
    /**
     * @hidden
     */
    get i() {
        return this._implementation;
    } /**
                                 * @hidden
                                 */
    static _createFromInternal(internal) {
        if (!internal) {
            return null;
        }
        if (!internal.$type) {
            return null;
        }
        let name = internal.$type.name;
        let externalName = "Igr" + name;
        if (!TypeRegistrar.isRegistered(externalName)) {
            return null;
        }
        return TypeRegistrar.create(externalName);
    }
    onImplementationCreated() {
    }
    componentDidMount() {
        for (const p of Object.keys(this.props)) {
            if (isValidProp(this, p)) {
                this[p] = this.props[p];
            }
        }
    }
    shouldComponentUpdate(nextProps, nextState) {
        const mod = getModifiedProps(this.props, nextProps);
        for (const p of Object.keys(mod)) {
            if (isValidProp(this, p)) {
                this[p] = mod[p];
            }
        }
        return true;
    }
    render() {
        return null;
    }
    /**
     * Gets or sets the cross hair point (in world coordinates)
     * Either or both of the crosshair point's X and Y may be set to double.NaN, in which
     * case the relevant crosshair line is hidden.
    *
    * The `crosshairPoint` property is used to gets/sets the cross hair point (in world coordinates).
    *
    * ```ts
    * this.chart.crosshairPoint = {x:.8,y:.2};
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	crosshairVisibility="visible"
    *     crosshairPoint={x:.8,y:.2} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrAreaSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get crosshairPoint() {
        return fromPoint(this.i.ok);
    }
    set crosshairPoint(v) {
        this.i.ok = toPoint(v);
    }
    /**
     * Gets or sets whether the series animations should be allowed when a range change has been detected on an axis.
    *
    * `animateSeriesWhenAxisRangeChanges` is a Boolean property to override the default behavior in which series do not animate if an axis range changes.
    *
    * ```ts
    * this.chart.animateSeriesWhenAxisRangeChanges = true;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	animateSeriesWhenAxisRangeChanges={true}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrColumnSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get animateSeriesWhenAxisRangeChanges() {
        return this.i.c3;
    }
    set animateSeriesWhenAxisRangeChanges(v) {
        this.i.c3 = ensureBool(v);
    }
    /**
     * Gets or sets whether to sync the vertical aspect of the window with the contained series content. This is only supported for a subset of the available series.
    */
    get isWindowSyncedToVisibleRange() {
        return this.i.dv;
    }
    set isWindowSyncedToVisibleRange(v) {
        this.i.dv = ensureBool(v);
    }
    /**
     * Gets or sets whether calling SimulateHover should shift the crosshair point.
    */
    get shouldSimulateHoverMoveCrosshairPoint() {
        return this.i.eb;
    }
    set shouldSimulateHoverMoveCrosshairPoint(v) {
        this.i.eb = ensureBool(v);
    }
    /**
     * Gets or sets the highlighting mode to use for the series in the component, when supported. This takes precedence over the series level IsHightlightingEnabled.
    */
    get highlightingMode() {
        return this.i.bj;
    }
    set highlightingMode(v) {
        this.i.bj = ensureEnum(SeriesHighlightingMode_$type, v);
    }
    /**
     * Gets or sets the highlighting Behavior to use for the series in the component, when supported. This takes precedence over the series level IsHightlightingEnabled.
    */
    get highlightingBehavior() {
        return this.i.bh;
    }
    set highlightingBehavior(v) {
        this.i.bh = ensureEnum(SeriesHighlightingBehavior_$type, v);
    }
    /**
     * Gets or sets the highlighting mode to use for the legend linked to the component, when supported.
    */
    get legendHighlightingMode() {
        return this.i.a2;
    }
    set legendHighlightingMode(v) {
        this.i.a2 = ensureEnum(LegendHighlightingMode_$type, v);
    }
    /**
     * Gets the viewport rectangle associated with the SeriesViewer, the physical dimensions of the plot area.
    */
    get viewportRect() {
        return fromRect(this.i.o7);
    }
    /**
     * Gets the EffectiveViewport rectangle, representing the effective viewport area after margins have been subtracted.
    *
    *  ``ts
    * let viewport: IgxRect = this.chart.effectiveViewport;
    *
    * ```
    *
    * ```
    */
    get effectiveViewport() {
        return fromRect(this.i.ow);
    }
    set effectiveViewport(v) {
        this.i.ow = toRect(v);
    }
    /**
     * Represents the subset area within the viewport into which content should be mapped.
     * This is the projection of the current EffectiveViewport into the viewport at current zoom level.
    */
    get contentViewport() {
        return fromRect(this.i.ov);
    }
    /**
     * A rectangle representing the portion of the SeriesViewer currently in view.
     * A rectangle at X=0, Y=0 with a Height and Width of 1 implies the entire plotting area is in view.  A Height and Width of .5 would imply that the view is halfway zoomed in.
    *
    * You can set the `windowRect` to zoom in on an area of interest in the chart.
    *
    * ```ts
    * this.chart.windowRect = {left:0, top:1, width: .5, height: .5};
    * ```
    */
    get windowRect() {
        return fromRect(this.i.o8);
    }
    set windowRect(v) {
        this.i.o8 = toRect(v);
    }
    /**
     * Gets or sets whether the series viewer should use cached tiles during zooms rather than the default live content.
    */
    get useTiledZooming() {
        return this.i.ei;
    }
    set useTiledZooming(v) {
        this.i.ei = ensureBool(v);
    }
    /**
     * Gets or sets whether the series viewer should prefer selecting higher resolution tiles over lower resolution tiles when performing tile zooming. Setting this to true will lower performance but increase quality.
    */
    get preferHigherResolutionTiles() {
        return this.i.d7;
    }
    set preferHigherResolutionTiles(v) {
        this.i.d7 = ensureBool(v);
    }
    /**
     * Gets or sets the maximum number of zoom tiles that the series viewer should cache while in tiled zooming mode.
    */
    get zoomTileCacheSize() {
        return this.i.f5;
    }
    set zoomTileCacheSize(v) {
        this.i.f5 = +v;
    }
    /**
     * Gets or sets the duration the highlighting/de-highlighting effects.
    *
    * The `highlightingTransitionDuration` property is used to set the time for highlighting transition in milliseconds .
    *
    * ```ts
    * chart.HighlightingTransitionDuration=500;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	HighlightingTransitionDuration={500} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrAreaSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get highlightingTransitionDuration() {
        return this.i.f4;
    }
    set highlightingTransitionDuration(v) {
        this.i.f4 = +v;
    }
    /**
     * Gets or sets the whether the series viewer can allow the page to pan if a control pan is not possible in the requested direction.
    */
    get isPagePanningAllowed() {
        return this.i.dr;
    }
    set isPagePanningAllowed(v) {
        this.i.dr = ensureBool(v);
    }
    /**
     * Determines the method of hit testing used when mousing over elements in the chart.
    *
    * ```ts
    * this.chart.contentHitTestMode = ChartHitTestMode.Computational;
    * ```
    */
    get contentHitTestMode() {
        return this.i.ap;
    }
    set contentHitTestMode(v) {
        this.i.ap = ensureEnum(ChartHitTestMode_$type, v);
    }
    /**
     * Resolved method of hit testing used when the pointer is over elements in the chart.
    *
    * ```ts
    * let actualContentHitTestMode: ChartHitTestMode  =this.chart.actualContentHitTestMode;
    * ```
    */
    get actualContentHitTestMode() {
        return this.i.ao;
    }
    set actualContentHitTestMode(v) {
        this.i.ao = ensureEnum(ChartHitTestMode_$type, v);
    }
    /**
     * Gets or sets whether all surface interactions with the plot area should be disabled.
    *
    * The `isSurfaceInteractionDisabled` property is used to enable/disable interactions with the plot surface.
    *
    * ```ts
    * chart.isSurfaceInteractionDisabled=true;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	 isSurfaceInteractionDisabled={true} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrAreaSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get isSurfaceInteractionDisabled() {
        return this.i.ds;
    }
    set isSurfaceInteractionDisabled(v) {
        this.i.ds = ensureBool(v);
    }
    /**
     * Indicates if this SeriesViewer is a map.
    */
    get isMap() {
        return this.i.dq;
    }
    /**
     * The response to user panning and zooming: whether to update the view immediately while the user action is happening, or to defer the update to after the user action is complete.  The user action will be an action such as a mouse drag which causes panning and/or zooming to occur.
    *
    * The `windowResponse` property is used to set the response to user panning and zooming: whether to update the view immediately while the user action is happening, or to defer the update to after the user action is complete.
    * The user action will be an action such as a mouse drag which causes panning and/or zooming to occur.
    *
    * ```ts
    * this.chart.windowResponse="deferred";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	windowResponse="deferred">
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get windowResponse() {
        return this.i.bp;
    }
    set windowResponse(v) {
        this.i.bp = ensureEnum(WindowResponse_$type, v);
    }
    /**
     * Sets or gets the minimum width that the window rect is allowed to reach before being clamped.
     * Decrease this value if you want to allow for further zooming into the viewer.
     * If this value is lowered too much it can cause graphical corruption due to floating point arithmetic inaccuracy.
    *
    * The `windowRectMinWidth` property is used to set or get the minimum width that the window rect is allowed to reach before being clamped.
    *
    * ```ts
    * this.chart.WindowRectMinWidth=".2";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	WindowRectMinWidth=".2">
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get windowRectMinWidth() {
        return this.i.fw;
    }
    set windowRectMinWidth(v) {
        this.i.fw = +v;
    }
    /**
     * Gets or sets the current SeriesViewer's crosshair visibility override.
    *
    * The `crosshairVisibility` property is used to gets or sets the current Chart's crosshair visibility override. Note: setting this property does not affect the mobile browser version of the chart.
    *
    * ```ts
    * this.chart.crosshairVisibility = Visibility.Visible;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	crosshairVisibility="visible"
    *     crosshairPoint={x:.8,y:.2} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrAreaSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get crosshairVisibility() {
        return this.i.pc;
    }
    set crosshairVisibility(v) {
        this.i.pc = ensureEnum(Visibility_$type, v);
    }
    /**
     * Gets or sets zoom is contrained to within the axes. Setting this to false is a preview feature at the present time.
    */
    get zoomCoercionMode() {
        return this.i.bt;
    }
    set zoomCoercionMode(v) {
        this.i.bt = ensureEnum(ZoomCoercionMode_$type, v);
    }
    /**
     * Gets or sets the brush used as the background for the current SeriesViewer object's plot area.
    *
    * `plotAreaBackground` property set the background brush to the current Chart object's plot area.
    *
    * ```ts
    * this.chart.plotAreaBackground="#F0F8FF";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    * 	dataSource={this.state.dataSource}
    * 	plotAreaBackground="#F0F8FF" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get plotAreaBackground() {
        return brushToString(this.i.od);
    }
    set plotAreaBackground(v) {
        this.i.od = stringToBrush(v);
    }
    /**
     * Gets or sets the DefaultInteraction property.
     * The default interaction state defines the SeriesViewer's response to mouse events.
    *
    * The default interaction state defines the chart's response to mouse events.
    *
    * ```ts
    * this.chart.defaultInteraction = InteractionState.DragPan;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	defaultInteraction="dragPan" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrAreaSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get defaultInteraction() {
        return this.i.bw;
    }
    set defaultInteraction(v) {
        this.i.bw = ensureEnum(InteractionState_$type, v);
    }
    /**
     * Gets or sets the RightButtonDefaultInteraction property.
     * The default interaction state defines the SeriesViewer's response to right button mouse events.
    */
    get rightButtonDefaultInteraction() {
        return this.i.by;
    }
    set rightButtonDefaultInteraction(v) {
        this.i.by = ensureEnum(InteractionState_$type, v);
    }
    /**
     * Gets or sets the current SeriesViewer's DragModifier property.
    *
    * `dragModifier` is useful to enable zooming when zooming is not the default interaction.
    *
    * ```ts
    * this.chart.dragModifier = ModifierKeys.Alt;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	isHorizontalZoomEnabled=true
    *     defaultInteraction="dragPan"
    *     dragModifier="alt" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get dragModifier() {
        return this.i.n0;
    }
    set dragModifier(v) {
        this.i.n0 = ensureEnum(ModifierKeys_$type, v);
    }
    /**
     * Gets or sets the current SeriesViewer's PanModifier property.
    *
    * `panModifier` is useful to enable panning when panning is not the default interaction.
    *
    * ```ts
    * this.chart.panModifier = ModifierKeys.Alt;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    * 	dataSource={this.state.dataSource}
    * 	isHorizontalZoomEnabled=true
    * 	defaultInteraction="dragZoom"
    * 	panModifier="alt" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get panModifier() {
        return this.i.n1;
    }
    set panModifier(v) {
        this.i.n1 = ensureEnum(ModifierKeys_$type, v);
    }
    /**
     * Gets or sets the preview rectangle.
     * The preview rectangle may be set to Rect.Empty, in which case the visible preview
     * strokePath is hidden.
    *
    * `previewRect` can be used to highlight an area of importance.
    *
    * ```ts
    * this.chart.previewRect = {left:0,top:0,height:.5,width:.5};
    * ```
    */
    get previewRect() {
        return fromRect(this.i.o2);
    }
    set previewRect(v) {
        this.i.o2 = toRect(v);
    }
    /**
     * A number between 0 and 1 determining the position of the horizontal scroll.
     * This property is effectively a shortcut to the X position of the WindowRect property.
    *
    * ```ts
    * this.chart.windowPositionHorizontal = .2;
    * ```
    */
    get windowPositionHorizontal() {
        return this.i.fu;
    }
    set windowPositionHorizontal(v) {
        this.i.fu = +v;
    }
    /**
     * A number between 0 and 1 determining the position of the vertical scroll.
     * This property is effectively a shortcut to the Y position of the WindowRect property.
    *
    * ```ts
    * this.chart.windowPositionVertical = .2;
    * ```
    */
    get windowPositionVertical() {
        return this.i.fv;
    }
    set windowPositionVertical(v) {
        this.i.fv = +v;
    }
    /**
     * Text to display above the plot area.
    *
    * The `chartTitle` property is used to set the title to display for the component.
    *
    * ```ts
    * this.chart.title="Items Sold";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	title="Items Sold" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get chartTitle() {
        return this.i.hy;
    }
    set chartTitle(v) {
        this.i.hy = v;
    }
    /**
     * Gets or sets the TitleHorizontalAlignment property.
    *
    * The `subtitleHorizontalAlignment` property is used to set horizontal alignment for the subtitle.
    *
    * ```ts
    * this.chart.titleHorizontalAlignment="left";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	titleHorizontalAlignment="left"
    *     subtitleHorizontalAlignment="left" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleHorizontalAlignment() {
        return this.i.nz;
    }
    set titleHorizontalAlignment(v) {
        this.i.nz = ensureEnum(HorizontalAlignment_$type, v);
    }
    /**
     * Gets or sets the SubtitleHorizontalAlignment property.
    *
    * The `subtitleBottomMargin` property is used to set the horizontal alignment for the subtitle.
    *
    * ```ts
    * this.chart.subtitleHorizontalAlignment="left";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	subtitleHorizontalAlignment="left"	>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleHorizontalAlignment() {
        return this.i.ny;
    }
    set subtitleHorizontalAlignment(v) {
        this.i.ny = ensureEnum(HorizontalAlignment_$type, v);
    }
    /**
     * Font settings for the title.
    */
    get titleTextStyle() {
        return this.i.h5;
    }
    set titleTextStyle(v) {
        this.i.h5 = v;
    }
    /**
     * Font settings for the subtitle.
    */
    get subtitleTextStyle() {
        return this.i.ht;
    }
    set subtitleTextStyle(v) {
        this.i.ht = v;
    }
    /**
     * Gets or sets the Color used for the Title Text.
    *
    * The `titleTextColor` property is used to set the title brush.
    *
    * ```ts
    * this.chart.titleTextColor="blue" ;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	titleTextColor="blue" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleTextColor() {
        return brushToString(this.i.oi);
    }
    set titleTextColor(v) {
        this.i.oi = stringToBrush(v);
    }
    /**
     * Gets or sets the Color used for the Subtitle Text.
    *
    * The `subtitleTextColor` property is used to set the color for the subtitle.
    *
    * ```ts
    * this.chart.subtitleTextColor="blue";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	title="Date of Sale: 1/1/2018"
    *     subtitleTextColor="blue">
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleTextColor() {
        return brushToString(this.i.oh);
    }
    set subtitleTextColor(v) {
        this.i.oh = stringToBrush(v);
    }
    /**
     * Margin applied above the title.
    *
    * The `titleTopMargin` property is used to set the top margin for the title.
    *
    * ```ts
    * this.chart.titleTopMargin=10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	titleLeftMarging= {10}
    *     titleTopMargin= {10 }
    *     titleRightMargin= {10}
    *     titleBottomMargin= {20}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleTopMargin() {
        return this.i.fs;
    }
    set titleTopMargin(v) {
        this.i.fs = +v;
    }
    /**
     * Margin applied to the left of the title.
    *
    * The `titleLeftMarging` property is used to set the left margin for the title.
    *
    * ```ts
    * this.chart.titleLeftMarging=10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	title="Items Sold"
    *     titleLeftMarging={10}
    *     titleTopMargin={10}
    *     titleRightMargin={10}
    *     titleBottomMargin= {20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleLeftMargin() {
        return this.i.fq;
    }
    set titleLeftMargin(v) {
        this.i.fq = +v;
    }
    /**
     * Margin applied to the right of the title.
    *
    * The `titleRightMargin` property is used to set the right margin for the title.
    *
    * ```ts
    * this.chart.titleRightMargin=10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	titleLeftMarging= {10}
    *     titleTopMargin= {10 }
    *     titleRightMargin= {10}
    *     titleBottomMargin= {20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleRightMargin() {
        return this.i.fr;
    }
    set titleRightMargin(v) {
        this.i.fr = +v;
    }
    /**
     * Margin applied below the title.
    *
    * The `titleBottomMargin` property is used to set the bottom margin for the title.
    *
    * ```ts
    * this.chart.titleBottomMargin=20;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	title="Items Sold"
    * 	titleLeftMarging= {10}
    *     titleTopMargin= {10 }
    *     titleRightMargin= {10}
    *     titleBottomMargin= {20}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get titleBottomMargin() {
        return this.i.fp;
    }
    set titleBottomMargin(v) {
        this.i.fp = +v;
    }
    /**
     * Margin applied above the subtitle.
    *
    * The `subtitleTopMargin` property is used to set the top margin for the subtitle.
    *
    * ```ts
    * this.chart.subtitleTopMargin =10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	subtitleLeftMarging= {10}
    *     subtitleTopMargin={10}
    *     subtitleRightMargin={10}
    *     subtitleBottomMargin={20}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleTopMargin() {
        return this.i.fo;
    }
    set subtitleTopMargin(v) {
        this.i.fo = +v;
    }
    /**
     * Margin applied to the left of the subtitle.
    *
    * The `subtitleLeftMarging` property is used to set the left margin for the subtitle.
    *
    * ```ts
    * this.chart.subtitleLeftMarging=10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	subtitleLeftMarging= {10}
    *     subtitleTopMargin={10}
    *     subtitleRightMargin={10}
    *     subtitleBottomMargin={20}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleLeftMargin() {
        return this.i.fm;
    }
    set subtitleLeftMargin(v) {
        this.i.fm = +v;
    }
    /**
     * Margin applied to the right of the subtitle.
    *
    * The `subTitleRightMargin` property is used to set the right margin for the subtitle.
    *
    * ```ts
    * this.chart.subtitleLeftMarging=10;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	subtitleLeftMarging= {10}
    *     subtitleTopMargin= {10}
    *     subtitleRightMargin={10}
    *     subtitleBottomMargin={20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleRightMargin() {
        return this.i.fn;
    }
    set subtitleRightMargin(v) {
        this.i.fn = +v;
    }
    /**
     * Margin applied below the subtitle.
    *
    * The `subtitleBottomMargin` property is used to set the bottom margin for the subtitle.
    *
    * ```ts
    * this.chart.subtitleBottomMargin = 20;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	 subtitleBottomMargin={20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitleBottomMargin() {
        return this.i.fl;
    }
    set subtitleBottomMargin(v) {
        this.i.fl = +v;
    }
    /**
     * Gets or sets the Subtitle property.
     * The Title property defines the Subtitle of the chart
    *
    * The `subtitle` property is used to display subtitle for the component.
    *
    * ```ts
    * this.chart.subtitle="Date of Sale: 1/1/2018";
    * ```
    *
    * ```ts
    *  <IgrDataChart
    * 	dataSource={this.state.dataSource}
    * 	subtitle="Date of Sale: 1/1/2018" >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get subtitle() {
        return this.i.hm;
    }
    set subtitle(v) {
        this.i.hm = v;
    }
    /**
     * Sets or gets the top margin to use around the chart content.
    *
    * The `topMargin` property is used to set the top margin.
    *
    * ```ts
    * this.chart.topMargin=30;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	leftMargin= {20}
    *     rightMargin={20}
    *     topMargin={30}
    *     bottomMargin= {20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get topMargin() {
        return this.i.ft;
    }
    set topMargin(v) {
        this.i.ft = +v;
    }
    /**
     * Sets or gets the left margin to use around the chart content.
    *
    * The `leftMargin` property is used to set the left margin.
    *
    * ```ts
    *  this.chart.leftMargin = 20;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	 leftMargin={20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    * />
    *  </IgrDataChart>
    * ```
    */
    get leftMargin() {
        return this.i.fh;
    }
    set leftMargin(v) {
        this.i.fh = +v;
    }
    /**
     * Sets or gets the right margin to use around the chart content.
    *
    * The `rightMargin` property is used to set the left margin around the chart content in the canvas.
    *
    * ```ts
    * this.chart.rightMargin=20;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	leftMargin= {20}
    * 	rightMargin={20}
    * 	topMargin={30}
    * 	bottomMargin={20} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get rightMargin() {
        return this.i.fk;
    }
    set rightMargin(v) {
        this.i.fk = +v;
    }
    /**
     * Sets or gets the bottom margin to use around the chart content.
    *
    * The `bottomMargin` property is used to gets/set the bottom margin around the chart content in the canvas.
    *
    * ```ts
    * this.chart.bottomMargin = 50;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	 bottomMargin={50} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrColumnSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get bottomMargin() {
        return this.i.fd;
    }
    set bottomMargin(v) {
        this.i.fd = +v;
    }
    /**
     * Sets or gets the automatic width to add when automatically adding margins to the chart.
    *
    * The `autoMarginWidth` propertry is used find the automatic width to add when automatically adding margins to the chart.
    *
    * ```ts
    * this.chart.autoMarginWidth = 50;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	autoMarginWidth={50} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrColumnSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value"
    *     brush="Gray"
    *     outline="Black" />
    *  </IgrDataChart>
    * ```
    */
    get autoMarginWidth() {
        return this.i.fc;
    }
    set autoMarginWidth(v) {
        this.i.fc = +v;
    }
    /**
     * Sets or gets the automatic height to add when automatically adding margins to the chart.
    *
    * ```ts
    *  this.chart.autoMarginHeight = 50;
    * ```
    *
    * ```ts
    *  <IgrDataChart
    * 	autoMarginHeight={50}
    *     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 autoMarginHeight() {
        return this.i.fb;
    }
    set autoMarginHeight(v) {
        this.i.fb = +v;
    }
    /**
     * Gets or sets the IsAntiAliasingEnabledDuringInteraction property.
    */
    get isAntiAliasingEnabledDuringInteraction() {
        return this.i.dg;
    }
    set isAntiAliasingEnabledDuringInteraction(v) {
        this.i.dg = ensureBool(v);
    }
    /**
     * Gets or sets the scaling value used to affect the pixel density of the control.
     * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
     * to appear blurry.
    */
    get pixelScalingRatio() {
        return this.i.fi;
    }
    set pixelScalingRatio(v) {
        this.i.fi = +v;
    }
    /**
     * Method of pixel scaling to use during end user interaction with the chart.
    */
    get interactionPixelScalingRatio() {
        return this.i.fg;
    }
    set interactionPixelScalingRatio(v) {
        this.i.fg = +v;
    }
    /**
     * Gets the resolved pixel scaling ratio.
    *
    * A higher scaling ratio will produce crisper visuals at the expense of memory. Lower values will cause the control to appear blurry
    *
    * ```ts
    * let actualPixelScalingRatio: number = this.chart.actualPixelScalingRatio;
    * ```
    */
    get actualPixelScalingRatio() {
        return this.i.e8;
    }
    set actualPixelScalingRatio(v) {
        this.i.e8 = +v;
    }
    /**
     * Resolved method of pixel scaling to use during end user interaction with the chart.
    *
    * ```ts
    * let actualInteractionPixelScalingRatio: number = this.chart.actualInteractionPixelScalingRatio;
    * ```
    */
    get actualInteractionPixelScalingRatio() {
        return this.i.e7;
    }
    set actualInteractionPixelScalingRatio(v) {
        this.i.e7 = +v;
    }
    /**
     * Gets the actual value of the window rectangle, which represents the current zoom level.
    */
    get actualWindowRect() {
        return fromRect(this.i.os);
    }
    set actualWindowRect(v) {
        this.i.os = toRect(v);
    }
    /**
     * A number between 0 and 1 determining the position of the horizontal scroll.
     * This property is effectively a shortcut to the Left of the ActualWindowRect property.
    *
    * ```ts
    * let actualWindowPositionHorizontal: number = this.chart.actualWindowPositionHorizontal;
    * ```
    */
    get actualWindowPositionHorizontal() {
        return this.i.e9;
    }
    set actualWindowPositionHorizontal(v) {
        this.i.e9 = +v;
    }
    /**
     * A number between 0 and 1 determining the position of the vertical scroll.
     * This property is effectively a shortcut to the Top of the ActualWindowRect property.
    *
    * ```ts
    * let actualWindowPositionVertical: number = this.chart.actualWindowPositionVertical;
    * ``
    * ```
    */
    get actualWindowPositionVertical() {
        return this.i.fa;
    }
    set actualWindowPositionVertical(v) {
        this.i.fa = +v;
    }
    findByName(name) {
        if (this.series != null && this.series.findByName && this.series.findByName(name)) {
            return this.series.findByName(name);
        }
        if (this.legend && this.legend.name && this.legend.name == name) {
            return this.legend;
        }
        return null;
    }
    get hasUserValues() {
        return this._hasUserValues;
    }
    __m(propertyName) {
        if (!this._inStyling) {
            this._hasUserValues.add(propertyName);
        }
    }
    _styling(container, component, parent) {
        if (this._inStyling) {
            return;
        }
        this._inStyling = true;
        this._stylingContainer = container;
        this._stylingParent = component;
        let genericPrefix = "";
        let typeName = this.i.$type.name;
        if (typeName.indexOf("Xam") === 0) {
            typeName = typeName.substring(3);
        }
        genericPrefix = toSpinal("SeriesViewer");
        let additionalPrefixes = [];
        let prefix = toSpinal(typeName);
        additionalPrefixes.push(prefix + "-");
        let b = this.i.$type.baseType;
        while (b && b.name != "Object" &&
            b.name != "Base" &&
            b.name != "Control" &&
            b.Name != "DependencyObject" &&
            b.Name != "FrameworkElement") {
            typeName = b.name;
            if (typeName.indexOf("Xam") === 0) {
                typeName = typeName.substring(3);
            }
            let basePrefix = toSpinal(typeName);
            additionalPrefixes.push(basePrefix + "-");
            b = b.baseType;
        }
        if (parent) {
            let parentTypeName = parent.i.$type.name;
            if (parentTypeName.indexOf("Xam") === 0) {
                parentTypeName = parentTypeName.substring(3);
            }
            let parentPrefix = toSpinal(parentTypeName);
            additionalPrefixes.push(parentPrefix + "-" + genericPrefix + "-");
            additionalPrefixes.push(parentPrefix + "-" + prefix + "-");
        }
        initializePropertiesFromCss(container, this, genericPrefix + "-", this.hasUserValues, false, additionalPrefixes);
        if (this._otherStyling) {
            this._otherStyling(container, component, parent);
        }
        this._inStyling = false;
    }
    /**
     * Hides the active main tooltip, if displayed.
    
    *
    * ```ts
    * this.chart.hideToolTip();
    * ```
    */
    hideToolTip() {
        this.i.i4();
    }
    simulateHover(point) {
        this.i.lv(toPoint(point));
    }
    /**
     * Manually starts a tiled zoom if one isn't already running.
    
    */
    startTiledZoomingIfNecessary() {
        this.i.lx();
    }
    /**
     * Manually ends a tiled zoom if one is running.
    
    */
    endTiledZoomingIfRunning() {
        this.i.iy();
    }
    /**
     * Clears the tile zoom tile cache so that new tiles will be generated. Only applies if the viewer is using a tile based zoom.
    
    */
    clearTileZoomCache() {
        this.i.is();
    }
    /**
     * Resets the zoom level to default.
    
    */
    resetZoom() {
        this.i.lp();
    }
    cancelManipulation() {
        this.i.iq();
    }
    /**
     * Gets actual window scale for horizontal dimension of the control
    
    *
    * ```ts
    * let actualWindowScaleHorizontal: number = chart.getActualWindowScaleHorizontal();
    * ```
    */
    getActualWindowScaleHorizontal() {
        let iv = this.i.fe();
        return (iv);
    }
    /**
     * Gets actual window scale for vertical dimension of the control
    
    *
    * ```ts
    * let actualWindowScaleVertical: number = chart.getActualWindowScaleVertical();
    * ```
    */
    getActualWindowScaleVertical() {
        let iv = this.i.ff();
        return (iv);
    }
    /**
     * Notification from the containing object that the container has been resized.
    
    */
    notifyContainerResized() {
        this.i.notifyContainerResized();
    }
    /**
     * Attaches the given series to the chart.
    
    * @param s  * The series to attach to the chart.
    */
    attachSeries(s) {
        this.i.io((s == null ? null : s.i));
    }
    notifySetItem(source_, index, oldItem, newItem) {
        this.i.ji(source_, index, oldItem, newItem);
    }
    /**
     * Used to manually notify the SeriesViewer that the data source has reset or cleared its items.  Invoking this method is only necessary if that datasource is not observable.
    
    * @param source_  * The data source which was cleared or reset.
    *
    * ```ts
    * this.chart.notifyClearItems(this.data);
    * ```
    */
    notifyClearItems(source_) {
        this.i.jd(source_);
    }
    notifyInsertItem(source_, index, newItem) {
        this.i.jg(source_, index, newItem);
    }
    notifyRemoveItem(source_, index, oldItem) {
        this.i.jh(source_, index, oldItem);
    }
    /**
     * Release any resources held by the control.
    
    */
    destroy() {
        this.i.destroy();
    }
    getCurrentActualWindowRect() {
        let iv = this.i.oy();
        return fromRect(iv);
    }
    renderToImage(width, height) {
        let iv = this.i.f7(width, height);
        return (iv);
    }
    /**
     * Use to force the SeriesViewer to finish any deferred work before printing or evaluating its visual.
     * This should only be called if the visual of the SeriesViewer needs to be synchronously saved or evaluated.
     * Calling this method too often will hinder the performance of the SeriesViewer.
    
    *
    * ```ts
    * this.chart.flush();
    * ```
    */
    flush() {
        this.i.flush();
    }
    /**
     * Occurs when the left mouse button is pressed while the mouse pointer is over the plot area.
    */
    get plotAreaMouseLeftButtonDown() {
        return this._plotAreaMouseLeftButtonDown;
    }
    set plotAreaMouseLeftButtonDown(ev) {
        if (this._plotAreaMouseLeftButtonDown_wrapped !== null) {
            this.i.plotAreaMouseLeftButtonDown = delegateRemove(this.i.plotAreaMouseLeftButtonDown, this._plotAreaMouseLeftButtonDown_wrapped);
            this._plotAreaMouseLeftButtonDown_wrapped = null;
            this._plotAreaMouseLeftButtonDown = null;
        }
        this._plotAreaMouseLeftButtonDown = ev;
        this._plotAreaMouseLeftButtonDown_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseButtonEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaMouseLeftButtonDown) {
                this.beforePlotAreaMouseLeftButtonDown(this, outerArgs);
            }
            if (this._plotAreaMouseLeftButtonDown) {
                this._plotAreaMouseLeftButtonDown(this, outerArgs);
            }
        };
        this.i.plotAreaMouseLeftButtonDown = delegateCombine(this.i.plotAreaMouseLeftButtonDown, this._plotAreaMouseLeftButtonDown_wrapped);
    }
    /**
     * Occurs when the left mouse button is pressed while the mouse pointer is over the plot area.
    */
    get plotAreaMouseLeftButtonUp() {
        return this._plotAreaMouseLeftButtonUp;
    }
    set plotAreaMouseLeftButtonUp(ev) {
        if (this._plotAreaMouseLeftButtonUp_wrapped !== null) {
            this.i.plotAreaMouseLeftButtonUp = delegateRemove(this.i.plotAreaMouseLeftButtonUp, this._plotAreaMouseLeftButtonUp_wrapped);
            this._plotAreaMouseLeftButtonUp_wrapped = null;
            this._plotAreaMouseLeftButtonUp = null;
        }
        this._plotAreaMouseLeftButtonUp = ev;
        this._plotAreaMouseLeftButtonUp_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseButtonEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaMouseLeftButtonUp) {
                this.beforePlotAreaMouseLeftButtonUp(this, outerArgs);
            }
            if (this._plotAreaMouseLeftButtonUp) {
                this._plotAreaMouseLeftButtonUp(this, outerArgs);
            }
        };
        this.i.plotAreaMouseLeftButtonUp = delegateCombine(this.i.plotAreaMouseLeftButtonUp, this._plotAreaMouseLeftButtonUp_wrapped);
    }
    /**
     * Occurs when the left mouse button is clicked while the mouse pointer is over the plot area.
    */
    get plotAreaClicked() {
        return this._plotAreaClicked;
    }
    set plotAreaClicked(ev) {
        if (this._plotAreaClicked_wrapped !== null) {
            this.i.plotAreaClicked = delegateRemove(this.i.plotAreaClicked, this._plotAreaClicked_wrapped);
            this._plotAreaClicked_wrapped = null;
            this._plotAreaClicked = null;
        }
        this._plotAreaClicked = ev;
        this._plotAreaClicked_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseButtonEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaClicked) {
                this.beforePlotAreaClicked(this, outerArgs);
            }
            if (this._plotAreaClicked) {
                this._plotAreaClicked(this, outerArgs);
            }
        };
        this.i.plotAreaClicked = delegateCombine(this.i.plotAreaClicked, this._plotAreaClicked_wrapped);
    }
    /**
     * Occurs when the pointer enters the plot area.
    */
    get plotAreaMouseEnter() {
        return this._plotAreaMouseEnter;
    }
    set plotAreaMouseEnter(ev) {
        if (this._plotAreaMouseEnter_wrapped !== null) {
            this.i.plotAreaMouseEnter = delegateRemove(this.i.plotAreaMouseEnter, this._plotAreaMouseEnter_wrapped);
            this._plotAreaMouseEnter_wrapped = null;
            this._plotAreaMouseEnter = null;
        }
        this._plotAreaMouseEnter = ev;
        this._plotAreaMouseEnter_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaMouseEnter) {
                this.beforePlotAreaMouseEnter(this, outerArgs);
            }
            if (this._plotAreaMouseEnter) {
                this._plotAreaMouseEnter(this, outerArgs);
            }
        };
        this.i.plotAreaMouseEnter = delegateCombine(this.i.plotAreaMouseEnter, this._plotAreaMouseEnter_wrapped);
    }
    /**
     * Occurs when the pointer exits the plot area.
    */
    get plotAreaMouseLeave() {
        return this._plotAreaMouseLeave;
    }
    set plotAreaMouseLeave(ev) {
        if (this._plotAreaMouseLeave_wrapped !== null) {
            this.i.plotAreaMouseLeave = delegateRemove(this.i.plotAreaMouseLeave, this._plotAreaMouseLeave_wrapped);
            this._plotAreaMouseLeave_wrapped = null;
            this._plotAreaMouseLeave = null;
        }
        this._plotAreaMouseLeave = ev;
        this._plotAreaMouseLeave_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaMouseLeave) {
                this.beforePlotAreaMouseLeave(this, outerArgs);
            }
            if (this._plotAreaMouseLeave) {
                this._plotAreaMouseLeave(this, outerArgs);
            }
        };
        this.i.plotAreaMouseLeave = delegateCombine(this.i.plotAreaMouseLeave, this._plotAreaMouseLeave_wrapped);
    }
    /**
     * Occurs when the pointer if over the plot area.
    */
    get plotAreaMouseOver() {
        return this._plotAreaMouseOver;
    }
    set plotAreaMouseOver(ev) {
        if (this._plotAreaMouseOver_wrapped !== null) {
            this.i.plotAreaMouseOver = delegateRemove(this.i.plotAreaMouseOver, this._plotAreaMouseOver_wrapped);
            this._plotAreaMouseOver_wrapped = null;
            this._plotAreaMouseOver = null;
        }
        this._plotAreaMouseOver = ev;
        this._plotAreaMouseOver_wrapped = (o, e) => {
            let outerArgs = new IgrPlotAreaMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforePlotAreaMouseOver) {
                this.beforePlotAreaMouseOver(this, outerArgs);
            }
            if (this._plotAreaMouseOver) {
                this._plotAreaMouseOver(this, outerArgs);
            }
        };
        this.i.plotAreaMouseOver = delegateCombine(this.i.plotAreaMouseOver, this._plotAreaMouseOver_wrapped);
    }
    /**
     * Occurs when the cursors are moved over a series in this SeriesViewer.
    */
    get seriesCursorMouseMove() {
        return this._seriesCursorMouseMove;
    }
    set seriesCursorMouseMove(ev) {
        if (this._seriesCursorMouseMove_wrapped !== null) {
            this.i.seriesCursorMouseMove = delegateRemove(this.i.seriesCursorMouseMove, this._seriesCursorMouseMove_wrapped);
            this._seriesCursorMouseMove_wrapped = null;
            this._seriesCursorMouseMove = null;
        }
        this._seriesCursorMouseMove = ev;
        this._seriesCursorMouseMove_wrapped = (o, e) => {
            let outerArgs = new IgrChartCursorEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesCursorMouseMove) {
                this.beforeSeriesCursorMouseMove(this, outerArgs);
            }
            if (this._seriesCursorMouseMove) {
                this._seriesCursorMouseMove(this, outerArgs);
            }
        };
        this.i.seriesCursorMouseMove = delegateCombine(this.i.seriesCursorMouseMove, this._seriesCursorMouseMove_wrapped);
    }
    /**
     * Occurs when the left mouse button is pressed while the mouse pointer is over a Series.
    *
    * The `SeriesMouseLeftButtonDown` event occurs when the left mouse button is pressed while the mouse pointer is over an element of this chart.
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    * public onSeriesMouseLeftButtonDown(event: {sender: any, args: DataChartMouseButtonEventArgs})
    * {
    *     var item = event.args.item;
    * }
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	seriesMouseLeftButtonDown= {this.onSeriesMouseLeftButtonDown}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get seriesMouseLeftButtonDown() {
        return this._seriesMouseLeftButtonDown;
    }
    set seriesMouseLeftButtonDown(ev) {
        if (this._seriesMouseLeftButtonDown_wrapped !== null) {
            this.i.seriesMouseLeftButtonDown = delegateRemove(this.i.seriesMouseLeftButtonDown, this._seriesMouseLeftButtonDown_wrapped);
            this._seriesMouseLeftButtonDown_wrapped = null;
            this._seriesMouseLeftButtonDown = null;
        }
        this._seriesMouseLeftButtonDown = ev;
        this._seriesMouseLeftButtonDown_wrapped = (o, e) => {
            let outerArgs = new IgrDataChartMouseButtonEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesMouseLeftButtonDown) {
                this.beforeSeriesMouseLeftButtonDown(this, outerArgs);
            }
            if (this._seriesMouseLeftButtonDown) {
                this._seriesMouseLeftButtonDown(this, outerArgs);
            }
        };
        this.i.seriesMouseLeftButtonDown = delegateCombine(this.i.seriesMouseLeftButtonDown, this._seriesMouseLeftButtonDown_wrapped);
    }
    /**
     * Occurs when the left mouse button is released while the mouse pointer is over a Series.
    *
    * The `SeriesMouseLeftButtonUp` event occurs when the left mouse button is released while the mouse pointer is over an element of this chart.
    *
    * &lt;-- position: content member-->
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    * public onSeriesMouseLeftButtonUp(event: {sender: any, args: DataChartMouseButtonEventArgs})
    * {
    *     var item = event.args.item;
    * }
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	seriesMouseLeftButtonUp ={this.onSeriesMouseLeftButtonUp}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    *
    * ```ts
    * public onSeriesMouseLeftButtonUp =(event: any, args: DataChartMouseButtonEventArgs )
    * {
    *
    * }
    * ```
    */
    get seriesMouseLeftButtonUp() {
        return this._seriesMouseLeftButtonUp;
    }
    set seriesMouseLeftButtonUp(ev) {
        if (this._seriesMouseLeftButtonUp_wrapped !== null) {
            this.i.seriesMouseLeftButtonUp = delegateRemove(this.i.seriesMouseLeftButtonUp, this._seriesMouseLeftButtonUp_wrapped);
            this._seriesMouseLeftButtonUp_wrapped = null;
            this._seriesMouseLeftButtonUp = null;
        }
        this._seriesMouseLeftButtonUp = ev;
        this._seriesMouseLeftButtonUp_wrapped = (o, e) => {
            let outerArgs = new IgrDataChartMouseButtonEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesMouseLeftButtonUp) {
                this.beforeSeriesMouseLeftButtonUp(this, outerArgs);
            }
            if (this._seriesMouseLeftButtonUp) {
                this._seriesMouseLeftButtonUp(this, outerArgs);
            }
        };
        this.i.seriesMouseLeftButtonUp = delegateCombine(this.i.seriesMouseLeftButtonUp, this._seriesMouseLeftButtonUp_wrapped);
    }
    /**
     * Occurs when the mouse pointer moves while over a Series.
    *
    * The `SeriesMouseMove` event occurs when the left mouse pointer moves while over an element of this chart.
    *
    * &lt;-- position: content member-->
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    * public onSeriesMouseMove(event: {sender: any, args: ChartMouseEventArgs})
    * {
    *     var item = event.args.item;
    * }
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	seriesMouseMove={this.onSeriesMouseMove} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    *
    * ```ts
    * public onSeriesMouseMove =( event: any, args: ChartMouseEventArgs) => {
    *                  }
    * ```
    */
    get seriesMouseMove() {
        return this._seriesMouseMove;
    }
    set seriesMouseMove(ev) {
        if (this._seriesMouseMove_wrapped !== null) {
            this.i.seriesMouseMove = delegateRemove(this.i.seriesMouseMove, this._seriesMouseMove_wrapped);
            this._seriesMouseMove_wrapped = null;
            this._seriesMouseMove = null;
        }
        this._seriesMouseMove = ev;
        this._seriesMouseMove_wrapped = (o, e) => {
            let outerArgs = new IgrChartMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesMouseMove) {
                this.beforeSeriesMouseMove(this, outerArgs);
            }
            if (this._seriesMouseMove) {
                this._seriesMouseMove(this, outerArgs);
            }
        };
        this.i.seriesMouseMove = delegateCombine(this.i.seriesMouseMove, this._seriesMouseMove_wrapped);
    }
    /**
     * Occurs when the mouse pointer enters a Series.
    *
    * The `SeriesMouseEnter` event occurs when the left mouse pointer enters an element of this chart.
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    * public onSeriesMouseEnter(event: {sender: any, args: ChartMouseEventArgs})
    * {
    *     var item = event.args.item;
    * }
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	seriesMouseEnter={this.onSeriesMouseEnter}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get seriesMouseEnter() {
        return this._seriesMouseEnter;
    }
    set seriesMouseEnter(ev) {
        if (this._seriesMouseEnter_wrapped !== null) {
            this.i.seriesMouseEnter = delegateRemove(this.i.seriesMouseEnter, this._seriesMouseEnter_wrapped);
            this._seriesMouseEnter_wrapped = null;
            this._seriesMouseEnter = null;
        }
        this._seriesMouseEnter = ev;
        this._seriesMouseEnter_wrapped = (o, e) => {
            let outerArgs = new IgrChartMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesMouseEnter) {
                this.beforeSeriesMouseEnter(this, outerArgs);
            }
            if (this._seriesMouseEnter) {
                this._seriesMouseEnter(this, outerArgs);
            }
        };
        this.i.seriesMouseEnter = delegateCombine(this.i.seriesMouseEnter, this._seriesMouseEnter_wrapped);
    }
    /**
     * Occurs when the mouse pointer leaves a Series.
    *
    * The `SeriesMouseLeave` event occurs when the left mouse pointer leaves an element of this chart.
    *
    * ```ts
    * public onSeriesMouseLeave(event: {sender: any, args: ChartMouseEventArgs})
    * {
    *     var item = event.args.item;
    * }
    * ```
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	 seriesMouseLeave ={this.onSeriesMouseLeave}>
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    */
    get seriesMouseLeave() {
        return this._seriesMouseLeave;
    }
    set seriesMouseLeave(ev) {
        if (this._seriesMouseLeave_wrapped !== null) {
            this.i.seriesMouseLeave = delegateRemove(this.i.seriesMouseLeave, this._seriesMouseLeave_wrapped);
            this._seriesMouseLeave_wrapped = null;
            this._seriesMouseLeave = null;
        }
        this._seriesMouseLeave = ev;
        this._seriesMouseLeave_wrapped = (o, e) => {
            let outerArgs = new IgrChartMouseEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSeriesMouseLeave) {
                this.beforeSeriesMouseLeave(this, outerArgs);
            }
            if (this._seriesMouseLeave) {
                this._seriesMouseLeave(this, outerArgs);
            }
        };
        this.i.seriesMouseLeave = delegateCombine(this.i.seriesMouseLeave, this._seriesMouseLeave_wrapped);
    }
    /**
     * Raised when an ongoing manipulation of the series viewer is started.
    */
    get viewerManipulationStarting() {
        return this._viewerManipulationStarting;
    }
    set viewerManipulationStarting(ev) {
        if (this._viewerManipulationStarting_wrapped !== null) {
            this.i.viewerManipulationStarting = delegateRemove(this.i.viewerManipulationStarting, this._viewerManipulationStarting_wrapped);
            this._viewerManipulationStarting_wrapped = null;
            this._viewerManipulationStarting = null;
        }
        this._viewerManipulationStarting = ev;
        this._viewerManipulationStarting_wrapped = (o, e) => {
            let outerArgs = new IgrSeriesViewerManipulationEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeViewerManipulationStarting) {
                this.beforeViewerManipulationStarting(this, outerArgs);
            }
            if (this._viewerManipulationStarting) {
                this._viewerManipulationStarting(this, outerArgs);
            }
        };
        this.i.viewerManipulationStarting = delegateCombine(this.i.viewerManipulationStarting, this._viewerManipulationStarting_wrapped);
    }
    /**
     * Raised when an ongoing manipulation of the series viewer is ended.
    */
    get viewerManipulationEnding() {
        return this._viewerManipulationEnding;
    }
    set viewerManipulationEnding(ev) {
        if (this._viewerManipulationEnding_wrapped !== null) {
            this.i.viewerManipulationEnding = delegateRemove(this.i.viewerManipulationEnding, this._viewerManipulationEnding_wrapped);
            this._viewerManipulationEnding_wrapped = null;
            this._viewerManipulationEnding = null;
        }
        this._viewerManipulationEnding = ev;
        this._viewerManipulationEnding_wrapped = (o, e) => {
            let outerArgs = new IgrSeriesViewerManipulationEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeViewerManipulationEnding) {
                this.beforeViewerManipulationEnding(this, outerArgs);
            }
            if (this._viewerManipulationEnding) {
                this._viewerManipulationEnding(this, outerArgs);
            }
        };
        this.i.viewerManipulationEnding = delegateCombine(this.i.viewerManipulationEnding, this._viewerManipulationEnding_wrapped);
    }
    /**
     * Occurs just after the current SeriesViewer's window rectangle is changed.
    *
    * &lt;-- position: content member-->
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    * <IgrDataChart
    * 	width="100%"
    * 	height="100%"
    * 	dataSource={this.data}
    * 	windowRectChanged={this.onWindowRectChanged} >
    * <IgrCategoryXAxis name="xAxis" label="Year"/>
    * <IgrNumericYAxis name="yAxis" minimumValue={0} />
    * <IgrLineSeries name="series3" title="Russia"
    *     valueMemberPath="Russia"
    *     xAxisName="xAxis"
    *     yAxisName="yAxis"
    *     markerType={this.state.markersType} />
    * </IgrDataChart>
    * ```
    *
    * ```ts
    * public onWindowRectChanged =( s:any, e: RectChangedEventArgs) => {
    *
    *        }
    * ```
    */
    get windowRectChanged() {
        return this._windowRectChanged;
    }
    set windowRectChanged(ev) {
        if (this._windowRectChanged_wrapped !== null) {
            this.i.windowRectChanged = delegateRemove(this.i.windowRectChanged, this._windowRectChanged_wrapped);
            this._windowRectChanged_wrapped = null;
            this._windowRectChanged = null;
        }
        this._windowRectChanged = ev;
        this._windowRectChanged_wrapped = (o, e) => {
            let outerArgs = new IgrRectChangedEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeWindowRectChanged) {
                this.beforeWindowRectChanged(this, outerArgs);
            }
            if (this._windowRectChanged) {
                this._windowRectChanged(this, outerArgs);
            }
        };
        this.i.windowRectChanged = delegateCombine(this.i.windowRectChanged, this._windowRectChanged_wrapped);
    }
    /**
     * Occurs after the size of the series viewer changes.
    *
    * &lt;-- position: content member-->
    *
    * &lt;-- position: content member-->
    *
    * ```ts
    *  <IgrDataChart
    *     dataSource={this.state.dataSource}
    * 	sizeChanged={this.onSizeChanged=} >
    *
    *     <IgrNumericXAxis name="xAxis" />
    *     <IgrNumericYAxis name="yAxis" />
    *
    *     <IgrLineSeries
    *      name="series1"
    *     xAxisName="xAxis"
    * 	yAxisName="yAxis"
    * 	valueMemberPath="Value" />
    *  </IgrDataChart>
    * ```
    *
    * ```ts
    * public onSizeChanged =(event: any, args: RectChangedEventArgs}){
    *
    * }
    * ```
    */
    get sizeChanged() {
        return this._sizeChanged;
    }
    set sizeChanged(ev) {
        if (this._sizeChanged_wrapped !== null) {
            this.i.sizeChanged = delegateRemove(this.i.sizeChanged, this._sizeChanged_wrapped);
            this._sizeChanged_wrapped = null;
            this._sizeChanged = null;
        }
        this._sizeChanged = ev;
        this._sizeChanged_wrapped = (o, e) => {
            let outerArgs = new IgrRectChangedEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeSizeChanged) {
                this.beforeSizeChanged(this, outerArgs);
            }
            if (this._sizeChanged) {
                this._sizeChanged(this, outerArgs);
            }
        };
        this.i.sizeChanged = delegateCombine(this.i.sizeChanged, this._sizeChanged_wrapped);
    }
    /**
     * Raised when the actual window rectangle of the SeriesViewer changes.
    */
    get actualWindowRectChanged() {
        return this._actualWindowRectChanged;
    }
    set actualWindowRectChanged(ev) {
        if (this._actualWindowRectChanged_wrapped !== null) {
            this.i.actualWindowRectChanged = delegateRemove(this.i.actualWindowRectChanged, this._actualWindowRectChanged_wrapped);
            this._actualWindowRectChanged_wrapped = null;
            this._actualWindowRectChanged = null;
        }
        this._actualWindowRectChanged = ev;
        this._actualWindowRectChanged_wrapped = (o, e) => {
            let outerArgs = new IgrRectChangedEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeActualWindowRectChanged) {
                this.beforeActualWindowRectChanged(this, outerArgs);
            }
            if (this._actualWindowRectChanged) {
                this._actualWindowRectChanged(this, outerArgs);
            }
        };
        this.i.actualWindowRectChanged = delegateCombine(this.i.actualWindowRectChanged, this._actualWindowRectChanged_wrapped);
    }
    /**
     * Occurs just after the current SeriesViewer's grid area rectangle is changed.
     * The grid area may change as the result of the SeriesViewer being resized, or
     * of an axis being added or changing size, possibly in another SeriesViewer.
    */
    get gridAreaRectChanged() {
        return this._gridAreaRectChanged;
    }
    set gridAreaRectChanged(ev) {
        if (this._gridAreaRectChanged_wrapped !== null) {
            this.i.gridAreaRectChanged = delegateRemove(this.i.gridAreaRectChanged, this._gridAreaRectChanged_wrapped);
            this._gridAreaRectChanged_wrapped = null;
            this._gridAreaRectChanged = null;
        }
        this._gridAreaRectChanged = ev;
        this._gridAreaRectChanged_wrapped = (o, e) => {
            let outerArgs = new IgrRectChangedEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeGridAreaRectChanged) {
                this.beforeGridAreaRectChanged(this, outerArgs);
            }
            if (this._gridAreaRectChanged) {
                this._gridAreaRectChanged(this, outerArgs);
            }
        };
        this.i.gridAreaRectChanged = delegateCombine(this.i.gridAreaRectChanged, this._gridAreaRectChanged_wrapped);
    }
    /**
     * Raised when the SeriesViewer's processing for an update has completed.
    */
    get refreshCompleted() {
        return this._refreshCompleted;
    }
    set refreshCompleted(ev) {
        if (this._refreshCompleted_wrapped !== null) {
            this.i.refreshCompleted = delegateRemove(this.i.refreshCompleted, this._refreshCompleted_wrapped);
            this._refreshCompleted_wrapped = null;
            this._refreshCompleted = null;
        }
        this._refreshCompleted = ev;
        this._refreshCompleted_wrapped = (o, e) => {
            let outerArgs = new IgrRefreshCompletedEventArgs();
            outerArgs._provideImplementation(e);
            if (this.beforeRefreshCompleted) {
                this.beforeRefreshCompleted(this, outerArgs);
            }
            if (this._refreshCompleted) {
                this._refreshCompleted(this, outerArgs);
            }
        };
        this.i.refreshCompleted = delegateCombine(this.i.refreshCompleted, this._refreshCompleted_wrapped);
    }
}
//# sourceMappingURL=igr-series-viewer.js.map
