realchart 0.9.29 → 0.9.31

package/dist/index.d.ts

@@ -1,14 +1,3 @@
-interface ImageExportOptions {
-    type?: 'png' | 'jpeg';
-    width?: number;
-    scale?: number;
-    fileName?: string;
-    url?: string;
-    hideScrollbar?: boolean;
-    hideNavigator?: boolean;
-    hideZoomButton?: boolean;
-}
-
 declare class DatetimeFormatter {
     private static readonly Formatters;
     static getFormatter(format: string): DatetimeFormatter;
@@ -138,7 +127,7 @@ interface ISides {
 }
 declare enum AlignBase {
     CHART = "chart",
-    PLOT = "plot",
+    BODY = "body",
     PARENT = "parent"
 }
 interface IValueRange {
@@ -178,15 +167,11 @@ declare abstract class RcObject {
     toBool(v: any): boolean;
     toNum(v: any, def?: number): number;
 }
-declare abstract class RcWrappableObject extends RcObject {
-    protected _wrapper: any;
-    wrapper(): any;
-    wrapperOrThis(): any;
-    createWrapper<T>(clazz: {
-        new (): T;
-    }): T;
-    setWrapper<T>(wrapper: T): T;
-    isWrapper(w: any): boolean;
+declare abstract class RcEventProvider<T> extends RcObject {
+    private _listeners;
+    addListener(listener: T): void;
+    removeListener(listener: T): void;
+    protected _fireEvent(event: string, ...args: any[]): any;
 }
 
 interface IPoint {
@@ -202,7 +187,7 @@ interface IPointerHandler {
     handleDblClick(ev: PointerEvent): void;
     handleWheel(ev: WheelEvent): void;
 }
-declare abstract class RcControl extends RcWrappableObject {
+declare abstract class RcControl extends RcObject {
     static readonly CLASS_NAME = "rct-control";
     static readonly SHADOW_FILTER = "rr-chart-shadow-filter";
     static _animatable: boolean;
@@ -211,7 +196,6 @@ declare abstract class RcControl extends RcWrappableObject {
     private _htmlRoot;
     private _svg;
     private _defs;
-    private _back;
     private _root;
     private _pointerHandler;
     private _inited;
@@ -243,7 +227,6 @@ declare abstract class RcControl extends RcWrappableObject {
     clearTemporaryDefs(): void;
     appendDom(elt: HTMLElement): void;
     addElement(elt: RcElement): void;
-    removeElement(elt: RcElement): void;
     setPointerHandler(handler: IPointerHandler): void;
     invalidate(force?: boolean): void;
     invalidateLayout(force?: boolean): void;
@@ -264,7 +247,6 @@ declare abstract class RcControl extends RcWrappableObject {
     containerToElement(element: RcElement, x: number, y: number): IPoint;
     svgToElement(element: RcElement, x: number, y: number): IPoint;
     elementToSvg(element: RcElement, x: number, y: number): IPoint;
-    test(canvas: HTMLCanvasElement): void;
     protected _setTesting(): void;
     protected _setSize(w: number, h: number): void;
     private $_addListener;
@@ -306,8 +288,8 @@ declare class RcElement extends RcObject {
     private _width;
     private _height;
     private _zIndex;
-    private _translateX;
-    private _translateY;
+    private _tx;
+    private _ty;
     private _scaleX;
     private _scaleY;
     private _rotation;
@@ -317,6 +299,7 @@ declare class RcElement extends RcObject {
     protected _styleName: string;
     protected _styles: any;
     protected _styleDirty: boolean;
+    tag: any;
     private _dom;
     private _parent;
     removing: boolean;
@@ -348,11 +331,11 @@ declare class RcElement extends RcObject {
     hasStyle(className: string): boolean;
     add(child: RcElement): RcElement;
     insertChild(child: RcElement, before: RcElement): RcElement;
+    insertAfter(child: RcElement, after: RcElement): RcElement;
     insertFirst(child: RcElement): RcElement;
-    removeChild(child: RcElement): void;
-    remove(): RcElement;
     appendElement(doc: Document, tag: string): SVGElement;
     insertElement(doc: Document, tag: string, before: Node): SVGElement;
+    remove(): RcElement;
     getAttr(attr: string): any;
     setAttr(attr: string, value: any): RcElement;
     setAttrEx(attr: string, value: any): RcElement;
@@ -364,21 +347,21 @@ declare class RcElement extends RcObject {
     setRect(rect: IRect): RcElement;
     getRect(): IRect;
     getSize(): ISize;
-    getBBounds(): IRect;
+    getBBox(): IRect;
     controlToElement(x: number, y: number): IPoint;
     svgToElement(x: number, y: number): IPoint;
     elementToSvg(x: number, y: number): IPoint;
     move(x: number, y: number): RcElement;
-    movep(p: IPoint): RcElement;
+    setPos(x: number, y: number): void;
     isDomAnimating(): boolean;
     rotate(angle: number): RcElement;
     internalRotate(angle: number): void;
     scale(s: number): RcElement;
-    translate(x: number, y: number): RcElement;
-    translatep(p: IPoint): RcElement;
-    translateEx(x: number, y: number, duration?: number, invalidate?: boolean): RcElement;
-    translateX(x: number): RcElement;
-    translateY(y: number): RcElement;
+    trans(x: number, y: number): RcElement;
+    transp(p: IPoint): RcElement;
+    transEx(x: number, y: number, duration?: number, invalidate?: boolean): RcElement;
+    transX(x: number): RcElement;
+    transY(y: number): RcElement;
     resize(width: number, height: number, attr?: boolean): RcElement;
     appendDom(dom: Node): Node;
     insertDom(dom: Node, before: Node): Node;
@@ -398,6 +381,10 @@ declare class RcElement extends RcObject {
     setClass(value: string): void;
     setStyle(prop: string, value: string): boolean;
     internalSetStyle(prop: string, value: string): void;
+    setColor(color: string): void;
+    setFill(color: string): void;
+    setStroke(color: string): void;
+    setTransparent(): void;
     textAlign(): Align;
     setData(data: string, value?: string): void;
     unsetData(data: string): void;
@@ -410,8 +397,10 @@ declare class RcElement extends RcObject {
     setCursor(cursor: string): void;
     ignorePointer(): void;
     contains(dom: Element): boolean;
-    front(siblings: RcElement[]): void;
+    front(siblings: RcElement[], group?: RcElement[]): void;
     back(siblings: RcElement[]): void;
+    invalidate(): void;
+    sort(children: RcElement[]): void;
     protected _testing(): boolean;
     protected _doAttached(parent: RcElement): void;
     protected _doDetached(parent: RcElement): void;
@@ -490,7 +479,7 @@ declare class TextElement extends RcElement {
     clearDom(): void;
     setStyles(styles: any): boolean;
     setStyle(prop: string, value: string): boolean;
-    getBBounds(): IRect;
+    getBBox(): IRect;
     getBBoundsTest(): IRect;
     stain(): void;
 }
@@ -529,6 +518,35 @@ declare class SvgRichText {
     $_parse(fmt: string): void;
 }
 
+declare enum PaletteMode {
+    NORMAL = "normal",
+    SHUFFLE = "shuffle",
+    RANDOM = "random"
+}
+
+interface IAssetItem {
+    id: string;
+}
+declare abstract class AssetItem<T extends IAssetItem> {
+    source: T;
+    constructor(source: T);
+    hasDef(): boolean;
+    abstract getEelement(doc: Document, source: T): Element;
+}
+interface IAssetOwner {
+    addDef(element: Element): void;
+    removeDef(element: string): void;
+}
+declare class AssetCollection {
+    private _items;
+    private _map;
+    load(source: any): void;
+    register(doc: Document, owner: IAssetOwner): void;
+    unregister(doc: Document, owner: IAssetOwner): void;
+    get(id: string): AssetItem<IAssetItem>;
+    private $_loadItem;
+}
+
 declare class ChartItem extends RcObject {
     static readonly UPDATED = "updated";
     readonly chart: IChart;
@@ -599,6 +617,27 @@ declare abstract class FormattableText extends ChartText {
     private $_getNumberText;
     protected _getText(text: string, value: any, useSymbols: boolean, forceSymbols?: boolean): string;
 }
+declare enum LabelIconPostion {
+    DEFAULT = "default",
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+declare abstract class IconedText extends FormattableText {
+    private _images;
+    private _root;
+    iconPosition: LabelIconPostion;
+    imageList: string;
+    iconRoot: string;
+    iconGap: number;
+    width: number;
+    height: number;
+    abstract getDefaultIconPos(): LabelIconPostion;
+    getIconPos(): LabelIconPostion;
+    protected _doPrepareRender(chart: IChart): void;
+    getUrl(url: string): string;
+}
 declare class BackgroundImage extends ChartItem {
     url: string;
     style: SVGStyleOrClass;
@@ -614,20 +653,64 @@ declare enum Shape {
     RECTANGLE = "rectangle"
 }
 
-declare enum LineType {
-    DEFAULT = "default",
-    SPLINE = "spline",
-    STEP = "step"
+interface IChartDataListener {
+    onDataValueChanged?(data: ChartData, row: number, field: string, value: any, oldValue: any): void;
+    onDataRowUpdated?(data: ChartData, row: number, oldValues: any): void;
+    onDataRowAdded?(data: ChartData, row: number): void;
+    onDataRowDeleted?(data: ChartData, row: number): void;
+    onDataChanged?(data: ChartData): void;
+}
+interface IRcChartDataOptions {
+    fields?: string[];
+    field?: string;
+}
+declare class ChartData extends RcEventProvider<IChartDataListener> {
+    _rows: any[];
+    private _fields;
+    private _field;
+    private _fieldMap;
+    constructor(options: IRcChartDataOptions, rows: any[]);
+    private $_buildOptions;
+    _internalValues(): any[];
+    private $_readRow;
+    getValue(row: number, field: string): any;
+    setValue(row: number, field: string, value: any): void;
+    getValues(field: string, fromRow: number, toRow: number): any[];
+    getRow(row: number): object;
+    addRow(values: any, row: number): void;
+    deleteRow(row: number): void;
+    protected _checkRow(row: number): void;
+    protected _changed(): void;
+}
+declare class ChartDataCollection {
+    private _map;
+    get(name: string): ChartData;
+    load(source: any): void;
 }
 
-interface IPointPos {
-    xPos: number;
-    yPos: number;
-    isNull?: boolean;
-    range?: IValueRange;
+type RcAnimationEndHandler = (ani: RcAnimation) => void;
+declare abstract class RcAnimation {
+    static readonly DURATION = 700;
+    static readonly SHORT_DURATION = 300;
+    delay: number;
+    duration: number;
+    easing: string;
+    endHandler: RcAnimationEndHandler;
+    private _easing;
+    private _started;
+    private _timer;
+    private _handler;
+    start(endHandler?: RcAnimationEndHandler): RcAnimation;
+    stop(): void;
+    protected _start(duration: number, delay?: number, easing?: string): void;
+    protected _stop(): void;
+    protected _doStart(): void;
+    protected _doStop(): void;
+    protected _canUpdate(): boolean;
+    protected abstract _doUpdate(rate: number): boolean;
 }
+
 declare class DataPoint {
-    static swap(pts: IPointPos[]): IPointPos[];
     index: number;
     vindex: number;
     x: any;
@@ -648,18 +731,22 @@ declare class DataPoint {
     range: IValueRange;
     zValue: number;
     label: any;
+    ani: RcAnimation;
+    yPrev: number;
+    yNew: number;
     constructor(source: any);
-    get yAbs(): number;
-    get xAbs(): number;
     ariaHint(): string;
     labelCount(): number;
+    getValue(): number;
+    proxy(): any;
     assignTo(proxy?: any): any;
     getProp(fld: string | number): any;
     parse(series: ISeries): void;
     getLabel(index: number): any;
     swap(): void;
     getTooltipPos(): IPoint;
-    toPoint(): IPointPos;
+    updateValue(value: number, animation: RcAnimation): void;
+    cleanValue(): void;
     protected _assignTo(proxy: any): any;
     protected _readArray(series: ISeries, v: any[]): void;
     protected _readObject(series: ISeries, v: any): void;
@@ -672,9 +759,12 @@ declare class DataPointCollection {
     get count(): number;
     isEmpty(): boolean;
     get(index: number): DataPoint;
-    pointAt(xValue: number): DataPoint;
+    pointAt(xValue: number | any): DataPoint;
     contains(p: DataPoint): boolean;
     load(source: any): void;
+    clear(): void;
+    add(p: DataPoint): void;
+    remove(p: DataPoint): boolean;
     getProps(prop: string | number): any[];
     getCategories(axis: string): any[];
     getProxies(): any[];
@@ -744,7 +834,7 @@ declare enum PointItemPosition {
     INSIDE_FIRST = "insideFirst",
     OUTSIDE_FIRST = "outsideFirst"
 }
-declare class DataPointLabel extends FormattableText {
+declare class DataPointLabel extends IconedText {
     private static readonly OFFSET;
     private _point;
     _domain: IRichTextDomain;
@@ -759,6 +849,7 @@ declare class DataPointLabel extends FormattableText {
     getTextDomain(p: DataPoint): IRichTextDomain;
     getText(value: any): string;
     getOffset(): number;
+    getDefaultIconPos(): LabelIconPostion;
     protected _doLoadSimple(source: any): boolean;
     protected _doPrepareRender(chart: IChart): void;
 }
@@ -790,7 +881,9 @@ interface IPlottingItem {
     prepareRender(): void;
     prepareAfter(): void;
     collectValues(axis: IAxis, vals: number[]): void;
+    collectRanges(vals: number[]): void;
     pointValuesPrepared(axis: IAxis): void;
+    seriesChanged(): boolean;
 }
 declare enum TrendType {
     LINEAR = "linear",
@@ -800,27 +893,26 @@ declare enum TrendType {
     EXPONENTIAL = "exponential",
     MOVING_AVERAGE = "movingAverage"
 }
-declare class MovingAverage extends RcObject {
-    interval: number;
-    type: 'simple' | 'weighted' | 'exponential' | 'triangualr';
-}
 declare class Trendline extends ChartItem {
     series: Series;
     _points: {
         x: number;
         y: number;
     }[];
+    private _res;
     constructor(series: Series);
     type: TrendType;
-    lineType: LineType;
-    movingAverage: MovingAverage;
+    resolution: number;
+    movingInterval: number;
+    curved: boolean;
     protected _doPrepareRender(chart: IChart): void;
+    isCurved(): boolean;
     private $_calcLine;
-    private $_calcLine2;
     private $_linear;
     private $_logarithmic;
-    private $_exponential;
     private $_power;
+    private $_calcLine2;
+    private $_exponential;
     $_polynomial(pts: IPoint[], list: {
         x: number;
         y: number;
@@ -834,11 +926,14 @@ interface ISeries extends IPlottingItem {
     chart: IChart;
     group: ISeriesGroup;
     xField: string | number;
-    yField: string | number;
+    yField: string | number | Function;
+    _xFielder: (src: any) => any;
+    _yFielder: (src: any) => any;
+    _colorFielder: (src: any) => any;
     colorField: string | number;
     color: string;
     displayName(): string;
-    createPoints(source: any[]): DataPoint[];
+    initPoints(source: any[]): DataPoint[];
     getPoints(): DataPointCollection;
     isVisible(p: DataPoint): boolean;
 }
@@ -864,16 +959,22 @@ interface IDataPointCallbackArgs {
 }
 type PointStyleCallback = (args: IDataPointCallbackArgs) => SVGStyleOrClass;
 type PointClickCallback = (args: IDataPointCallbackArgs) => boolean;
-declare abstract class Series extends ChartItem implements ISeries, ILegendSource, ITooltipContext {
+declare abstract class Series extends ChartItem implements ISeries, IChartDataListener, ILegendSource, ITooltipContext {
     static readonly LEGEND_MARKER = "rct-legend-item-marker";
     static _loadSeries(chart: IChart, src: any, defType?: string): Series;
     static getPointTooltipParam(series: Series, point: DataPoint, param: string): any;
+    private _data;
     _row: number;
     _col: number;
     index: number;
     group: SeriesGroup<Series>;
     _xAxisObj: IAxis;
     _yAxisObj: IAxis;
+    _xFielder: (src: any) => any;
+    _yFielder: (src: any) => any;
+    _colorFielder: (src: any) => any;
+    _dataDirty: boolean;
+    _cdata: ChartData;
     protected _points: DataPointCollection;
     _runPoints: DataPoint[];
     _visPoints: DataPoint[];
@@ -896,6 +997,11 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     constructor(chart: IChart, name?: string);
     protected _initProps(): void;
     protected _createLabel(chart: IChart): DataPointLabel;
+    onDataValueChanged(data: ChartData, row: number, field: string, value: any, oldValue: any): void;
+    onDataRowUpdated(data: ChartData, row: number, oldValues: any): void;
+    onDataRowAdded(data: ChartData, row: number): void;
+    onDataRowDeleted(data: ChartData, row: number): void;
+    onDataChanged(data: ChartData): void;
     getTooltipText(series: ISeries, point: DataPoint): string;
     getTooltipParam(series: ISeries, point: DataPoint, param: string): any;
     abstract _type(): string;
@@ -910,14 +1016,15 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     xAxis: string | number;
     yAxis: string | number;
     xField: string | number;
-    yField: string | number;
+    yField: string | number | Function;
     colorField: string;
-    dataProp: string;
+    get data(): any;
+    set data(value: any);
     xStart: any;
     xStep: number | string;
     pointStyle: SVGStyleOrClass;
     color: string;
-    pointColors: boolean | string[];
+    pointColors: string[] | string;
     viewRanges: IValueRange[] | IValueRanges;
     viewRangeValue: 'x' | 'y' | 'z';
     noClip: boolean;
@@ -948,18 +1055,19 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     canMaxPadding(axis: IAxis, max: number): boolean;
     hasMarker(): boolean;
     setShape(shape: Shape): void;
+    seriesChanged(): boolean;
     getVisibleSeries(): ISeries[];
     needClip(polar: boolean): boolean;
     setCol(col: number): void;
     setRow(row: number): void;
-    createPoints(source: any[]): DataPoint[];
+    initPoints(source: any[]): DataPoint[];
     private $_getXStart;
     getXStep(): number;
     prepareRender(): void;
     prepareAfter(): void;
     collectCategories(axis: IAxis): string[];
     collectValues(axis: IAxis, vals: number[]): void;
-    collectVisibles(): DataPoint[];
+    collectRanges(vals: number[]): void;
     protected _getRangeMinMax(axis: 'x' | 'y' | 'z'): {
         min: number;
         max: number;
@@ -983,17 +1091,25 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     getViewRangeAxis(): 'x' | 'y' | 'z';
     isPointLabelsVisible(): boolean;
     isPointLabelVisible(p: DataPoint): boolean;
+    getPointAt(xValue: number | string | object): DataPoint;
+    setValueAt(p: DataPoint, yValue: number, animate: boolean): boolean;
+    findPoint(keys: any): DataPoint;
     updateData(data: any): void;
-    getPointAt(xValue: number): DataPoint;
+    addPoint(source: any, animate: boolean): DataPoint;
+    removePoint(p: DataPoint): boolean;
     protected _createPoint(source: any): DataPoint;
+    private $_addPoint;
+    protected _doAddPoint(source: any): DataPoint;
+    protected _doPointRemoved(point: DataPoint): void;
     protected _createLegendMarker(doc: Document, size: number): RcElement;
     _referOtherSeries(series: Series): boolean;
-    protected _getField(axis: IAxis): any;
     _colorByPoint(): boolean;
+    protected _createFilder(f: any): (v: any) => any;
+    protected _createFielders(): void;
     protected _doLoad(src: any): void;
-    protected _loadData(src: any): any;
-    protected _doLoadPoints(src: any[]): void;
-    loadPoints(src: any[]): void;
+    protected _doLoadData(src: any): any[];
+    _loadPoints(data: any): void;
+    protected _doLoadPoints(src: any): void;
     protected _doPrepareRender(): void;
     protected _setViewRange(p: DataPoint, axis: 'x' | 'y' | 'z'): void;
     _defViewRangeValue(): 'x' | 'y' | 'z';
@@ -1026,6 +1142,9 @@ declare class PlottingItemCollection {
     seriesByPoint(point: DataPoint): Series;
     getLegendSources(): ILegendSource[];
     load(src: any): void;
+    private $_add;
+    add(source: any): Series;
+    remove(series: string | Series): Series;
     updateData(values: any[]): void;
     prepareRender(): void;
     prepareAfter(): void;
@@ -1053,6 +1172,7 @@ declare abstract class SeriesGroup<T extends Series> extends ChartItem implement
     _yAxisObj: IAxis;
     _stackPoints: Map<number, DataPoint[]>;
     _stacked: boolean;
+    private _seriesChanged;
     constructor(chart: IChart);
     getTooltipText(series: ISeries, point: DataPoint): string;
     getTooltipParam(series: ISeries, point: DataPoint, param: string): string;
@@ -1083,6 +1203,7 @@ declare abstract class SeriesGroup<T extends Series> extends ChartItem implement
     isFirstVisible(series: ISeries): boolean;
     isLastVisible(series: ISeries): boolean;
     collectValues(axis: IAxis, vals: number[]): void;
+    collectRanges(vals: number[]): void;
     pointValuesPrepared(axis: IAxis): void;
     collectCategories(axis: IAxis): string[];
     getLegendSources(list: ILegendSource[]): void;
@@ -1090,6 +1211,8 @@ declare abstract class SeriesGroup<T extends Series> extends ChartItem implement
     canMinPadding(axis: IAxis, min: number): boolean;
     canMaxPadding(axis: IAxis, max: number): boolean;
     getVisPoints(p: DataPoint): DataPoint[];
+    seriesChanged(): boolean;
+    remove(series: T): boolean;
     getVisiblePoints(): DataPoint[];
     protected _doLoadProp(prop: string, value: any): boolean;
     prepareRender(): void;
@@ -1123,6 +1246,7 @@ declare abstract class Annotation extends ChartItem {
     scope: AnnotationScope;
     series: string;
     loadAnimation: IAnnotationAnimation;
+    backgroundStyle: SVGStyleOrClass;
     getPosition(inverted: boolean, left: number, top: number, wDomain: number, hDomain: number, width: number, height: number): IPoint;
     update(): void;
     protected _doPrepareRender(chart: IChart): void;
@@ -1188,18 +1312,12 @@ declare class Body extends ChartItem {
     private $_loadAnnotations;
 }
 
-declare enum PaletteMode {
-    NORMAL = "normal",
-    MIXED = "mixed",
-    RANDOM = "random"
-}
-
 declare class Title extends ChartItem {
     constructor(chart: IChart);
-    verticalAlign: VerticalAlign;
     text: string;
     alignBase: AlignBase;
     align: Align;
+    verticalAlign: VerticalAlign;
     backgroundStyle: SVGStyleOrClass;
     gap: number;
     isVisible(): boolean;
@@ -1212,8 +1330,8 @@ declare enum SubtitlePosition {
     TOP = "top"
 }
 declare class Subtitle extends Title {
-    position: SubtitlePosition;
     verticalAlign: VerticalAlign;
+    position: SubtitlePosition;
     text: string;
     titleGap: number;
 }
@@ -1316,169 +1434,12 @@ declare abstract class ValueGauge extends Gauge {
     getParam(param: string): any;
     calcedMinMax(): IMinMax;
 }
-declare class GuageScaleTick extends ChartItem {
-    scale: GaugeScale;
-    constructor(scale: GaugeScale);
-    reversed: boolean;
-    length: number;
-}
-declare class GaugeScaleLabel extends FormattableText {
-    getText(value: any): string;
-}
-declare abstract class GaugeScale extends ChartItem {
-    gauge: ValueGauge | GaugeGroup<ValueGauge>;
-    private _gap;
-    private _step;
-    _steps: number[];
-    _min: number;
-    _max: number;
-    constructor(gauge: ValueGauge | GaugeGroup<ValueGauge>, visible?: boolean);
-    position: GaugeItemPosition;
-    line: ChartItem;
-    tick: GuageScaleTick;
-    label: GaugeScaleLabel;
-    steps: number[];
-    stepCount: number;
-    stepInterval: number;
-    stepPixels: number;
-    get gap(): number;
-    set gap(value: number);
-    range(): IMinMax;
-    isEmpty(): boolean;
-    buildSteps(length: number, value: number, target?: number): number[];
-    buildGroupSteps(length: number, values: number[]): number[];
-    getRate(value: number): number;
-    protected _adjustMinMax(min: number, max: number): {
-        min: number;
-        max: number;
-    };
-    protected _adjustGroupMinMax(values: number[]): {
-        min: number;
-        max: number;
-    };
-    protected _buildSteps(length: number, min: number, max: number): number[];
-    protected _getStepsByCount(count: number, min: number, max: number): number[];
-    protected _getStepsByInterval(interval: number, min: number, max: number): number[];
-    protected _getStepMultiples(step: number): number[];
-    protected _getStepsByPixels(length: number, pixels: number, min: number, max: number): number[];
-}
-declare enum GaugeItemPosition {
-    DEFAULT = "default",
-    OPPOSITE = "opposite",
-    INSIDE = "inside"
-}
-declare class RangeLabel extends ChartItem {
-}
-declare class GaugeRangeBand extends ChartItem {
-    gauge: ValueGauge | GaugeGroup<ValueGauge>;
-    static readonly DEF_THICKNESS = 7;
-    private _ranges;
-    private _thickness;
-    private _runRanges;
-    private _thickDim;
-    constructor(gauge: ValueGauge | GaugeGroup<ValueGauge>, visible?: boolean);
-    position: GaugeItemPosition;
-    get thickness(): RtPercentSize;
-    set thickness(value: RtPercentSize);
-    gap: number;
-    itemGap: number;
-    get ranges(): IValueRange[];
-    set ranges(value: IValueRange[]);
-    rangeLabel: RangeLabel;
-    tickLabel: ChartItem;
-    getThickness(domain: number): number;
-    private $_internalRanges;
-}
 declare abstract class GaugeLabel extends FormattableText {
     _domain: IRichTextDomain;
     constructor(chart: IChart);
     animatable: boolean;
     protected _doPrepareRender(chart: IChart): void;
 }
-declare class CircularGaugeLabel extends GaugeLabel {
-    private _offsetXDim;
-    private _offsetYDim;
-    offsetX: RtPercentSize;
-    offsetY: RtPercentSize;
-    getOffset(width: number, height: number): IPoint;
-    load(source: any): ChartItem;
-}
-interface ICircularGaugeExtents {
-    scale?: number;
-    scaleTick?: number;
-    scaleLabel?: number;
-    band?: number;
-    bandThick?: number;
-    bandTick?: number;
-    radius: number;
-    radiusThick: number;
-    inner: number;
-    value: number;
-}
-declare class CircularProps {
-    private _centerX;
-    private _centerY;
-    private _radius;
-    private _innerRadius;
-    private _valueRadius;
-    private _centerXDim;
-    private _centerYDim;
-    private _radiusDim;
-    private _innerDim;
-    private _valueDim;
-    _startRad: number;
-    _handRad: number;
-    _sweepRad: number;
-    constructor(grouped?: boolean);
-    centerX(): RtPercentSize;
-    setCenterX(value: RtPercentSize): void;
-    centerY(): RtPercentSize;
-    setCenterY(value: RtPercentSize): void;
-    radius(): RtPercentSize;
-    setRadius(value: RtPercentSize): void;
-    innerRadius(): RtPercentSize;
-    setInnerRadius(value: RtPercentSize): void;
-    valueRadius(): RtPercentSize;
-    setValueRadius(value: RtPercentSize): void;
-    getCenter(gaugeWidth: number, gaugeHeight: number): {
-        x: number;
-        y: number;
-    };
-    getExtents(gaugeSize: number): ICircularGaugeExtents;
-    prepareAngles(startAngle: number, sweepAngle: number): void;
-}
-declare abstract class CircularGauge extends ValueGauge {
-    static readonly DEF_CENTER = "50%";
-    static readonly DEF_RADIUS = "40%";
-    static readonly DEF_INNER = "80%";
-    props: CircularProps;
-    childProps: CircularProps;
-    constructor(chart: IChart);
-    get centerX(): RtPercentSize;
-    set centerX(value: RtPercentSize);
-    get centerY(): RtPercentSize;
-    set centerY(value: RtPercentSize);
-    get radius(): RtPercentSize;
-    set radius(value: RtPercentSize);
-    get innerRadius(): RtPercentSize;
-    set innerRadius(value: RtPercentSize);
-    get valueRadius(): RtPercentSize;
-    set valueRadius(value: RtPercentSize);
-    startAngle: number;
-    sweepAngle: number;
-    clockwise: boolean;
-    label: CircularGaugeLabel;
-    innerStyle: SVGStyleOrClass;
-    getProps(): CircularProps;
-    getCenter(gaugeWidth: number, gaugeHeight: number): {
-        x: number;
-        y: number;
-    };
-    getExtents(gaugeSize: number): ICircularGaugeExtents;
-    labelVisible(): boolean;
-    setGroup(group: GaugeGroup<ValueGauge>, index: number): void;
-    protected _doPrepareRender(chart: IChart): void;
-}
 
 declare class PaneBody extends Body {
     pane: Pane;
@@ -1541,12 +1502,14 @@ interface IChartProxy {
 }
 interface IChart {
     _proxy: IChartProxy;
+    data: ChartDataCollection;
     type: string;
     gaugeType: string;
+    assets: AssetCollection;
     _xPaneAxes: PaneXAxisMatrix;
     _yPaneAxes: PaneYAxisMatrix;
     options: ChartOptions;
-    export: ExportOptions;
+    exportOptions: IExportOptions;
     first: IPlottingItem;
     firstSeries: Series;
     xAxis: IAxis;
@@ -1565,6 +1528,7 @@ interface IChart {
     isInverted(): boolean;
     isSplitted(): boolean;
     animatable(): boolean;
+    loadAnimatable(): boolean;
     seriesByName(series: string): Series;
     axisByName(axis: string): Axis;
     getAxes(dir: SectionDir, visibleOnly: boolean): Axis[];
@@ -1588,6 +1552,8 @@ interface IChart {
     layoutAxes(width: number, height: number, inverted: boolean, phase: number): void;
     getParam(target: any, param: string): any;
     setParam(param: string, value: any, redraw?: boolean): void;
+    dataChanged(): void;
+    isDataChanged(): boolean;
 }
 declare class Credits extends ChartItem {
     text: string;
@@ -1613,17 +1579,21 @@ declare class ChartOptions extends ChartItem {
 }
 declare enum ExportType {
     PNG = "png",
-    JPEG = "jpeg"
-}
-declare class ExportOptions extends ChartItem {
-    menus: ExportType[];
-    fileName: string;
-    width: number;
-    scale: number;
-    url: string;
-    hideScrollbar: boolean;
-    hideNavigator: boolean;
-    hideZoomButton: boolean;
+    JPEG = "jpeg",
+    SVG = "svg",
+    PDF = "pdf",
+    PRINT = "print"
+}
+interface IExportOptions {
+    visible?: boolean;
+    menus?: ExportType[];
+    fileName?: string;
+    width?: number;
+    scale?: number;
+    url?: string;
+    hideScrollbar?: boolean;
+    hideNavigator?: boolean;
+    hideZoomButton?: boolean;
 }
 
 declare enum CrosshairType {
@@ -1671,7 +1641,7 @@ interface IAxis {
     reversed: boolean;
     _vlen: number;
     _zoom: IAxisZoom;
-    isContinuous(): boolean;
+    continuous(): boolean;
     getBaseValue(): number;
     axisMax(): number;
     axisMin(): number;
@@ -1681,10 +1651,11 @@ interface IAxis {
     getXValue(value: number): any;
     contains(value: number): boolean;
     incStep(value: number, step: any): number;
-    getPosition(length: number, value: number, point?: boolean): number;
-    getValueAt(length: number, pos: number): number;
-    getAxisValueAt(length: number, pos: number): any;
-    getUnitLength(length: number, value: number): number;
+    getPos(length: number, value: number): number;
+    valueAt(length: number, pos: number): number;
+    axisValueAt(length: number, pos: number): any;
+    xValueAt(pos: number): number;
+    getUnitLen(length: number, value: number): number;
     value2Tooltip(value: number): any;
     hasBreak(): boolean;
     isBreak(pos: number): boolean;
@@ -1694,7 +1665,7 @@ declare abstract class AxisItem extends ChartItem {
     constructor(axis: Axis, visible?: boolean);
 }
 declare class AxisLine extends AxisItem {
-    constructor(axis: Axis);
+    constructor(axis: Axis, visible: boolean);
     protected _doLoadSimple(source: any): boolean;
 }
 declare enum AxisTitleAlign {
@@ -1715,19 +1686,33 @@ declare class AxisTitle extends AxisItem {
     getRotation(axis: Axis): number;
     protected _doLoadSimple(source: any): boolean;
 }
-declare class AxisGrid extends AxisItem {
-    startVisible: boolean;
-    endVisible: boolean;
+interface IAxisGridRow {
+    axis: Axis;
+    from: number;
+    to: number;
+    color: string;
+}
+declare class AxisGridRows extends AxisItem {
+    colors: string[];
+    belowColor: string;
+    getRows(): IAxisGridRow[];
+    protected _doLoadSimple(source: any): boolean;
+}
+declare abstract class AxisGrid extends AxisItem {
     constructor(axis: Axis);
+    rows: AxisGridRows;
+    firstVisible: boolean;
+    lastVisible: boolean;
     isVisible(polar: boolean): boolean;
-    getPoints(length: number): number[];
+    abstract getPoints(length: number): number[];
 }
-declare class AxisGuideLabel extends FormattableText {
+declare class AxisGuideLabel extends IconedText {
     constructor(chart: IChart);
     align: Align;
     verticalAlign: VerticalAlign;
     offsetX: number;
     offsetY: number;
+    getDefaultIconPos(): LabelIconPostion;
 }
 declare abstract class AxisGuide extends AxisItem {
     constructor(axis: Axis);
@@ -1756,7 +1741,7 @@ interface IAxisLabelArgs {
     index: number;
     value: number;
 }
-declare abstract class AxisLabel extends FormattableText {
+declare abstract class AxisLabel extends IconedText {
     axis: Axis;
     _paramTick: IAxisTick;
     _domain: IRichTextDomain;
@@ -1774,10 +1759,13 @@ declare abstract class AxisLabel extends FormattableText {
     lastStyle: SVGStyleOrClass;
     textCallback: (args: IAxisLabelArgs) => string;
     styleCallback: (args: IAxisLabelArgs) => SVGStyleOrClass;
+    iconCallback: (args: IAxisLabelArgs) => string;
     abstract getTick(index: number, value: any): string;
     protected _getParamValue(tick: IAxisTick, param: string): any;
     getLabelText(tick: IAxisTick, count: number): string;
     getLabelStyle(tick: IAxisTick, count: number): any;
+    getIcon(tick: IAxisTick): string;
+    getDefaultIconPos(): LabelIconPostion;
     protected _doPrepareRender(chart: IChart): void;
 }
 interface IAxisTick {
@@ -1822,7 +1810,9 @@ declare class AxisZoom {
     total(): number;
     length(): number;
     isFull(): boolean;
-    resize(start: number, end: number): boolean;
+    resize(start: number, end: number, minSize: number): boolean;
+}
+declare class AxisSectorLine extends AxisLine {
 }
 declare abstract class Axis extends ChartItem implements IAxis {
     _index: number;
@@ -1850,12 +1840,15 @@ declare abstract class Axis extends ChartItem implements IAxis {
     protected _single: boolean;
     _runPos: AxisPosition;
     _labelArgs: IAxisLabelArgs;
+    _prevSeries: IPlottingItem[];
+    _seriesChanged: boolean;
+    _prevRate: number;
     constructor(chart: IChart, isX: boolean, name?: string);
     abstract _type(): string;
     readonly name: string;
     readonly title: AxisTitle;
     readonly line: AxisLine;
-    readonly sectorLine: AxisLine;
+    readonly sectorLine: AxisSectorLine;
     readonly tick: AxisTick;
     readonly label: AxisLabel;
     readonly grid: AxisGrid;
@@ -1876,50 +1869,58 @@ declare abstract class Axis extends ChartItem implements IAxis {
     tooltipHeader: string;
     tooltipRow: string;
     tooltipFooter: string;
+    animatable: boolean;
     isEmpty(): boolean;
     getBaseValue(): number;
     length(): number;
     axisMin(): number;
     axisMax(): number;
-    abstract isContinuous(): boolean;
-    abstract getValueAt(length: number, pos: number): number;
-    getAxisValueAt(length: number, pos: number): any;
+    abstract continuous(): boolean;
+    abstract valueAt(length: number, pos: number): number;
+    axisValueAt(length: number, pos: number): any;
     getStartAngle(): number;
     getTotalAngle(): number;
     isArced(): boolean;
     getVisibleSeries(): ISeries[];
+    unitPad(): number;
     protected abstract _createTickModel(): AxisTick;
-    protected abstract _createLabelModel(): AxisLabel;
+    protected abstract _createLabel(): AxisLabel;
     protected abstract _doPrepareRender(): void;
     protected abstract _doBuildTicks(min: number, max: number, length: number): IAxisTick[];
     value2Tooltip(value: number): any;
     isBased(): boolean;
+    isBaseVisible(): boolean;
     disconnect(): void;
     collectValues(): void;
+    collectRanges(): void;
     collectReferentsValues(): void;
     prepareRender(): void;
+    afterRender(): void;
     buildTicks(length: number): void;
     calcPoints(length: number, phase: number): void;
-    abstract getPosition(length: number, value: number, point?: boolean): number;
-    abstract getUnitLength(length: number, value: number): number;
+    abstract getPos(length: number, value: number): number;
+    abstract getUnitLen(length: number, value: number): number;
     getLabelLength(length: number, value: number): number;
     getValue(value: any): number;
     incStep(value: number, step: any): number;
     contains(value: number): boolean;
     resetZoom(): void;
     _prepareZoom(): AxisZoom;
-    zoom(start: number, end: number): boolean;
+    zoom(start: number, end: number, minSize?: number): boolean;
     isZoomed(): boolean;
     hasBreak(): boolean;
     isBreak(pos: number): boolean;
     getTickLabelArgs(index: number, value: any): IAxisLabelArgs;
     getXValue(value: number): any;
+    setPrevRate(rate: number): void;
+    prev(len: number): number;
+    abstract xValueAt(pos: number): number;
     protected _doLoadProp(prop: string, value: any): boolean;
     protected _setMinMax(min: number, max: number): void;
-    protected _createGrid(): AxisGrid;
+    protected abstract _createGrid(): AxisGrid;
     private $_loadGuides;
     _connect(series: IPlottingItem): void;
-    protected _doCalcluateRange(values: number[]): {
+    protected _doCalculateRange(values: number[]): {
         min: number;
         max: number;
     };
@@ -1939,8 +1940,10 @@ declare class AxisCollection {
     get(name: string | number): Axis;
     disconnect(): void;
     collectValues(): void;
+    collectRanges(): void;
     collectReferentsValues(): void;
     prepareRender(): void;
+    afterRender(): void;
     $_buildTicks(length: number): void;
     connect(series: IPlottingItem): Axis;
     forEach(callback: (p: Axis, i?: number) => any): void;
@@ -1975,84 +1978,6 @@ declare class PaneYAxisMatrix extends PaneAxisMatrix {
     prepare(axes: AxisCollection, rows: number, cols: number): void;
 }
 
-declare abstract class CircleGaugeRimBase extends ChartItem {
-    gauge: CircleGauge;
-    private _ranges;
-    private _runRanges;
-    constructor(gauge: CircleGauge);
-    get ranges(): IValueRange[];
-    set ranges(value: IValueRange[]);
-    rangeInclusive: boolean;
-    isRanged(): boolean;
-    rangeCount(): number;
-    getRange(value: number): IValueRange | undefined;
-    private $_internalRanges;
-}
-declare class CircleGaugeRim extends CircleGaugeRimBase {
-    private _segmentThickness;
-    private _thickDim;
-    constructor(gauge: CircleGauge);
-    get segmentThickness(): RtPercentSize;
-    set segmentThickness(value: RtPercentSize);
-    segmentGap: number;
-    getSegmentThickness(domain: number): number;
-}
-declare class CircleGaugeValueRim extends CircleGaugeRimBase {
-    private _thickness;
-    private _thickDim;
-    constructor(gauge: CircleGauge);
-    get thickness(): RtPercentSize;
-    set thickness(value: RtPercentSize);
-    stroked: boolean;
-    getThickness(domain: number): number;
-}
-declare class CircleGaugeValueMarker extends ChartItem {
-    constructor(gauge: CircleGauge);
-}
-declare class CircleGaugeHand extends ChartItem {
-    private _radius;
-    private _length;
-    private _offset;
-    private _radiusDim;
-    private _lengthDim;
-    private _offsetDim;
-    constructor(gauge: CircleGauge);
-    get radius(): RtPercentSize;
-    set radius(value: RtPercentSize);
-    get length(): RtPercentSize;
-    set length(value: RtPercentSize);
-    get offset(): RtPercentSize;
-    set offset(value: RtPercentSize);
-    getExtents(domain: number): {
-        radius: number;
-        length: number;
-        offset: number;
-    };
-}
-declare class CircleGaugePin extends ChartItem {
-    private _radius;
-    private _radiusDim;
-    constructor(gauge: CircleGauge);
-    get radius(): RtPercentSize;
-    set radius(value: RtPercentSize);
-    getRadius(domain: number): number;
-}
-declare class CircleGaugeScale extends GaugeScale {
-    stepPixels: number;
-    protected _getStepMultiples(step: number): number[];
-}
-declare class CircleGauge extends CircularGauge {
-    band: GaugeRangeBand;
-    scale: CircleGaugeScale;
-    rim: CircleGaugeRim;
-    valueRim: CircleGaugeValueRim;
-    marker: CircleGaugeValueMarker;
-    hand: CircleGaugeHand;
-    pin: CircleGaugePin;
-    _type(): string;
-    getExtents(gaugeSize: number): ICircularGaugeExtents;
-}
-
 declare class RcChartObject {
     $_p: ChartItem;
     protected constructor(proxy: ChartItem);
@@ -2086,11 +2011,15 @@ declare class RcChartAxis extends RcChartObject {
     resetZoom(): void;
     zoom(start: number, end: number): void;
 }
-declare class RcPointLabel extends RcChartAxis {
-}
 declare abstract class RcNamedObject extends RcChartObject {
     get name(): string;
 }
+interface IRcDataPoint {
+    pid: number;
+    xValue: number;
+    yValue: number;
+    zValue: number;
+}
 declare class RcChartSeries extends RcNamedObject {
     private _pointLabel;
     private _trendLine;
@@ -2099,72 +2028,27 @@ declare class RcChartSeries extends RcNamedObject {
     get pointLabel(): RcChartObject;
     get trendLine(): RcChartObject;
     get tooltip(): RcChartObject;
-    getValueAt(xValue: number): number;
+    get pointCount(): number;
+    get visiblePointCount(): number;
+    getPointAt(xValue: number | string): IRcDataPoint;
+    findPoint(keys: any): IRcDataPoint;
+    getValueAt(xValue: number | string | IRcDataPoint): number;
+    setValueAt(xValue: number | string | IRcDataPoint, value: number, animate?: boolean): boolean;
+    addPoint(source: any, animate?: boolean): IRcDataPoint;
+    removePoint(xValue: number | string | IRcDataPoint): boolean;
+    addPoints(source: any[]): IRcDataPoint[];
+    removePoints(point: IRcDataPoint[]): void;
     updateData(data: any): void;
 }
 declare class RcSeriesGroup extends RcNamedObject {
 }
-declare abstract class RcChartGaugeBase extends RcNamedObject {
-}
-declare abstract class RcChartGauge extends RcChartGaugeBase {
-}
-declare abstract class RcValueGauge extends RcChartGauge {
-    updateValue(value: any, animate?: boolean): void;
-}
-declare class RcGaugeScale extends RcChartObject {
-    private _line;
-    private _tick;
-    private _tickLabel;
-    protected _doInit(proxy: ChartItem): void;
-    get line(): RcChartObject;
-    get tick(): RcChartObject;
-    get tickLabel(): RcChartObject;
-}
-declare abstract class RcCircularGauge extends RcValueGauge {
-    private _label;
-    protected _doInit(proxy: ChartItem): void;
-    get label(): RcChartObject;
-}
-declare class RcGaugeRangeBand extends RcChartObject {
-    private _rangeLabel;
-    private _tickLabel;
-    protected _doInit(proxy: ChartItem): void;
-    get rangeLabel(): RcChartObject;
-    get tickLabel(): RcChartObject;
-}
-declare class RcCircleGauge extends RcCircularGauge {
-    private _band;
-    private _scale;
-    private _rim;
-    private _valueRim;
-    private _marker;
-    private _hand;
-    private _pin;
-    protected _doInit(proxy: CircleGauge): void;
-    get band(): RcGaugeRangeBand;
-    get scale(): RcChartObject;
-    get rim(): RcChartObject;
-    get valueRim(): RcChartObject;
-    get marker(): RcChartObject;
-    get hand(): RcChartObject;
-    get pin(): RcChartObject;
-}
-declare abstract class RcLinearGaugeBase extends RcValueGauge {
-    private _label;
-    private _scale;
-    protected _doInit(proxy: ChartItem): void;
-    get label(): RcChartObject;
-    get scale(): RcChartObject;
-}
-declare class RcLinearGauge extends RcLinearGaugeBase {
-    private _marker;
-    private _band;
-}
-declare class RcBulletGauge extends RcLinearGaugeBase {
+declare class RcChartGauge extends RcNamedObject {
+    setValue(value: any, animate?: boolean): void;
 }
-declare class RcClockGauge extends RcChartGauge {
+declare abstract class RcGaugeGroup extends RcNamedObject {
 }
-declare abstract class RcGaugeGroup extends RcChartGaugeBase {
+declare class RcAnnotation extends RcNamedObject {
+    update(): void;
 }
 declare class RcTitle extends RcChartObject {
 }
@@ -2174,20 +2058,12 @@ declare class RcLegend extends RcChartObject {
 }
 declare class RcBody extends RcChartObject {
 }
-declare class RcAnnotation extends RcNamedObject {
-    update(): void;
-}
-declare class RcTextAnnotation extends RcAnnotation {
-}
-declare class RcImageAnnotation extends RcAnnotation {
-}
-declare class RcShapeAnnotation extends RcAnnotation {
-}
 
 declare class RcChartControl {
     private $_p;
     private _objects;
     private _proxy;
+    private _exporter;
     private constructor();
     load(config: any, animate?: boolean): void;
     render(now?: boolean): void;
@@ -2209,16 +2085,51 @@ declare class RcChartControl {
     get inverted(): boolean;
     get polar(): boolean;
     scroll(axis: RcChartAxis, pos: number): void;
-    exportImage(options?: ImageExportOptions): void;
     setParam(param: string, value: any, redraw?: boolean): void;
+    addSeries(source: any, animate?: boolean): RcChartSeries | undefined;
+    removeSeries(series: string | RcChartSeries, animate?: boolean): RcChartSeries | undefined;
+}
+
+declare class RcChartData {
+    private $_p;
+    private constructor();
+    get rowCount(): number;
+    getValue(row: number, field: string): any;
+    setValue(row: number, field: string, value: any): void;
+    getValues(field: string, fromRow?: number, toRow?: number): any[];
+    getRow(row: number): any;
+    addRow(values: any, row?: number): void;
+    deleteRow(row?: number): void;
+}
+
+interface IRcLocale {
+    dateFormat: string;
+    am: string;
+    pm: string;
+    notExistsDataField: string;
+    notSpecifiedDataField: string;
+    invalidFieldName: string;
+    invalidRowIndex: string;
+    invalidToIndex: string;
+    requireSourceData: string;
+    requireFilterName: string;
+    invalidDateFormat: string;
+    invalidSizeValue: string;
+    invalidOuterDiv: string;
+    dataMustSet: string;
+    requireTableName: string;
+    alreadyTableExists: string;
 }
 
 declare class Globals {
     static getVersion(): string;
+    static setLocale(lang: string, config?: IRcLocale): void;
+    static registerLocale(lang: string, config: IRcLocale): void;
     static setDebugging(debug: boolean): void;
     static setLogging(logging: boolean): void;
     static setAnimatable(value: boolean): void;
     static createChart(doc: Document, container: string | HTMLDivElement, config: any, animate?: boolean): RcChartControl;
+    static createData(options?: IRcChartDataOptions, rows?: any[]): RcChartData;
 }
 
 declare const getVersion: typeof Globals.getVersion;
@@ -2226,5 +2137,6 @@ declare const setDebugging: typeof Globals.setDebugging;
 declare const setLogging: typeof Globals.setLogging;
 declare const setAnimatable: typeof Globals.setAnimatable;
 declare const createChart: typeof Globals.createChart;
+declare const createData: typeof Globals.createData;
 
-export { RcBody, RcBulletGauge, RcChartAxis, RcChartControl, RcChartGauge, RcChartGaugeBase, RcChartObject, RcChartSeries, RcCircleGauge, RcCircularGauge, RcClockGauge, RcGaugeGroup, RcGaugeRangeBand, RcGaugeScale, RcImageAnnotation, RcLegend, RcLinearGauge, RcLinearGaugeBase as RcLinerGaugeBase, RcPointLabel, RcSeriesGroup, RcShapeAnnotation, RcSubtitle, RcTextAnnotation, RcTitle, RcValueGauge, createChart, getVersion, setAnimatable, setDebugging, setLogging };
+export { RcAnnotation, RcBody, RcChartAxis, RcChartControl, RcChartData, RcChartGauge, RcChartObject, RcChartSeries, RcGaugeGroup, RcLegend, RcNamedObject, RcSeriesGroup, RcSubtitle, RcTitle, createChart, createData, getVersion, setAnimatable, setDebugging, setLogging };