realchart 0.9.7 → 0.9.9

package/dist/index.d.ts

@@ -1,35 +1,3 @@
-declare abstract class RcObject {
-    static destroy(obj: RcObject): null;
-    private $_hash;
-    private $_destroyed;
-    private $_destroying;
-    constructor(noHash?: boolean);
-    destroy(): null;
-    protected _doDestory(): void;
-    get destroying(): boolean;
-    get hash(): string;
-    isMe(hash: string): boolean;
-    toString(): string;
-    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;
-}
-
 type Path = string | any[];
 type RtPercentSize = string | number;
 interface SVGStyles {
@@ -42,6 +10,10 @@ interface SVGStyles {
     fontStyle?: string;
 }
 type SVGStyleOrClass = SVGStyles | string;
+interface IMinMax {
+    min: number;
+    max: number;
+}
 declare enum Align {
     LEFT = "left",
     CENTER = "center",
@@ -58,9 +30,37 @@ declare enum SectionDir {
     BOTTOM = "bottom",
     RIGHT = "right"
 }
-declare enum AlignBase {
-    CHART = "chart",
-    PLOT = "plot"
+interface IValueRange {
+    fromValue?: number;
+    toValue?: number;
+    color: string;
+    label?: string;
+}
+
+declare abstract class RcObject {
+    static destroy(obj: RcObject): null;
+    private $_hash;
+    private $_destroyed;
+    private $_destroying;
+    constructor(noHash?: boolean);
+    destroy(): null;
+    protected _doDestory(): void;
+    get destroying(): boolean;
+    get hash(): string;
+    isMe(hash: string): boolean;
+    toString(): string;
+    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;
 }
 
 interface ISize {
@@ -114,6 +114,7 @@ declare abstract class RcControl extends RcWrappableObject {
     isTesting(): boolean;
     doc(): Document;
     dom(): HTMLElement;
+    svg(): SVGSVGElement;
     width(): number;
     height(): number;
     setData(data: string, value: any, container?: boolean): void;
@@ -229,7 +230,9 @@ declare class RcElement extends RcObject {
     insertElement(doc: Document, tag: string, before: Node): SVGElement;
     getAttr(attr: string): any;
     setAttr(attr: string, value: any): RcElement;
+    setAttrEx(attr: string, value: any): RcElement;
     setAttrs(attrs: any): RcElement;
+    setAttrsEx(attrs: any): RcElement;
     unsetAttr(attr: string): RcElement;
     setBounds(x: number, y: number, width: number, height: number): RcElement;
     setRect(rect: IRect): RcElement;
@@ -277,15 +280,14 @@ declare class RcElement extends RcObject {
     setClip(cr?: ClipElement | ClipPathElement | string): void;
     setTemporary(): RcElement;
     setCursor(cursor: string): void;
+    ignorePointer(): void;
+    contains(dom: Element): boolean;
     protected _testing(): boolean;
     protected _doAttached(parent: RcElement): void;
     protected _doDetached(parent: RcElement): void;
     protected _updateTransform(): void;
     getTransform(): string;
 }
-declare class LayerElement extends RcElement {
-    constructor(doc: Document, styleName: string);
-}
 declare class ClipElement extends RcElement {
     private _id;
     private _rect;
@@ -309,28 +311,6 @@ declare class ClipPathElement extends RcElement {
     setPath(path: Path): void;
 }
 
-interface IAssetItem {
-    id: string;
-}
-declare abstract class AssetItem<T extends IAssetItem> {
-    source: T;
-    constructor(source: T);
-    abstract getEelement(doc: Document): Element;
-}
-interface IAssetOwner {
-    addDef(element: Element): void;
-    removeDef(element: string): void;
-}
-declare class AssetCollection {
-    private _items;
-    get count(): number;
-    get(index: number): AssetItem<IAssetItem>;
-    load(source: any): void;
-    register(doc: Document, owner: IAssetOwner): void;
-    unregister(doc: Document, owner: IAssetOwner): void;
-    private $_loadItem;
-}
-
 declare enum TextAnchor {
     START = "start",
     MIDDLE = "middle",
@@ -377,6 +357,7 @@ declare class TextElement extends RcElement {
     setStyle(prop: string, value: string): boolean;
     getBBounds(): IRect;
     getBBoundsTest(): IRect;
+    stain(): void;
 }
 
 type RichTextParamCallback = (target: any, param: string, format: string) => string;
@@ -415,13 +396,14 @@ declare class ChartItem extends RcObject {
     style: SVGStyleOrClass;
     load(source: any): ChartItem;
     save(): any;
-    getProp(prop: string, deep: boolean): any;
-    setProp(prop: string, value: any): void;
-    setProps(props: object): void;
+    private INVALID;
+    private $_parseProp;
+    getProp(prop: string): any;
+    setProp(prop: string, value: any, redraw: boolean): boolean;
+    setProps(props: object, redraw: boolean): boolean;
     prepareRender(): void;
-    protected _changed(): void;
+    protected _changed(tag?: any): void;
     protected _doLoadSimple(source: any): boolean;
-    protected _getDefObjProps(prop: string): any;
     protected _doLoad(source: any): void;
     protected _doLoadProp(prop: string, value: any): boolean;
     protected _doSave(target: object): void;
@@ -434,7 +416,7 @@ declare enum ChartTextEffect {
 }
 declare abstract class ChartText extends ChartItem {
     effect: ChartTextEffect;
-    brightStyle: SVGStyleOrClass;
+    lightStyle: SVGStyleOrClass;
     darkStyle: SVGStyleOrClass;
     backgroundStyle: SVGStyleOrClass;
     autoContrast: boolean;
@@ -463,33 +445,6 @@ declare abstract class FormattableText extends ChartText {
     private $_getNumberText;
     protected _getText(text: string, value: any, useSymbols: boolean, forceSymbols?: boolean): string;
 }
-declare class BackgroundImage extends ChartItem {
-    url: string;
-    style: SVGStyleOrClass;
-}
-
-declare enum CrosshairType {
-    AUTO = "auto",
-    LINE = "line"
-}
-declare class CrosshairFlag extends ChartItem {
-    prefix: string;
-    suffix: string;
-    format: string;
-    textStyles: SVGStyleOrClass;
-    minWidth: number;
-}
-declare class Crosshair extends ChartItem {
-    axis: IAxis;
-    readonly flag: CrosshairFlag;
-    constructor(axis: IAxis);
-    type: CrosshairType;
-    showAlways: boolean;
-    followPointer: boolean;
-    numberFormat: string;
-    isBar(): boolean;
-    getFlag(length: number, pos: number): string;
-}
 
 declare enum Shape {
     CIRCLE = "circle",
@@ -560,7 +515,7 @@ declare class DataPointCollection {
     getProps(prop: string | number): any[];
     getValues(axis: string): any[];
     forEach(callback: (p: DataPoint, i?: number) => any): void;
-    getPoints(): DataPoint[];
+    getPoints(xAxis: IAxis, yAxis: IAxis): DataPoint[];
 }
 
 declare abstract class Widget extends ChartItem {
@@ -574,64 +529,6 @@ interface ILegendSource {
     legendColor(): string;
     legendLabel(): string;
 }
-declare class LegendItem extends ChartItem {
-    legend: Legend;
-    source: ILegendSource;
-    static readonly MARKER_SIZE = 10;
-    constructor(legend: Legend, source: ILegendSource);
-    text(): string;
-}
-declare enum LegendLocation {
-    BOTTOM = "bottom",
-    TOP = "top",
-    RIGHT = "right",
-    LEFT = "left",
-    PLOT = "plot",
-    SUBPLOT = "subplot"
-}
-declare enum LegendLayout {
-    AUTO = "auto",
-    HORIZONTAL = "horizontal",
-    VERTICAL = "vertical"
-}
-declare enum LegendItemsAlign {
-    START = "start",
-    CENTER = "center",
-    END = "end"
-}
-declare class Legend extends Widget {
-    private _items;
-    private _maxWidthDim;
-    private _maxHeightDim;
-    private _location;
-    constructor(chart: IChart);
-    location: LegendLocation;
-    layout: LegendLayout;
-    alignBase: AlignBase;
-    gap: number;
-    itemGap: number;
-    markerGap: number;
-    backgroundStyles: SVGStyleOrClass;
-    itemsPerLine: number;
-    lineGap: number;
-    maxWidth: RtPercentSize;
-    maxHeight: RtPercentSize;
-    align: Align;
-    verticalAlign: VerticalAlign;
-    offsetX: number;
-    offsetY: number;
-    itemsAlign: LegendItemsAlign;
-    items(): LegendItem[];
-    isEmpty(): boolean;
-    isVisible(): boolean;
-    getLocatiion(): LegendLocation;
-    getLayout(): LegendLayout;
-    getMaxWidth(domain: number): number;
-    getMaxHeight(domain: number): number;
-    protected _doLoad(src: any): void;
-    protected _doPrepareRender(chart: IChart): void;
-    private $_collectItems;
-}
 
 declare class Tooltip extends ChartItem {
     series: ISeries;
@@ -695,7 +592,7 @@ declare enum TrendType {
     EXPONENTIAL = "exponential",
     MOVING_AVERAGE = "movingAverage"
 }
-declare class MovingAverage {
+declare class MovingAverage extends RcObject {
     interval: number;
     type: 'simple' | 'weighted' | 'exponential' | 'triangualr';
 }
@@ -710,10 +607,6 @@ declare class Trendline extends ChartItem {
     lineType: LineType;
     movingAverage: MovingAverage;
     protected _doPrepareRender(chart: IChart): void;
-    protected _getDefObjProps(prop: string): {
-        interval: number;
-        type: string;
-    };
     $_linear(pts: DataPoint[], list: {
         x: number;
         y: number;
@@ -772,11 +665,6 @@ type PointClickCallbck = (args: IDataPointCallbackArgs) => boolean;
 declare abstract class Series extends ChartItem implements ISeries, ILegendSource {
     static readonly LEGEND_MARKER = "rct-legend-item-marker";
     static _loadSeries(chart: IChart, src: any, defType?: string): Series;
-    readonly name: string;
-    readonly label: string;
-    readonly pointLabel: DataPointLabel;
-    readonly trendline: Trendline;
-    readonly tooltip: Tooltip;
     index: number;
     group: SeriesGroup<Series>;
     _xAxisObj: IAxis;
@@ -787,10 +675,16 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     _maxValue: number;
     _referents: Series[];
     _calcedColor: string;
+    _simpleMode: boolean;
     private _legendMarker;
     protected _pointArgs: IDataPointCallbackArgs;
     constructor(chart: IChart, name?: string);
     abstract _type(): string;
+    readonly name: string;
+    readonly label: string;
+    readonly pointLabel: DataPointLabel;
+    readonly trendline: Trendline;
+    readonly tooltip: Tooltip;
     zOrder: number;
     xAxis: string | number;
     yAxis: string | number;
@@ -804,6 +698,7 @@ declare abstract class Series extends ChartItem implements ISeries, ILegendSourc
     pointColors: boolean | string[];
     clipped: boolean;
     displayInLegend: boolean;
+    displayInNavigator: boolean;
     pointStyleCallback: PointStyleCallback;
     onPointClick: PointClickCallbck;
     contains(p: DataPoint): boolean;
@@ -940,65 +835,376 @@ declare abstract class SeriesGroup<T extends Series> extends ChartItem implement
     private $_collectFill;
 }
 
-interface IAxis {
-    type(): string;
-    chart: IChart;
-    _length: number;
-    _isX: boolean;
-    _isHorz: boolean;
-    _isOpposite: boolean;
-    reversed: boolean;
-    isContinuous(): boolean;
-    getBaseValue(): number;
-    axisMax(): number;
-    axisMin(): number;
-    getValue(value: any): number;
-    parseValue(value: any): number;
-    contains(value: number): boolean;
-    incStep(value: number, step: any): number;
-    getPosition(length: number, value: number, point?: boolean): number;
-    getValueAt(length: number, pos: number): number;
-    getUnitLength(length: number, value: number): number;
-}
-declare abstract class AxisItem extends ChartItem {
-    readonly axis: Axis;
-    constructor(axis: Axis, visible?: boolean);
-}
-declare class AxisLine extends AxisItem {
-    constructor(axis: Axis);
+declare abstract class GaugeBase extends Widget {
+    private _size;
+    private _width;
+    private _height;
+    private _left;
+    private _right;
+    private _top;
+    private _bottom;
+    index: number;
+    private _sizeDim;
+    private _widthDim;
+    private _heightDim;
+    private _leftDim;
+    private _rightDim;
+    private _topDim;
+    private _bottomDim;
+    constructor(chart: IChart);
+    abstract _type(): string;
+    name: string;
+    get left(): RtPercentSize;
+    set left(value: RtPercentSize);
+    get right(): RtPercentSize;
+    set right(value: RtPercentSize);
+    get top(): RtPercentSize;
+    set top(value: RtPercentSize);
+    get bottom(): RtPercentSize;
+    set bottom(value: RtPercentSize);
+    get width(): RtPercentSize;
+    set width(value: RtPercentSize);
+    get height(): RtPercentSize;
+    set height(value: RtPercentSize);
+    get size(): RtPercentSize;
+    set size(value: RtPercentSize);
+    paneStyle: SVGStyleOrClass;
+    getSize(width: number, height: number): ISize;
+    getLeft(doamin: number): number;
+    getRight(doamin: number): number;
+    getTop(doamin: number): number;
+    getBottom(doamin: number): number;
 }
-declare class AxisTitle extends AxisItem {
-    text: string;
-    gap: number;
-    backgroundStyle: SVGStyleOrClass;
-    isVisible(): boolean;
-    protected _doLoadSimple(source: any): boolean;
+declare abstract class Gauge extends GaugeBase {
+    static _loadGauge(chart: IChart, src: any, defType?: string): Gauge;
+    group: GaugeGroup<ValueGauge>;
+    gindex: number;
+    duration: number;
+    setGroup(group: GaugeGroup<ValueGauge>, index: number): void;
 }
-declare class AxisGrid extends AxisItem {
-    circular: boolean;
-    startVisible: boolean;
-    endVisible: boolean;
-    constructor(axis: Axis);
-    isVisible(): boolean;
-    getPoints(length: number): number[];
+declare abstract class GaugeGroup<T extends ValueGauge> extends GaugeBase {
+    private _gauges;
+    protected _visibles: T[];
+    minValue: number;
+    maxValue: number;
+    count(): number;
+    isEmpty(): boolean;
+    visibles(): T[];
+    abstract _gaugesType(): string;
+    get(index: number): T;
+    getVisible(index: number): T;
+    calcedMinMax(): IMinMax;
+    protected _doLoadProp(prop: string, value: any): boolean;
+    prepareRender(): void;
+    protected _prepareChildren(visibles: T[]): void;
+    private $_loadGauges;
+    private $_add;
+    protected _setGroup(child: T, index: number): void;
 }
-declare class AxisGuideLabel extends FormattableText {
+declare class GaugeCollection {
+    readonly chart: IChart;
+    private _map;
+    private _items;
+    private _visibles;
+    private _gauges;
     constructor(chart: IChart);
-    align: Align;
-    verticalAlign: VerticalAlign;
-}
-declare abstract class AxisGuide extends AxisItem {
-    readonly label: AxisGuideLabel;
-    front: boolean;
-    zindex: number;
-    constructor(axis: Axis);
+    get count(): number;
+    get firstGauge(): Gauge;
+    visibles(): GaugeBase[];
+    getGauge(name: string): Gauge;
+    get(name: string | number): GaugeBase;
+    load(src: any): void;
+    prepareRender(): void;
+    private $_loadItem;
 }
-declare class AxisGuideLine extends AxisGuide {
+declare abstract class ValueGauge extends Gauge {
+    protected _runValue: number;
+    minValue: number;
+    maxValue: number;
     value: number;
+    animatable: boolean;
+    updateValue(value: any, animate: boolean): void;
+    getLabel(label: GaugeLabel, value: number): string;
+    getParam(param: string): any;
+    calcedMinMax(): IMinMax;
 }
-declare class AxisGuideRange extends AxisGuide {
-    start: number;
-    end: number;
+declare class GuageScaleTick extends ChartItem {
+    scale: GaugeScale;
+    constructor(scale: GaugeScale);
+    reversed: boolean;
+    length: number;
+}
+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;
+    tickLabel: ChartItem;
+    steps: number[];
+    stepCount: number;
+    stepInterval: number;
+    stepPixels: number;
+    get gap(): number;
+    set gap(value: number);
+    range(): IMinMax;
+    buildSteps(length: number, value: number, target?: number): number[];
+    buildGroupSteps(length: number, values: 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 {
+    constructor(chart: IChart);
+    animatable: boolean;
+}
+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);
+    maxValue: number;
+    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;
+}
+
+interface IChart {
+    type: string;
+    gaugeType: string;
+    xStart: number;
+    xStep: number;
+    first: IPlottingItem;
+    firstSeries: Series;
+    xAxis: IAxis;
+    yAxis: IAxis;
+    colors: string[];
+    assignTemplates(target: any): any;
+    isGauge(): boolean;
+    isPolar(): boolean;
+    isInverted(): boolean;
+    animatable(): boolean;
+    startAngle(): number;
+    seriesByName(series: string): Series;
+    axisByName(axis: string): Axis;
+    getAxes(dir: SectionDir): Axis[];
+    _getGroupType(type: string): any;
+    _getSeriesType(type: string): any;
+    _getAxisType(type: string): any;
+    _getGaugeType(type: string): any;
+    _getGaugeGroupType(type: string): any;
+    _getSeries(): PlottingItemCollection;
+    _getGauges(): GaugeCollection;
+    _getXAxes(): AxisCollection;
+    _getYAxes(): AxisCollection;
+    getAxesGap(): number;
+    _connectSeries(series: IPlottingItem, isX: boolean): Axis;
+    _getLegendSources(): ILegendSource[];
+    _visibleChanged(item: ChartItem): void;
+    _pointVisibleChanged(series: Series, point: DataPoint): void;
+    _modelChanged(item: ChartItem, tag?: any): void;
+}
+
+declare enum CrosshairType {
+    AUTO = "auto",
+    LINE = "line"
+}
+declare class CrosshairFlag extends ChartItem {
+    prefix: string;
+    suffix: string;
+    format: string;
+    textStyles: SVGStyleOrClass;
+    minWidth: number;
+}
+declare class Crosshair extends ChartItem {
+    axis: IAxis;
+    readonly flag: CrosshairFlag;
+    constructor(axis: IAxis);
+    type: CrosshairType;
+    showAlways: boolean;
+    followPointer: boolean;
+    numberFormat: string;
+    isBar(): boolean;
+    getFlag(length: number, pos: number): string;
+}
+
+interface IAxis {
+    type(): string;
+    chart: IChart;
+    _vlen: number;
+    _isX: boolean;
+    _isHorz: boolean;
+    _isOpposite: boolean;
+    reversed: boolean;
+    _zoom: IAxisZoom;
+    isContinuous(): boolean;
+    getBaseValue(): number;
+    axisMax(): number;
+    axisMin(): number;
+    zoom(start: number, end: number): boolean;
+    getValue(value: any): number;
+    parseValue(value: any): number;
+    contains(value: number): boolean;
+    incStep(value: number, step: any): number;
+    getPosition(length: number, value: number, point?: boolean): number;
+    getValueAt(length: number, pos: number): number;
+    getUnitLength(length: number, value: number): number;
+}
+declare abstract class AxisItem extends ChartItem {
+    readonly axis: Axis;
+    constructor(axis: Axis, visible?: boolean);
+}
+declare class AxisLine extends AxisItem {
+    constructor(axis: Axis);
+}
+declare enum AxisTitleAlign {
+    START = "start",
+    MIDDLE = "middle",
+    END = "end"
+}
+declare class AxisTitle extends AxisItem {
+    text: string;
+    align: AxisTitleAlign;
+    gap: number;
+    backgroundStyle: SVGStyleOrClass;
+    isVisible(): boolean;
+    protected _doLoadSimple(source: any): boolean;
+}
+declare class AxisGrid extends AxisItem {
+    circular: boolean;
+    startVisible: boolean;
+    endVisible: boolean;
+    constructor(axis: Axis);
+    isVisible(): boolean;
+    getPoints(length: number): number[];
+}
+declare class AxisGuideLabel extends FormattableText {
+    constructor(chart: IChart);
+    align: Align;
+    verticalAlign: VerticalAlign;
+}
+declare abstract class AxisGuide extends AxisItem {
+    constructor(axis: Axis);
+    readonly label: AxisGuideLabel;
+    front: boolean;
+    zindex: number;
 }
 declare abstract class AxisTick extends AxisItem {
     length: number;
@@ -1033,6 +1239,23 @@ declare enum AxisPosition {
     OPPOSITE = "opposite",
     BASE = "base"
 }
+declare class AxisScrollBar extends AxisItem {
+    constructor(axis: Axis);
+    thickness: number;
+}
+interface IAxisZoom {
+    start: number;
+    end: number;
+}
+declare class AxisZoom {
+    axis: Axis;
+    private _axixMin;
+    private _axixMax;
+    start: number;
+    end: number;
+    constructor(axis: Axis, start: number, end: number);
+    resize(start: number, end: number): boolean;
+}
 declare abstract class Axis extends ChartItem implements IAxis {
     readonly name: string;
     readonly title: AxisTitle;
@@ -1042,6 +1265,7 @@ declare abstract class Axis extends ChartItem implements IAxis {
     readonly grid: AxisGrid;
     readonly guides: AxisGuide[];
     readonly crosshair: Crosshair;
+    readonly scrollBar: AxisScrollBar;
     _isX: boolean;
     _isHorz: boolean;
     _isOpposite: boolean;
@@ -1052,11 +1276,14 @@ declare abstract class Axis extends ChartItem implements IAxis {
     };
     _ticks: IAxisTick[];
     _markPoints: number[];
-    _length: number;
+    _vlen: number;
     _minPad: number;
     _maxPad: number;
     _values: number[];
-    constructor(chart: IChart, name?: string);
+    protected _min: number;
+    protected _max: number;
+    _zoom: AxisZoom;
+    constructor(chart: IChart, isX: boolean, name?: string);
     abstract type(): string;
     position: AxisPosition;
     reversed: boolean;
@@ -1066,9 +1293,10 @@ declare abstract class Axis extends ChartItem implements IAxis {
     marginFar: number;
     isEmpty(): boolean;
     getBaseValue(): number;
+    length(): number;
+    axisMin(): number;
+    axisMax(): number;
     abstract isContinuous(): boolean;
-    abstract axisMin(): number;
-    abstract axisMax(): number;
     abstract getValueAt(length: number, pos: number): number;
     protected abstract _createTickModel(): AxisTick;
     protected abstract _createLabelModel(): AxisLabel;
@@ -1088,6 +1316,9 @@ declare abstract class Axis extends ChartItem implements IAxis {
     incStep(value: number, step: any): number;
     parseValue(value: any): number;
     contains(value: number): boolean;
+    resetZoom(): void;
+    zoom(start: number, end: number): boolean;
+    isZoomed(): boolean;
     protected _doLoadProp(prop: string, value: any): boolean;
     protected _createGrid(): AxisGrid;
     private $_loadGuides;
@@ -1116,703 +1347,146 @@ declare class AxisCollection {
     buildTicks(length: number): void;
     connect(series: IPlottingItem): Axis;
     forEach(callback: (p: Axis, i?: number) => any): void;
+    isZoomed(): boolean;
+    resetZoom(): void;
     private $_loadAxis;
 }
 
-declare class Body extends ChartItem {
+declare abstract class CircleGaugeRimBase extends ChartItem {
+    gauge: CircleGauge;
+    private _ranges;
+    private _runRanges;
+    constructor(gauge: CircleGauge);
+    get ranges(): IValueRange[];
+    set ranges(value: IValueRange[]);
+    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 _centerX;
-    private _centerY;
+    private _length;
+    private _offset;
     private _radiusDim;
-    private _cxDim;
-    private _cyDim;
-    _guides: AxisGuide[];
-    _frontGuides: AxisGuide[];
-    private _rd;
-    private _cx;
-    private _cy;
-    constructor(chart: IChart);
+    private _lengthDim;
+    private _offsetDim;
+    constructor(gauge: CircleGauge);
     get radius(): RtPercentSize;
     set radius(value: RtPercentSize);
-    get centerX(): RtPercentSize;
-    set centerX(value: RtPercentSize);
-    get centerY(): RtPercentSize;
-    set centerY(value: RtPercentSize);
-    startAngle: number;
-    circular: boolean;
-    image: BackgroundImage;
-    calcRadius(width: number, height: number): number;
-    setPolar(width: number, height: number): Body;
-    getStartAngle(): number;
-    getPolar(series: Series): {
-        start: number;
-        cx: number;
-        cy: number;
-        rd: number;
-        deg: number;
+    get length(): RtPercentSize;
+    set length(value: RtPercentSize);
+    get offset(): RtPercentSize;
+    set offset(value: RtPercentSize);
+    getExtents(domain: number): {
+        radius: number;
+        length: number;
+        offset: number;
     };
-    protected _doPrepareRender(chart: IChart): void;
-}
-
-declare enum PaletteMode {
-    NORMAL = "normal",
-    MIXED = "mixed",
-    RANDOM = "random"
-}
-
-declare class Title extends ChartItem {
-    text: string;
-    alignBase: AlignBase;
-    align: Align;
-    backgroundStyle: SVGStyleOrClass;
-    isVisible(): boolean;
-    protected _doLoadSimple(source: any): boolean;
-}
-declare enum SubtitlePosition {
-    BOTTOM = "bottom",
-    RIGHT = "right",
-    LEFT = "left",
-    TOP = "top"
 }
-declare class Subtitle extends Title {
-    position: SubtitlePosition;
-    verticalAlign: VerticalAlign;
-    text: string;
-}
-
-declare abstract class GaugeBase extends Widget {
-    private _size;
-    private _width;
-    private _height;
-    private _left;
-    private _right;
-    private _top;
-    private _bottom;
-    index: number;
-    private _sizeDim;
-    private _widthDim;
-    private _heightDim;
-    private _leftDim;
-    private _rightDim;
-    private _topDim;
-    private _bottomDim;
-    constructor(chart: IChart);
-    abstract _type(): string;
-    name: string;
-    get left(): RtPercentSize;
-    set left(value: RtPercentSize);
-    get right(): RtPercentSize;
-    set right(value: RtPercentSize);
-    get top(): RtPercentSize;
-    set top(value: RtPercentSize);
-    get bottom(): RtPercentSize;
-    set bottom(value: RtPercentSize);
-    get width(): RtPercentSize;
-    set width(value: RtPercentSize);
-    get height(): RtPercentSize;
-    set height(value: RtPercentSize);
-    get size(): RtPercentSize;
-    set size(value: RtPercentSize);
-    getSize(width: number, height: number): ISize;
-    getLeft(doamin: number): number;
-    getRight(doamin: number): number;
-    getTop(doamin: number): number;
-    getBottom(doamin: number): number;
-}
-declare abstract class Gauge extends GaugeBase {
-    static _loadGauge(chart: IChart, src: any, defType?: string): Gauge;
-    group: GaugeGroup<ValueGauge>;
-    gindex: number;
-    duration: number;
-    setGroup(group: GaugeGroup<ValueGauge>, index: number): void;
-}
-declare abstract class GaugeGroup<T extends ValueGauge> extends GaugeBase {
-    private _gauges;
-    protected _visibles: T[];
-    minValue: number;
-    maxValue: number;
-    count(): number;
-    isEmpty(): boolean;
-    visibles(): T[];
-    abstract _gaugesType(): string;
-    get(index: number): T;
-    getVisible(index: number): T;
-    protected _doLoadProp(prop: string, value: any): boolean;
-    prepareRender(): void;
-    protected _prepareChildren(visibles: T[]): void;
-    private $_loadGauges;
-    private $_add;
-    protected _setGroup(child: T, index: number): void;
-}
-declare class GaugeCollection {
-    readonly chart: IChart;
-    private _map;
-    private _items;
-    private _visibles;
-    private _gauges;
-    constructor(chart: IChart);
-    get count(): number;
-    get firstGauge(): Gauge;
-    visibles(): GaugeBase[];
-    getGauge(name: string): Gauge;
-    get(name: string | number): GaugeBase;
-    load(src: any): void;
-    prepareRender(): void;
-    private $_loadItem;
+declare class CircleGaugePin extends ChartItem {
+    private _radius;
+    private _radiusDim;
+    constructor(gauge: CircleGauge);
+    get radius(): RtPercentSize;
+    set radius(value: RtPercentSize);
+    getRadius(domain: number): number;
 }
-declare abstract class ValueGauge extends Gauge {
-    protected _runValue: number;
-    minValue: number;
-    maxValue: number;
-    value: number;
-    animatable: boolean;
-    updateValue(value: any): void;
-    getLabel(label: GaugeLabel, value: number): string;
-    getParam(param: string): any;
+declare class CircleGaugeScale extends GaugeScale {
+    stepPixels: number;
+    protected _getStepMultiples(step: number): number[];
 }
-declare abstract class GaugeLabel extends FormattableText {
+declare class CircleGauge extends CircularGauge {
     constructor(chart: IChart);
-    animatable: boolean;
+    band: GaugeRangeBand;
+    scale: CircleGaugeScale;
+    rim: CircleGaugeRim;
+    valueRim: CircleGaugeValueRim;
+    marker: CircleGaugeValueMarker;
+    hand: CircleGaugeHand;
+    pin: CircleGaugePin;
+    _type(): string;
+    getExtents(gaugeSize: number): ICircularGaugeExtents;
 }
 
-interface IChart {
-    type: string;
-    gaugeType: string;
-    xStart: number;
-    xStep: number;
-    first: IPlottingItem;
-    firstSeries: Series;
-    xAxis: IAxis;
-    yAxis: IAxis;
-    colors: string[];
-    assignTemplates(target: any): any;
-    isGauge(): boolean;
-    isPolar(): boolean;
-    isInverted(): boolean;
-    animatable(): boolean;
-    startAngle(): number;
-    seriesByName(series: string): Series;
-    axisByName(axis: string): Axis;
-    getAxes(dir: SectionDir): Axis[];
-    _getGroupType(type: string): any;
-    _getSeriesType(type: string): any;
-    _getAxisType(type: string): any;
-    _getGaugeType(type: string): any;
-    _getGaugeGroupType(type: string): any;
-    _getSeries(): PlottingItemCollection;
-    _getGauges(): GaugeCollection;
-    _getXAxes(): AxisCollection;
-    _getYAxes(): AxisCollection;
-    getAxesGap(): number;
-    _connectSeries(series: IPlottingItem, isX: boolean): Axis;
-    _getLegendSources(): ILegendSource[];
-    _visibleChanged(item: ChartItem): void;
-    _pointVisibleChanged(series: Series, point: DataPoint): void;
-    _modelChanged(item: ChartItem): void;
-}
-declare class Credits extends ChartItem {
-    text: string;
-    url: string;
-    floating: boolean;
-    align: Align;
-    verticalAlign: VerticalAlign;
-    offsetX: number;
-    offsetY: number;
+declare class RcChartObject {
+    $_p: ChartItem;
+    protected constructor(proxy: ChartItem);
+    protected _createObjects(...objs: string[]): void;
+    protected _doInit(proxy: ChartItem): void;
+    get(prop: string): any;
+    set(prop: string, value: any, redraw?: boolean): RcChartObject;
+    setAll(props: object, redraw?: boolean): RcChartObject;
+    toggle(prop: string, redraw?: boolean): RcChartObject;
+    protected _changed(): void;
 }
-declare class ChartOptions extends ChartItem {
-    theme: string;
-    palette: string;
-    paletteMode: PaletteMode;
-    animatable: boolean;
-    xStart: any;
-    xStep: number | string;
-    axisGap: number;
-    credits: Credits;
-}
-interface IChartEventListener {
-    onModelChanged?(chart: Chart, item: ChartItem): void;
-    onVisibleChanged?(chart: Chart, item: ChartItem): void;
-    onPointVisibleChange?(chart: Chart, series: Series, point: DataPoint): void;
-}
-declare class Chart extends RcEventProvider<IChartEventListener> implements IChart {
-    private _templates;
-    private _assets;
-    private _themes;
-    private _options;
+declare abstract class RcChartAxis extends RcChartObject {
     private _title;
-    private _subtitle;
-    private _legend;
-    private _series;
-    private _xAxes;
-    private _yAxes;
-    private _gauges;
-    private _body;
-    private _inverted;
-    private _polar;
-    private _gaugeOnly;
-    colors: string[];
-    assignTemplates: (target: any) => any;
-    constructor(source?: any);
-    startAngle(): number;
-    get xStart(): number;
-    get xStep(): number;
-    get xStepUnit(): string;
-    animatable(): boolean;
-    type: string;
-    gaugeType: string;
-    polar: boolean;
-    inverted: boolean;
-    get assets(): AssetCollection;
-    get options(): ChartOptions;
-    get title(): Title;
-    get subtitle(): Subtitle;
-    get first(): IPlottingItem;
-    get firstSeries(): Series;
-    get firstGauge(): Gauge;
-    get legend(): Legend;
-    get xAxis(): IAxis;
-    get yAxis(): IAxis;
-    get body(): Body;
-    needAxes(): boolean;
-    _getSeries(): PlottingItemCollection;
-    _getGauges(): GaugeCollection;
-    _getXAxes(): AxisCollection;
-    _getYAxes(): AxisCollection;
-    isGauge(): boolean;
-    isPolar(): boolean;
-    isWidget(): boolean;
-    isInverted(): boolean;
-    isEmpty(): boolean;
-    seriesByName(series: string): Series;
-    seriesByPoint(point: DataPoint): Series;
-    gaugeByName(gauge: string): Gauge;
-    axisByName(axis: string): Axis;
-    containsAxis(axis: Axis): boolean;
-    getAxes(dir: SectionDir): Axis[];
-    _getLegendSources(): ILegendSource[];
-    private $_assignTemplates;
-    load(source: any): void;
-    _connectSeries(series: IPlottingItem, isX: boolean): Axis;
-    prepareRender(): void;
-    layoutAxes(width: number, height: number, inverted: boolean, phase: number): void;
-    calcAxesPoints(width: number, height: number, inverted: boolean): void;
-    private $_calcAxesPoints;
-    update(): void;
-    private $_loadTemplates;
-    _getGroupType(type: string): any;
-    _getSeriesType(type: string): any;
-    _getAxisType(type: string): any;
-    _getGaugeType(type: string): any;
-    _getGaugeGroupType(type: string): any;
-    getAxesGap(): number;
-    _modelChanged(item: ChartItem): void;
-    _visibleChanged(item: ChartItem): void;
-    _pointVisibleChanged(series: Series, point: DataPoint): void;
-}
-
-declare abstract class GroupElement extends RcElement {
-    private static IGNORE_ATTRS;
-    constructor(doc: Document, styleName?: string);
-    protected _movable(): boolean;
-    setAttr(attr: string, value: any): RcElement;
-    protected _doInitChildren(doc: Document): void;
-}
-
-declare class Sides {
-    top: number;
-    bottom: number;
-    left: number;
-    right: number;
-    static readonly Empty: Readonly<Sides>;
-    static Temp: Sides;
-    static create(top: number, bottom?: number, left?: number, right?: number): Sides;
-    static createFrom(value: string): Sides;
-    constructor(top?: number, bottom?: number, left?: number, right?: number);
-    clone(): Sides;
-    applyPadding(cs: CSSStyleDeclaration): Sides;
-    applyMargin(cs: CSSStyleDeclaration): Sides;
-    shrink(r: IRect): IRect;
-    toString(): string;
-}
-
-interface IRectShape extends IRect {
-    r?: number;
-    rx?: number;
-    ry?: number;
-    rLeft?: number;
-    rTop?: number;
-    rRight?: number;
-    rBottom?: number;
-}
-declare class RectElement extends RcElement {
-    static create(doc: Document, styleName: string, x: number, y: number, width: number, height: number, r?: number): RectElement;
-    private _rect;
-    constructor(doc: Document, styleName?: string, rect?: IRectShape);
-    get rect(): IRectShape;
-    set rect(value: IRectShape);
-    resizeRect(width: number, height: number): RcElement;
-    setBounds(x: number, y: number, width: number, height: number, r?: number): RectElement;
-    setBox(x: number, y: number, width: number, height: number): void;
-    setRadius(value: number): void;
-}
-
-declare abstract class ChartElement<T extends ChartItem> extends RcElement {
-    model: T;
-    mw: number;
-    mh: number;
-    _debugRect: RectElement;
-    constructor(doc: Document, styleName?: any);
-    chart(): IChart;
-    protected _prepareStyleOrClass(model: T): void;
-    measure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
-    layout(param?: any): ChartElement<ChartItem>;
-    resizeByMeasured(): ChartElement<ChartItem>;
-    protected _getDebugRect(): IRect;
-    protected _doMeasure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
-    protected _doLayout(param: any): void;
-    protected _invalidate(): void;
-    protected _doModelChanged(): void;
-}
-declare abstract class BoundableElement<T extends ChartItem> extends ChartElement<T> {
-    private _background;
-    protected _margins: Sides;
-    protected _paddings: Sides;
-    private _borderRadius;
-    constructor(doc: Document, styleName: string, backStyle: string);
-    protected _getDebugRect(): IRect;
-    measure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
-    layout(param?: any): ChartElement<ChartItem>;
-    protected abstract _setBackgroundStyle(back: RectElement): void;
-    protected _getBackOffset(): number;
-}
-
-type Visitor<T extends RcElement> = (element: T, index?: number, count?: number) => void;
-declare class ElementPool<T extends RcElement> extends RcObject {
-    removeDelay: number;
-    private _owner;
-    private _creator;
-    private _pool;
-    private _views;
-    private _removes;
-    private _styleName;
-    constructor(owner: RcElement, creator: {
-        new (doc: Document, styleName?: string): T;
-    }, styleName?: string, removeDelay?: number);
-    protected _doDestory(): void;
-    get isEmpty(): boolean;
-    get count(): number;
-    get first(): T;
-    get last(): T;
-    get(index: number): T;
-    getAll(): T[];
-    elementOf(dom: Element): T;
-    find(matcher: (v: T) => boolean): T;
-    setRemoveDelay(v: number): ElementPool<T>;
-    removeLater(v: RcElement, duration: number): void;
-    private $_create;
-    prepare(count: number, visitor?: Visitor<T>, initor?: Visitor<T>): ElementPool<T>;
-    reprepare(viewProp: string, objs: RcObject[], objProp: string, cleaner?: Visitor<T>, initor?: Visitor<T>, visitor?: Visitor<T>): ElementPool<T>;
-    borrow(): T;
-    free(element: T, removeDelay?: number): void;
-    freeAll(elements: T[], removeDelay?: number): void;
-    forEach(visitor: (v: T, i?: number, count?: number) => void): void;
-    visit(visitor: (v: T, i: number, count: number) => boolean): boolean;
-    sort(compare: (v1: T, v2: T) => number): ElementPool<T>;
-    map(callback: (v: T) => any): any[];
-}
-
-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 abstract _doUpdate(rate: number): boolean;
-}
-
-declare class LabelElement extends GroupElement {
-    private _back;
-    _outline: TextElement;
-    _text: TextElement;
-    private _model;
-    constructor(doc: Document, styleName?: string);
-    get text(): string;
-    get anchor(): TextAnchor;
-    set anchor(value: TextAnchor);
-    setText(s: string): LabelElement;
-    setSvg(s: string): LabelElement;
-    setModel(doc: Document, model: ChartText, contrastTarget: Element): LabelElement;
-    setContrast(target: Element): LabelElement;
-    layout(): LabelElement;
-}
-
-interface IPointView {
-    point: DataPoint;
-}
-declare class PointLabelView extends LabelElement {
-    point: DataPoint;
-    constructor(doc: Document);
-}
-declare class PointLabelContainer extends LayerElement {
-    private _labels;
-    private _maps;
-    constructor(doc: Document);
-    clear(): void;
-    prepareLabel(doc: Document, view: PointLabelView, index: number, p: DataPoint, model: DataPointLabel): void;
-    prepare(doc: Document, owner: SeriesView<Series>): void;
-    get(point: DataPoint, index: number): PointLabelView;
-    removePoint(p: DataPoint, delay: number): void;
-}
-declare class PointContainer extends LayerElement {
-    inverted: boolean;
-    invert(v: boolean, height: number): boolean;
-}
-type LabelLayoutInfo = {
-    inverted: boolean;
-    reversed: boolean;
-    pointView: RcElement;
-    x: number;
-    y: number;
-    hPoint: number;
-    wPoint: number;
-    labelView: PointLabelView;
-    labelPos: PointItemPosition;
-    labelOff: number;
-};
-declare abstract class SeriesView<T extends Series> extends ChartElement<T> {
-    static readonly POINT_CLASS = "rct-point";
-    static readonly DATA_FOUCS = "focus";
-    static readonly LEGEND_MARKER = "rct-legend-item-marker";
-    protected _pointContainer: PointContainer;
-    protected _labelContainer: PointLabelContainer;
-    private _trendLineView;
-    protected _legendMarker: RcElement;
-    protected _visPoints: DataPoint[];
-    protected _inverted: boolean;
-    protected _animatable: boolean;
-    private _viewRate;
-    _animations: Animation[];
-    constructor(doc: Document, styleName: string);
-    invertable(): boolean;
-    getClipContainer(): RcElement;
-    setViewRate(rate: number): void;
-    setPosRate(rate: number): void;
-    isPointVisible(p: DataPoint): boolean;
-    protected _doViewRateChanged(rate: number): void;
-    _setChartOptions(inverted: boolean, animatable: boolean): void;
-    _animationStarted(ani: Animation): void;
-    _animationFinished(ani: Animation): void;
-    protected abstract _getPointPool(): ElementPool<RcElement>;
-    pointByDom(elt: Element): IPointView;
-    findPointView(p: DataPoint): RcElement;
-    clicked(elt: Element): void;
-    protected _doPointClicked(view: IPointView): void;
-    protected _getColor(): string;
-    prepareSeries(doc: Document, model: T): void;
-    protected _prepareStyleOrClass(model: T): void;
-    protected _doMeasure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
-    protected _doLayout(): void;
-    protected abstract _prepareSeries(doc: Document, model: T): void;
-    protected abstract _renderSeries(width: number, height: number): void;
-    protected _collectVisPoints(model: T): DataPoint[];
-    private $_setColorIndex;
-    protected _setPointStyle(v: RcElement, model: T, p: DataPoint, styles?: any[]): void;
-    protected _labelViews(): PointLabelContainer;
-    protected _getViewRate(): number;
-    protected _animating(): boolean;
-    protected _lazyPrepareLabels(): boolean;
-    protected _afterRender(): void;
-    protected _getShowAnimation(): RcAnimation;
-    protected _runShowEffect(firstTime: boolean): void;
-    private $_renderTrendline;
-    protected _layoutLabel(info: LabelLayoutInfo): void;
-}
-
-declare class AxisGridView extends ChartElement<AxisGrid> {
-    private _pts;
-    private _lines;
-    constructor(doc: Document);
-    protected _doMeasure(doc: Document, model: AxisGrid, hintWidth: number, hintHeight: number, phase: number): ISize;
-    protected _doLayout(): void;
-}
-declare abstract class AxisGuideView<T extends AxisGuide> extends RcElement {
-    model: T;
-    protected _label: TextElement;
-    constructor(doc: Document);
-    vertical(): boolean;
-    prepare(model: T): void;
-    abstract layout(width: number, height: number): void;
-}
-declare class AxisGuideLineView extends AxisGuideView<AxisGuideLine> {
     private _line;
-    constructor(doc: Document);
-    prepare(model: AxisGuideLine): void;
-    layout(width: number, height: number): void;
+    private _grid;
+    private _tick;
+    private _label;
+    private _crosshair;
+    private _scrollBar;
+    protected _doInit(proxy: Axis): void;
+    get title(): RcChartObject;
+    get line(): RcChartObject;
+    get grid(): RcChartObject;
+    get tick(): RcChartObject;
+    get label(): RcChartObject;
+    get crosshair(): RcChartObject;
+    get scrollBar(): RcChartObject;
+    get isEmpty(): boolean;
+    resetZoom(): void;
+    zoom(start: number, end: number): void;
 }
-declare class AxisGuideRangeView extends AxisGuideView<AxisGuideRange> {
-    private _box;
-    constructor(doc: Document);
-    prepare(model: AxisGuideRange): void;
-    layout(width: number, height: number): void;
-}
-declare class AxisGuideContainer extends LayerElement {
-    _linePool: AxisGuideLineView[];
-    _rangePool: AxisGuideRangeView[];
-    _views: AxisGuideView<AxisGuide>[];
-    prepare(): void;
-    addAll(doc: Document, guides: AxisGuide[]): void;
-    add(child: AxisGuideView<AxisGuide>): RcElement;
-}
-interface IPlottingOwner {
-    clipSeries(view: RcElement, x: number, y: number, w: number, h: number, invertable: boolean): void;
-    showTooltip(series: Series, point: DataPoint): void;
-    hideTooltip(): void;
-}
-declare class BodyView extends ChartElement<Body> {
-    static readonly BODY_CLASS = "rct-plot";
-    private _owner;
-    private _polar;
-    private _background;
-    private _image;
-    private _gridContainer;
-    protected _gridViews: Map<Axis, AxisGridView>;
-    private _breakViews;
-    private _seriesContainer;
-    protected _seriesViews: SeriesView<Series>[];
-    private _seriesMap;
-    private _series;
-    private _gaugeViews;
-    private _gaugeMap;
-    private _gauges;
-    _guideContainer: AxisGuideContainer;
-    _frontGuideContainer: AxisGuideContainer;
-    _axisBreakContainer: LayerElement;
-    private _feedbackContainer;
-    private _crosshairLines;
-    private _focused;
-    protected _animatable: boolean;
-    constructor(doc: Document, owner: IPlottingOwner);
-    prepareSeries(doc: Document, chart: IChart): void;
-    prepareGuideContainers(): void;
-    pointerMoved(p: IPoint, target: EventTarget): boolean;
-    private $_setFocused;
-    seriesByDom(elt: Element): SeriesView<Series>;
-    findSeries(ser: Series): SeriesView<Series>;
-    protected _doMeasure(doc: Document, model: Body, hintWidth: number, hintHeight: number, phase: number): ISize;
-    protected _doLayout(): void;
-    private $_createSeriesView;
-    private $_createGaugeView;
-    private $_prepareGrids;
-    private $_prepareSeries;
-    private $_prepareGauges;
-    private $_prepareAxisBreaks;
-    private $_preppareCrosshairs;
+declare class RcCategoryAxis extends RcChartAxis {
 }
-
-declare class TitleView extends BoundableElement<Title> {
-    static readonly TITLE_CLASS = "rct-title";
-    static readonly SUBTITLE_CLASS = "rct-subtitle";
-    private _textView;
-    constructor(doc: Document, isSub: boolean);
-    protected _setBackgroundStyle(back: RectElement): void;
-    protected _doMeasure(doc: Document, model: Title, hintWidth: number, hintHeight: number, phase: number): ISize;
-    protected _doLayout(): void;
+declare abstract class RcContinuousAxis extends RcChartAxis {
 }
-
-declare class EmptyView extends GroupElement {
+declare class RcLinearAxis extends RcContinuousAxis {
 }
-declare class CreditView extends ChartElement<Credits> {
-    private _textView;
-    constructor(doc: Document);
-    clicked(dom: Element): void;
-    protected _doMeasure(doc: Document, model: Credits, intWidth: number, hintHeight: number, phase: number): ISize;
-}
-declare class ChartView extends RcElement {
-    private _model;
-    _inverted: boolean;
-    _emptyView: EmptyView;
-    private _titleSectionView;
-    private _legendSectionView;
-    private _bodyView;
-    private _polarView;
-    private _currBody;
-    private _axisSectionViews;
-    private _creditView;
-    private _historyView;
-    private _tooltipView;
-    private _seriesClip;
-    _org: IPoint;
-    private _plotWidth;
-    private _plotHeight;
-    constructor(doc: Document);
-    titleView(): TitleView;
-    subtitleView(): TitleView;
-    bodyView(): BodyView;
-    measure(doc: Document, model: Chart, hintWidth: number, hintHeight: number, phase: number): void;
-    layout(): void;
-    showTooltip(series: Series, point: DataPoint): void;
-    hideTooltip(): void;
-    legendByDom(dom: Element): LegendItem;
-    seriesByDom(dom: Element): SeriesView<Series>;
-    findSeriesView(series: Series): SeriesView<Series>;
-    creditByDom(dom: Element): CreditView;
-    clipSeries(view: RcElement, x: number, y: number, w: number, h: number, invertable: boolean): void;
-    pointerMoved(x: number, y: number, target: EventTarget): void;
-    protected _doAttached(parent: RcElement): void;
-    private $_checkEmpty;
-    private $_prepareBody;
-    private $_prepareAxes;
-    private $_measurePlot;
-    private $_measurePolar;
+declare class RcTimeAxis extends RcContinuousAxis {
 }
-
-declare class ChartControl extends RcControl implements IChartEventListener {
-    private _model;
-    private _chartView;
-    constructor(doc: Document, container: string | HTMLDivElement);
-    onModelChanged(chart: Chart, item: ChartItem): void;
-    onVisibleChanged(chart: Chart, item: ChartItem): void;
-    onPointVisibleChanged(chart: Chart, series: Series, point: DataPoint): void;
-    get model(): Chart;
-    set model(value: Chart);
-    chartView(): ChartView;
-    load(config: any, loadAnimation?: boolean): void;
-    refresh(): void;
-    useImage(src: string): void;
-    protected _doRender(bounds: IRect): void;
-    protected _doRenderBackground(elt: HTMLDivElement, width: number, height: number): void;
+declare class RcLogAxis extends RcContinuousAxis {
 }
-
-declare abstract class RcChartObject {
-    $_p: ChartItem;
-    constructor(proxy: ChartItem);
-    get visible(): boolean;
-    set visible(value: boolean);
-    getProp(prop: string, deep?: boolean): any;
-    setProp(prop: string, value: any): void;
-    setProps(props: object): void;
-    protected _changed(): void;
+declare class RcPointLabel extends RcChartAxis {
 }
 declare abstract class RcChartSeries extends RcChartObject {
-    constructor(proxy: Series);
-    get type(): string;
-    get name(): string;
+    private _pointLabel;
+    private _trendLine;
+    private _tooltip;
+    protected _doInit(proxy: ChartItem): void;
+    get pointLabel(): RcChartObject;
+    get trendLine(): RcChartObject;
+    get tooltip(): RcChartObject;
 }
 declare abstract class RcSeriesGroup extends RcChartObject {
 }
-declare class RcLineSeries extends RcChartSeries {
+declare abstract class RcLineSeriesBase extends RcChartSeries {
+}
+declare class RcLineSeries extends RcLineSeriesBase {
 }
 declare class RcAreaSeries extends RcChartSeries {
 }
@@ -1864,22 +1538,67 @@ declare class RcPieSeriesGroup extends RcSeriesGroup {
 }
 declare class RcBumpSeriesGroup extends RcSeriesGroup {
 }
-declare abstract class RcChartGauge extends RcChartObject {
+declare abstract class RcChartGaugeBase extends RcChartObject {
 }
-declare abstract class RcValueGauge extends RcChartGauge {
-    updateValue(value: any): void;
-}
-declare class RcCircleGauge extends RcValueGauge {
+declare abstract class RcChartGauge extends RcChartGaugeBase {
 }
-declare class RcLinearGauge extends RcValueGauge {
+declare abstract class RcValueGauge extends RcChartGauge {
+    updateValue(value: any, animate?: boolean): void;
 }
-declare class RcBulletGauge extends RcValueGauge {
+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 RcClockGauge extends RcChartGauge {
-    get active(): boolean;
-    set active(value: boolean);
 }
-declare abstract class RcGaugeGroup extends RcChartObject {
+declare abstract class RcGaugeGroup extends RcChartGaugeBase {
 }
 declare class RcCircleGaugeGroup extends RcGaugeGroup {
 }
@@ -1887,17 +1606,39 @@ declare class RcLinearGaugeGroup extends RcGaugeGroup {
 }
 declare class RcBulletGaugeGroup extends RcGaugeGroup {
 }
+declare class RcTitle extends RcChartObject {
+}
+declare class RcSubtitle extends RcChartObject {
+}
+declare class RcLegend extends RcChartObject {
+}
+declare class RcBody extends RcChartObject {
+}
 
 declare class RcChartControl {
     private $_p;
     private _objects;
-    constructor(control: ChartControl);
+    private constructor();
     load(config: any, animate?: boolean): void;
-    refresh(): void;
+    render(now?: boolean): void;
+    get xAxis(): RcChartAxis;
+    getXAxis(name: string | number): RcChartAxis;
+    get yAxis(): RcChartAxis;
+    getYAxis(name: string | number): RcChartAxis;
     get series(): RcChartSeries;
     getSeries(name: string): RcChartSeries;
     get gauge(): RcChartGauge;
     getGauge(name: string): RcChartGauge;
+    get title(): RcTitle;
+    get subtitle(): RcSubtitle;
+    get legend(): RcLegend;
+    get body(): RcBody;
+    get type(): string;
+    get gaugeType(): string;
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    get polar(): boolean;
+    scroll(axis: RcChartAxis, pos: number): void;
 }
 
 declare class Globals {
@@ -1912,4 +1653,4 @@ declare const setDebugging: typeof Globals.setDebugging;
 declare const setAnimatable: typeof Globals.setAnimatable;
 declare const createChart: typeof Globals.createChart;
 
-export { RcAreaRangeSeries, RcAreaSeries, RcAreaSeriesGroup, RcBarRangeSeries, RcBarSeries, RcBarSeriesGroup, RcBellCurveSeries, RcBoxPlotSeries, RcBubbleSeries, RcBulletGauge, RcBulletGaugeGroup, RcBumpSeriesGroup, RcCandlestickSeries, RcChartControl, RcChartGauge, RcChartObject, RcChartSeries, RcCircleGauge, RcCircleGaugeGroup, RcClockGauge, RcDumbbellSeries, RcEqualizerSeries, RcFunnelSeries, RcGaugeGroup, RcHeatmapSeries, RcHistogramSeries, RcLineSeries, RcLineSeriesGroup, RcLinearGauge, RcLinearGaugeGroup, RcLollipopSeries, RcParetoSeries, RcPieSeries, RcPieSeriesGroup, RcScatterSeries, RcSeriesGroup, RcTreemapSeries, RcValueGauge, RcVectorSeries, RcWaterfallSeries, createChart, getVersion, setAnimatable, setDebugging };
+export { RcAreaRangeSeries, RcAreaSeries, RcAreaSeriesGroup, RcBarRangeSeries, RcBarSeries, RcBarSeriesGroup, RcBellCurveSeries, RcBody, RcBoxPlotSeries, RcBubbleSeries, RcBulletGauge, RcBulletGaugeGroup, RcBumpSeriesGroup, RcCandlestickSeries, RcCategoryAxis, RcChartAxis, RcChartControl, RcChartGauge, RcChartGaugeBase, RcChartObject, RcChartSeries, RcCircleGauge, RcCircleGaugeGroup, RcCircularGauge, RcClockGauge, RcContinuousAxis, RcDumbbellSeries, RcEqualizerSeries, RcFunnelSeries, RcGaugeGroup, RcGaugeRangeBand, RcGaugeScale, RcHeatmapSeries, RcHistogramSeries, RcLegend, RcLineSeries, RcLineSeriesGroup, RcLinearAxis, RcLinearGauge, RcLinearGaugeGroup, RcLinearGaugeBase as RcLinerGaugeBase, RcLogAxis, RcLollipopSeries, RcParetoSeries, RcPieSeries, RcPieSeriesGroup, RcPointLabel, RcScatterSeries, RcSeriesGroup, RcSubtitle, RcTimeAxis, RcTitle, RcTreemapSeries, RcValueGauge, RcVectorSeries, RcWaterfallSeries, createChart, getVersion, setAnimatable, setDebugging };