realmap 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4603 @@
+declare const PI_2: number;
+declare const ORG_ANGLE: number;
+declare const RAD_DEG: number;
+type Path = string | any[];
+declare function fixnum(value: number): number;
+declare function pixel(v: number): string;
+type PercentSize = string | number;
+interface IPercentSize {
+    size: number;
+    fixed: boolean;
+}
+declare function parsePercentSize(sv: PercentSize, enableNull: boolean): IPercentSize;
+declare function calcPercent(size: IPercentSize, domain: number, def?: number): number;
+interface SVGStyles {
+    transform?: string;
+    fill?: string;
+    fillOpacity?: string;
+    stroke?: string;
+    strokeWidth?: string;
+    strokeDasharray?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    rx?: string;
+    textAlign?: Align;
+    padding?: string;
+}
+type SVGStyleOrClass = SVGStyles | string;
+interface ISides {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    horz?: number;
+    vert?: number;
+}
+declare enum RtDirection {
+    UP = "up",
+    DOWN = "down",
+    LEFT = "left",
+    RIGHT = "right"
+}
+declare const _Align: {
+    readonly LEFT: "left";
+    readonly CENTER: "center";
+    readonly RIGHT: "right";
+};
+type Align = typeof _Align[keyof typeof _Align];
+declare const _VerticalAlign: {
+    readonly TOP: "top";
+    readonly MIDDLE: "middle";
+    readonly BOTTOM: "bottom";
+};
+type VerticalAlign = typeof _VerticalAlign[keyof typeof _VerticalAlign];
+declare const _AlignBase: {
+    readonly CHART: "chart";
+    readonly MAP: "map";
+    readonly PARENT: "parent";
+};
+type AlignBase = typeof _AlignBase[keyof typeof _AlignBase];
+declare const _WritingMode: {
+    readonly HORIZONTAL_TB: "horizontal-tb";
+    readonly VERTICAL_LR: "vertical-lr";
+    readonly VERTICAL_RL: "vertical-rl";
+};
+type WritingMode = typeof _WritingMode[keyof typeof _WritingMode];
+declare const _TextOrientation: {
+    readonly MIXED: "mixed";
+    readonly UPRIGHT: "upright";
+};
+type TextOrientation = typeof _TextOrientation[keyof typeof _TextOrientation];
+interface ColorRange {
+    minValue?: number;
+    maxValue?: number;
+    minColor?: string;
+    maxColor?: string;
+    logBase?: number;
+}
+interface IPaddings {
+    l: number;
+    r: number;
+    t: number;
+    b: number;
+}
+interface ConfigObject {
+    [key: string]: any;
+}
+type MapCoord = [number, number];
+type MapPolygon = MapCoord[][];
+type MapProps = any;
+
+declare abstract class RmObject {
+    private $_hash;
+    private $_destroyed;
+    private $_destroying;
+    constructor(noHash?: boolean);
+    destroy(): null;
+    protected _doDestory(): void;
+    get destroying(): boolean;
+    get orphaned(): boolean;
+    get hash(): string;
+    isMe(hash: string): boolean;
+    toString(): string;
+    toBool(v: any): boolean;
+    toNum(v: any, def?: number): number;
+}
+declare abstract class RmEventProvider<T> extends RmObject {
+    private _listeners;
+    _addListener(listener: T): void;
+    _removeListener(listener: T): void;
+    protected _fireEvent(event: string, ...args: any[]): any;
+}
+
+interface MapInsetDisplay {
+    scale?: number;
+    coord?: MapCoord;
+    offset?: MapCoord;
+    border?: MapCoord[] | string;
+    frame?: string;
+    style?: SVGStyleOrClass;
+}
+interface MapInset extends MapInsetDisplay {
+    area: string;
+    children?: string[];
+    parent?: string;
+    polygons?: number[] | number[][] | number;
+}
+type MapSourceMeta = {
+    license?: {
+        license?: string;
+        author?: string;
+        url?: string;
+        etc?: "차트 최적화를 위해 좌표계 변환 및 Feature Polygon 수정";
+    };
+    dokdo?: {
+        group?: string;
+        parent?: number;
+        index?: number;
+    };
+    dummies?: string[];
+};
+interface MapSource {
+    name?: string;
+    enabled?: boolean;
+    map?: any;
+    source: any;
+    url?: string;
+    idKey?: string;
+    nameKey?: string;
+    exclude?: string[];
+    insets?: MapInset[];
+    padding?: string;
+    dokdo?: number | MapCoord;
+    showDummies?: boolean;
+}
+declare abstract class MapSourceItem {
+    id: string;
+    props: MapProps;
+    constructor(id: string, props: MapProps);
+}
+declare class AreaItem extends MapSourceItem {
+    polygon: MapPolygon;
+    polygons: MapPolygon[];
+    dummy: boolean;
+}
+declare abstract class MapSourceImpl extends RmObject {
+    static createStockInset(area: string, display?: MapInsetDisplay): MapInset;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly idKey: string;
+    readonly nameKey: string;
+    readonly meta: MapSourceMeta;
+    readonly dokdo: number;
+    readonly dummies: string[];
+    items: MapSourceItem[];
+    insets: {
+        [area: string]: MapInset;
+    };
+    paddings: IPaddings;
+    private _excludes;
+    constructor(src: MapSource);
+    included(area: string): boolean;
+    private $_load;
+    protected abstract _doLoad(source: object): MapSourceItem[];
+}
+
+interface IPoint {
+    x: number;
+    y: number;
+}
+
+interface ISize {
+    width: number;
+    height: number;
+}
+declare class Size {
+    width: number;
+    height: number;
+    static readonly EMPTY: Size;
+    static empty(): Size;
+    static create(w?: number, h?: number): Size;
+    constructor(width?: number, height?: number);
+    get isEmpty(): boolean;
+    clone(): Size;
+    equals(sz: Size): boolean;
+    setEmpty(): Size;
+    set(width: number, height: number): Size;
+    round(): Size;
+    toString(): string;
+}
+
+interface ChartItemOptions {
+    visible?: boolean;
+    style?: SVGStyleOrClass;
+}
+declare const ChartTextEffects: {
+    readonly NONE: "none";
+    readonly OUTLINE: "outline";
+    readonly BACKGROUND: "background";
+};
+type ChartTextEffect = typeof ChartTextEffects[keyof typeof ChartTextEffects];
+interface ChartTextOptions extends ChartItemOptions {
+    effect?: ChartTextEffect;
+    lightStyle?: SVGStyleOrClass;
+    darkStyle?: SVGStyleOrClass;
+    backgroundStyle?: SVGStyleOrClass;
+    autoContrast?: boolean;
+    outlineThickness?: number;
+    prefix?: string;
+    suffix?: string;
+    numberSymbols?: string;
+    numberFormat?: string;
+    text?: string;
+    lineHeight?: number;
+}
+declare const IconPostions: {
+    readonly DEFAULT: "default";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+};
+type IconPosition = typeof IconPostions[keyof typeof IconPostions];
+interface IconedTextOptions extends ChartTextOptions {
+    iconPosition?: IconPosition;
+    imageList?: string;
+    iconRoot?: string;
+    iconGap?: number;
+    width?: number;
+    height?: number;
+}
+interface DataPointCallbackArgs {
+    series: object;
+    count: number;
+    vcount: number;
+    yMin: number;
+    yMax: number;
+    xMin: number;
+    xMax: number;
+    zMin: number;
+    zMax: number;
+    index: number;
+    vindex: number;
+    x: any;
+    y: any;
+    z: any;
+    xValue: any;
+    yValue: any;
+    zValue: any;
+    labelIndex: number;
+    source: any;
+}
+interface AnimationOptions {
+    duration: number;
+    end: () => void;
+}
+
+declare const _AnnotationScope: {
+    readonly CHART: "chart";
+    readonly CONTAINER: "container";
+};
+type AnnotationScope = typeof _AnnotationScope[keyof typeof _AnnotationScope];
+interface AnnotationAnimationOptions {
+    type: string;
+    duration?: number;
+}
+type AnnotationType = 'image' | 'shape' | 'text';
+interface AnnotationOptions extends ChartItemOptions {
+    type?: AnnotationType;
+    front?: boolean;
+    name?: string;
+    anchor?: string;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number | string;
+    offsetY?: number | string;
+    rotation?: number;
+    scope?: AnnotationScope;
+    backgroundStyle?: SVGStyleOrClass;
+    noClip?: boolean;
+    x1?: number | Date;
+    x2?: number | Date;
+    y1?: number | Date;
+    y2?: number | Date;
+    width?: PercentSize;
+    height?: PercentSize;
+}
+declare const ImageAnnotationType = "image";
+interface ImageAnnotationOptions extends AnnotationOptions {
+    type?: typeof ImageAnnotationType;
+    visible?: boolean;
+    imageUrl?: string;
+}
+declare const ShapeAnnotationType = "shape";
+interface ShapeAnnotationOptions extends AnnotationOptions {
+    type?: typeof ShapeAnnotationType;
+    width?: number;
+    height?: number;
+    shape?: 'circle' | 'diamond' | 'square' | 'triangle' | 'star' | 'itriangle' | 'rectangle';
+    path?: string;
+    series?: string;
+    xRange?: number[];
+    yRange?: number[];
+}
+declare const TextAnnotationType = "text";
+interface TextAnnotationOptions extends AnnotationOptions {
+    type?: typeof TextAnnotationType;
+    visible?: boolean;
+    text?: string;
+    numberFormat?: string;
+    timeFormat?: string;
+    writingMode?: WritingMode;
+    textOrientation?: TextOrientation;
+}
+type AnnotationOptionsType = ImageAnnotationOptions | ShapeAnnotationOptions | TextAnnotationOptions;
+
+declare class Color {
+    private static readonly COLORS;
+    static create(color?: string): Color | undefined;
+    static isBright(color: string): boolean;
+    static getContrast(color: string, darkColor?: string, brightColor?: string): string;
+    static interpolate(color1: Color, color2: Color, rate: number): Color;
+    private r;
+    private g;
+    private b;
+    private a;
+    constructor(color?: string);
+    get rgba(): string;
+    isBright(): boolean;
+    getContrast(darkColor: string, brightColor: string): string;
+    brighten(rate: number, color?: Color): Color;
+    toString(): string;
+    private $_parseRgb;
+    private $_parseNumber;
+}
+
+declare class DatetimeFormatter {
+    private static readonly Formatters;
+    static getFormatter(format: string): DatetimeFormatter;
+    static get Default(): DatetimeFormatter;
+    private _format;
+    private _baseYear;
+    private _preserveTime;
+    private _tokens;
+    private _hasAmPm;
+    private _formatString;
+    constructor(format: string);
+    get format(): string;
+    get formatString(): string;
+    set formatString(value: string);
+    toStr(date: Date, startOfWeek: number): string;
+    private parseDateFormatTokens;
+    private parse;
+}
+
+declare class NumberFormatter {
+    static readonly DEFAULT_FORMAT = "";
+    private static readonly Formatters;
+    static getFormatter(format: string): NumberFormatter;
+    static get Default(): NumberFormatter;
+    private _format;
+    private _options;
+    constructor(format: string);
+    get format(): string;
+    toStr(value: number | bigint): string;
+    toStrEx(value: number | bigint, roundingMode: 'trunc' | 'ceil'): string;
+    private $_parse;
+}
+
+interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare const createRect: (x: number, y: number, width: number, height: number) => IRect;
+declare function rectToSize(r: IRect): ISize;
+declare function isEmptyRect(r: IRect): boolean;
+
+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;
+}
+
+declare class TextFormatter {
+    private static readonly Formatters;
+    static getFormatter(format: string): TextFormatter;
+    private _format;
+    private _pattern;
+    private _replace;
+    constructor(format: string);
+    get format(): string;
+    toStr(text: string): string;
+    $_parse(fmt: string): void;
+}
+
+interface ExporterOptions extends ChartItemOptions {
+    visible?: boolean;
+    fileName?: string;
+    useLibrary?: boolean;
+    menus?: ExportType[];
+    width?: number;
+    scale?: number;
+    url?: string;
+    hideScrollbar?: boolean;
+    hideNavigator?: boolean;
+    hideZoomButton?: boolean;
+}
+
+declare const _ExportType: {
+    readonly PNG: "png";
+    readonly JPEG: "jpeg";
+    readonly SVG: "svg";
+    readonly PDF: "pdf";
+    readonly PRINT: "print";
+};
+type ExportType = typeof _ExportType[keyof typeof _ExportType];
+interface ExportOptions {
+    type?: ExportType;
+    fileName?: string;
+}
+interface ChartExporter {
+    exportToImage: (dom: HTMLElement, options: ExportOptions, config: ExporterOptions) => void;
+    exportToPrint: (dom: HTMLElement, options: ExportOptions) => void;
+    isContextMenuVisible: () => boolean;
+    toggleContextMenu: () => void;
+}
+
+declare const _Shapes: {
+    readonly CIRCLE: "circle";
+    readonly DIAMOND: "diamond";
+    readonly SQUARE: "square";
+    readonly TRIANGLE: "triangle";
+    readonly STAR: "star";
+    readonly ITRIANGLE: "itriangle";
+    readonly RECTANGLE: "rectangle";
+};
+type Shape = typeof _Shapes[keyof typeof _Shapes];
+
+type AssetTypes = 'colors' | 'images' | 'lineargradient' | 'radialgradient';
+interface AssetItemOptions {
+    type?: AssetTypes;
+    id: string;
+}
+interface GradientOptions extends AssetItemOptions {
+    color: string[] | string;
+    opacity?: number[] | number;
+}
+interface LinearGradientOptions extends GradientOptions {
+    dir?: 'down' | 'up' | 'right' | 'left';
+}
+interface RadialGradientOptions extends GradientOptions {
+    cx?: number | string;
+    cy?: number | string;
+    r?: number | string;
+}
+interface PatternOptions extends AssetItemOptions {
+    pattern: string | number;
+    width?: number;
+    height?: number;
+    style?: SVGStyles;
+    backgroundStyle?: SVGStyles;
+    transform?: string;
+}
+interface Image {
+    name?: string;
+    url: string;
+}
+interface ImageListOptions extends AssetItemOptions {
+    rootUrl?: string;
+    width?: number;
+    height?: number;
+    images: (Image | string)[];
+}
+type PaletteMode = 'normal' | 'shuffle' | 'random';
+interface ColorListOptions extends AssetItemOptions {
+    mode?: PaletteMode;
+    colors?: string[];
+}
+type AssetOptionsType = LinearGradientOptions | RadialGradientOptions | PatternOptions | ColorListOptions | ImageListOptions;
+
+declare const _ClickAction: {
+    readonly NONE: "none";
+    readonly SELECT: "select";
+    readonly ZOOM: "zoom";
+    readonly CENTER: "center";
+    readonly DRILLDOWN: "drilldown";
+    readonly DRILL_OR_ZOOM: "drillOrZoom";
+};
+type ClickAction = typeof _ClickAction[keyof typeof _ClickAction];
+declare const _DblClickAction: {
+    readonly NONE: "none";
+    readonly SELECT: "select";
+    readonly ZOOM: "zoom";
+    readonly CENTER: "center";
+    readonly DRILLDOWN: "drilldown";
+    readonly DRILL_OR_ZOOM: "drillOrZoom";
+};
+type DblClickAction = typeof _DblClickAction[keyof typeof _DblClickAction];
+declare const _DragAction: {
+    readonly DEFAULT: "default";
+    readonly SELECT: "select";
+    readonly ZOOM: "zoom";
+};
+type DragAction = typeof _DragAction[keyof typeof _DragAction];
+interface ChartOptionsOptions extends ChartItemOptions {
+    alwaysMap?: boolean;
+    clickAction?: ClickAction;
+    dblClickAction?: DblClickAction;
+    dragAction?: DragAction;
+    backgroundStyle?: CSSStyleDeclaration;
+    onSelectionChanged?: (args: any) => void;
+}
+interface TitleOptions extends ChartItemOptions {
+    visible?: boolean;
+    text?: string;
+    alignBase?: AlignBase;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    backgroundStyle?: SVGStyleOrClass;
+    gap?: number;
+}
+declare const _SubtitlePosition: {
+    readonly BOTTOM: "bottom";
+    readonly RIGHT: "right";
+    readonly LEFT: "left";
+    readonly TOP: "top";
+};
+type SubtitlePosition = typeof _SubtitlePosition[keyof typeof _SubtitlePosition];
+interface SubtitleOptions extends TitleOptions {
+    position?: SubtitlePosition;
+    titleGap?: number;
+}
+interface CreditsOptions extends ChartItemOptions {
+    text?: string;
+    url?: string;
+    floating?: boolean;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number;
+    offsetY?: number;
+    gap?: number;
+}
+declare const TooltipScopes: {
+    readonly HOVER: "hover";
+    readonly POINT: "point";
+    readonly GROUP: "group";
+    readonly AXIS: "axis";
+};
+type TooltipScope = typeof TooltipScopes[keyof typeof TooltipScopes];
+interface TooltipOptions extends ChartItemOptions {
+    scope?: TooltipScope;
+    html?: string;
+    text?: string;
+    offset?: number;
+    hideDelay?: number;
+    minWidth?: number;
+    minHeight?: number;
+    followPointer?: boolean;
+    nanText?: string;
+    numberFormat?: string;
+    timeFormat?: string;
+}
+type ProjectionType = undefined | 'orthographic' | 'equalearth' | 'miller' | 'mercator';
+interface MapBackgroundOptions extends ChartItemOptions {
+    visible?: boolean;
+    globeFill?: string;
+}
+interface BodyPanelOptions extends ChartItemOptions {
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number;
+    offsetY?: number;
+    itemGap?: number;
+}
+interface ZoomButton {
+    label?: string;
+    icon?: string;
+}
+interface ZoomPanelOptions extends BodyPanelOptions {
+    buttons?: ZoomButton[];
+    direction?: 'vertical' | 'horizontal';
+    zoomStep?: number;
+    buttonWidth?: number;
+    buttonHeight?: number;
+    showReset?: boolean;
+    buttonStyle?: SVGStyleOrClass;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    showAlways?: boolean;
+}
+declare const _DrilldownPanelType: {
+    readonly BUTTON: "button";
+    readonly TEXT: "text";
+};
+type DrilldownPanelType = typeof _DrilldownPanelType[keyof typeof _DrilldownPanelType];
+interface DrilldownPanelOptions extends BodyPanelOptions {
+    type?: DrilldownPanelType;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+}
+type IOnHoverAreaParam = {
+    area: any;
+    oldArea: any;
+};
+type IOnClickAreaParam = {
+    area: any;
+};
+type IOnZoomChanged = {
+    zoom: number;
+    oldZoom: number;
+};
+interface BodyOptions extends ChartItemOptions {
+    projection?: ProjectionType;
+    mapBackground?: MapBackgroundOptions;
+    zoomPanel?: ZoomPanelOptions | boolean;
+    drilldownPanel?: DrilldownPanelOptions | boolean;
+    zoomable?: boolean;
+    zoom?: number;
+    maxZoom?: number;
+    wheelZoomFactor?: number;
+    scrollable?: boolean;
+    scroll?: number;
+    panX?: number;
+    panY?: number;
+    rotationX?: number;
+    rotationY?: number;
+    fit?: any;
+    points?: ([string, number, number] | {
+        id: string;
+        coord?: MapCoord;
+        lon?: number;
+        lat?: number;
+    })[];
+    onZoomChanged?: (args: IOnZoomChanged) => void;
+    onHoverArea?: (args: IOnHoverAreaParam) => void;
+    onClickArea?: (args: IOnClickAreaParam) => void;
+    annotations?: AnnotationOptionsType | AnnotationOptionsType[];
+}
+interface BackgroundImageOptions extends ChartItemOptions {
+    url?: string;
+}
+
+declare const ScaleLocations: {
+    readonly BOTTOM: "bottom";
+    readonly TOP: "top";
+    readonly RIGHT: "right";
+    readonly LEFT: "left";
+    readonly BODY: "body";
+};
+type ScaleLocation = typeof ScaleLocations[keyof typeof ScaleLocations];
+interface ScaleOptions extends ChartItemOptions {
+    name?: string;
+    series?: string;
+    location?: ScaleLocation;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number;
+    offsetY?: number;
+}
+declare const _ColorScaleLayout: {
+    readonly AUTO: "auto";
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};
+type ColorScaleLayout = typeof _ColorScaleLayout[keyof typeof _ColorScaleLayout];
+declare const ColorScaleDisplays: {
+    readonly SCALE: "scale";
+    readonly LEGEND: "legend";
+    readonly BOTH: "both";
+};
+type ColorScaleDisplay = typeof ColorScaleDisplays[keyof typeof ColorScaleDisplays];
+interface ColorScaleMarkerOptions extends ChartItemOptions {
+    size?: number;
+    label?: ChartTextOptions;
+}
+interface ColorScaleStepLineOptions extends ChartItemOptions {
+}
+interface ColorScaleTickLineOptions extends ChartItemOptions {
+    length?: number;
+}
+interface ColorScaleTickLabelOptions extends IconedTextOptions {
+    position?: 'tick' | 'between';
+    offset?: number;
+    minText?: string;
+    maxText?: string;
+}
+interface ColorScaleTickOptions extends ChartItemOptions {
+    line?: ColorScaleTickLineOptions;
+    label?: ColorScaleTickLabelOptions;
+}
+interface ColorScaleStep {
+    from?: number | string;
+    to?: number | string;
+    label: string;
+    color: string;
+    fromColor?: string;
+    toColor?: string;
+}
+interface ColorStop {
+    stop: number;
+    color: string;
+}
+interface ColorScaleOptions extends ScaleOptions {
+    marker?: ColorScaleMarkerOptions;
+    tick?: ColorScaleTickOptions;
+    stepLine?: ColorScaleStepLineOptions;
+    display?: ColorScaleDisplay;
+    minValue?: number;
+    maxValue?: number;
+    integralSteps?: boolean;
+    stepCount?: number;
+    steps?: ColorScaleStep[];
+    logBase?: number;
+    minColor?: string;
+    maxColor?: string;
+    colors?: ColorStop[];
+    layout?: ColorScaleLayout;
+    barWidth?: number;
+    barLength?: PercentSize;
+    backgroundStyle?: SVGStyleOrClass;
+    gap?: number;
+}
+interface BubbleScaleTickLineOptions extends ChartItemOptions {
+    length?: number;
+}
+interface BubbleScaleTickLabelOptions extends IconedTextOptions {
+    offset?: number;
+}
+interface BubbleScaleTickOptions extends ChartItemOptions {
+    line?: BubbleScaleTickLineOptions;
+    label?: BubbleScaleTickLabelOptions;
+}
+interface BubbleScaleStep {
+    value: number;
+    label: string;
+}
+interface BubbleScaleOptions extends ScaleOptions {
+    tick?: BubbleScaleTickOptions;
+    steps?: (BubbleScaleStep | number)[];
+    stepCount?: number;
+}
+interface MapScaleLabelOptions extends IconedTextOptions {
+    offset?: number;
+}
+interface MapScaleOptions extends ScaleOptions {
+    visible?: boolean;
+    label?: MapScaleLabelOptions;
+}
+
+declare const LegendItemsAligns: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+};
+type LegendItemsAlign = typeof LegendItemsAligns[keyof typeof LegendItemsAligns];
+declare const _LegendLayout: {
+    readonly AUTO: "auto";
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};
+type LegendLayout = typeof _LegendLayout[keyof typeof _LegendLayout];
+declare const LegendLocations: {
+    readonly BOTTOM: "bottom";
+    readonly TOP: "top";
+    readonly RIGHT: "right";
+    readonly LEFT: "left";
+    readonly BODY: "body";
+};
+type LegendLocation = typeof LegendLocations[keyof typeof LegendLocations];
+interface LegendOptions extends ChartItemOptions {
+    visible?: boolean;
+    reversed?: boolean;
+    location?: LegendLocation;
+    layout?: LegendLayout;
+    alignBase?: AlignBase;
+    gap?: number;
+    itemGap?: number;
+    markerVisible?: boolean;
+    markerSize?: number;
+    markerGap?: number;
+    backgroundStyle?: SVGStyleOrClass;
+    itemsPerLine?: number;
+    lineGap?: number;
+    maxWidth?: PercentSize;
+    maxHeight?: PercentSize;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number;
+    offsetY?: number;
+    itemsAlign?: LegendItemsAlign;
+    useTextColor?: boolean;
+    seriesHovering?: boolean;
+}
+
+interface MapAxisGridLineOptions extends ChartItemOptions {
+    step?: number;
+}
+declare const _MapAxisGridFitTo: {
+    readonly Map: "map";
+    readonly Body: "body";
+};
+type MapAxisGridFitTo = typeof _MapAxisGridFitTo[keyof typeof _MapAxisGridFitTo];
+interface MapAxisGridOptions extends ChartItemOptions {
+    visible?: boolean;
+    fitTo?: MapAxisGridFitTo;
+    line?: MapAxisGridLineOptions | number;
+    lonLine?: MapAxisGridLineOptions | number;
+    latLine?: MapAxisGridLineOptions | number;
+}
+interface MapAxisLineOptions extends ChartItemOptions {
+    visible?: boolean;
+}
+interface MapAxisTickLineOptions extends ChartItemOptions {
+    visible?: boolean;
+}
+interface MapAxisTickOptions extends ChartItemOptions {
+    visible?: boolean;
+    line?: MapAxisTickLineOptions;
+    label?: ChartTextOptions;
+}
+declare const _MapAxisGuideLabelPosition: {
+    readonly INSIDE: "inside";
+    readonly OUTSIDE: "outside";
+};
+type MapAxisGuideLabelPosition = typeof _MapAxisGuideLabelPosition[keyof typeof _MapAxisGuideLabelPosition];
+interface MapAxisGuideLabelOptions extends IconedTextOptions {
+    position?: MapAxisGuideLabelPosition;
+    align?: Align;
+    verticalAlign?: VerticalAlign;
+    offsetX?: number;
+    offsetY?: number;
+}
+type MapAxisGuideType = 'line' | 'band' | 'range';
+interface MapAxisGuideOptions extends ChartItemOptions {
+    type?: MapAxisGuideType;
+    label?: MapAxisGuideLabelOptions;
+    front?: boolean;
+    zindex?: number;
+}
+declare const MapAxisLineGuideType = "line";
+interface MapAxisLineGuideOptions extends MapAxisGuideOptions {
+    type?: typeof MapAxisLineGuideType;
+    axis?: 'lon' | 'lat';
+    position?: number;
+}
+declare const MapAxisBandGuideType = "band";
+interface MapAxisBandGuideOptions extends MapAxisGuideOptions {
+    type?: typeof MapAxisBandGuideType;
+    axis?: 'lon' | 'lat';
+    from?: number;
+    to?: number;
+}
+declare const MapAxisRangeGuideType = "range";
+interface MapAxisRangeGuideOptions extends MapAxisGuideOptions {
+    type?: typeof MapAxisRangeGuideType;
+    from?: MapCoord;
+    to?: MapCoord;
+    elliptic?: boolean;
+}
+interface CrosshairFlagOptions extends ChartItemOptions {
+    prefix?: string;
+    suffix?: string;
+    numberFormat?: string;
+    backgroundStyle?: SVGStyleOrClass;
+    minWidth?: number;
+}
+interface CrosshairCallbackArgs {
+    axis: object;
+    coord: MapCoord;
+    flag: string;
+    points: DataPoint[];
+}
+type CrosshairChangeCallback = (args: CrosshairCallbackArgs) => void;
+interface MapCrosshairOptions extends ChartItemOptions {
+    flag?: CrosshairFlagOptions;
+    visible?: boolean;
+    onChange?: CrosshairChangeCallback;
+}
+interface MapAxisOptions extends ChartItemOptions {
+    line?: MapAxisLineOptions;
+    leftLine?: MapAxisLineOptions;
+    rightLine?: MapAxisLineOptions;
+    topLine?: MapAxisLineOptions;
+    bottomLine?: MapAxisLineOptions;
+    equatorLine?: MapAxisLineOptions;
+    meridianLine?: MapAxisLineOptions;
+    grid?: MapAxisGridOptions;
+    tick?: MapAxisTickOptions;
+    crosshair?: MapCrosshairOptions;
+    guide?: MapAxisGuideOptions | MapAxisGuideOptions[];
+}
+
+type PointHoverCallback = (args: DataPointCallbackArgs) => void;
+type PointClickCallback = (args: DataPointCallbackArgs) => boolean;
+type PointStyleCallback = (args: DataPointCallbackArgs) => SVGStyleOrClass;
+declare const _PointViewPosition: {
+    readonly CENTER: "center";
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+type PointViewPosition = typeof _PointViewPosition[keyof typeof _PointViewPosition];
+declare const _PointLabelPositions: {
+    readonly AUTO: "auto";
+    readonly CENTER: "center";
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+type PointLabelPosition = typeof _PointLabelPositions[keyof typeof _PointLabelPositions];
+interface DataPointLabelOptions extends IconedTextOptions {
+    visible?: boolean;
+    zoomLevel?: number;
+    position?: PointLabelPosition;
+    offset?: number;
+    distance?: number;
+    textField?: string;
+    textCallback?: (point: any) => string;
+    visibleCallback?: (point: any) => boolean;
+    styleCallback?: (point: any) => SVGStyleOrClass;
+    animation?: 'reveal' | 'fadenin';
+}
+interface CalloutAnchorPointOptions extends ChartItemOptions {
+    shape?: string;
+    radius?: number;
+}
+interface DataPointCalloutOptions extends ChartItemOptions {
+    anchorPoint?: CalloutAnchorPointOptions;
+    visible?: boolean;
+    usePointColor?: boolean;
+    useSeriesColor?: boolean;
+    layoutOnly?: boolean;
+}
+interface SeriesOptions extends ChartItemOptions {
+    type?: string;
+    name?: string;
+    label?: string;
+    map?: string | number;
+    pointLabel?: DataPointLabelOptions | boolean;
+    callout?: DataPointCalloutOptions | boolean;
+    data?: any;
+    dataUrl?: string;
+    fields?: string[];
+    idField?: string;
+    nameField?: string;
+    lonField?: string;
+    latField?: string;
+    colorField?: string;
+    color?: string | number;
+    pointColors?: string[] | string | ((point: any) => string);
+    tooltipText?: string;
+    tooltipCallback?: (args: any) => string;
+    visibleInLegend?: boolean;
+    loadAnimation?: 'default' | 'reveal' | 'grow' | 'spread' | 'fadein';
+    hoverEffect?: 'none' | 'default';
+    hoverStyle?: SVGStyleOrClass;
+    styleCallback?: PointStyleCallback;
+    onPointsLoaded?: (series: object, firstTime: boolean) => void;
+    onPointAdded?: (p: DataPointCallbackArgs) => void;
+    onPointRemoved?: (p: DataPointCallbackArgs) => void;
+    onPointClick?: PointClickCallback;
+    onPointHover?: PointHoverCallback;
+}
+interface ValueSeriesOptions extends SeriesOptions {
+    valueField?: string;
+}
+interface MarkerSeriesOptions extends ValueSeriesOptions {
+    rotation?: number;
+    hintDistance?: number;
+}
+interface SparkSeriesCategory {
+    name?: string;
+    color?: string;
+}
+interface SparkSeriesOptions extends ValueSeriesOptions {
+    categories?: SparkSeriesCategory[];
+    legendByCategory?: boolean;
+    minSize?: number;
+    rotation?: number;
+    position?: PointViewPosition;
+}
+interface GaugeOptions extends ValueSeriesOptions {
+    width?: number;
+    height?: number;
+    size?: number;
+    position?: PointViewPosition;
+}
+interface ValueGaugeOptions extends GaugeOptions {
+    minValue?: number;
+    maxValue?: number;
+}
+interface SparkBaseLineOptions extends ChartItemOptions {
+}
+declare const _DataPointValueDomain: {
+    readonly SERIES: "series";
+    readonly POINT: "point";
+};
+type DataPointValueDomain = typeof _DataPointValueDomain[keyof typeof _DataPointValueDomain];
+interface OrthogonalSparkSeriesOptions extends SparkSeriesOptions {
+    baseLine?: SparkBaseLineOptions | boolean;
+    width?: number;
+    height?: number;
+    padding?: PercentSize;
+    baseValue?: number;
+    belowStyle?: SVGStyleOrClass;
+    valueDomain?: DataPointValueDomain;
+    minValue?: number;
+    maxValue?: number;
+    logBase?: number;
+}
+declare const BarSeriesType = "bar";
+interface BarSeriesOptions extends OrthogonalSparkSeriesOptions {
+    type?: typeof BarSeriesType;
+    subLabel?: DataPointLabelOptions | boolean;
+    inverted?: boolean;
+    barWidth?: number;
+    maxValue?: number;
+    nullAsBase?: boolean;
+    belowStyle?: SVGStyleOrClass;
+}
+interface LineSeriesAreaOptions extends ChartItemOptions {
+    visible?: false;
+}
+declare const LineSeriesType = "line";
+interface LineSeriesOptions extends OrthogonalSparkSeriesOptions {
+    type?: typeof LineSeriesType;
+    back?: ChartItemOptions;
+    area?: LineSeriesAreaOptions;
+    curved?: boolean;
+}
+declare const PieSeriesType = "pie";
+interface PieSeriesOptions extends SparkSeriesOptions {
+    type?: typeof PieSeriesType;
+    centerX?: number;
+    centerY?: number;
+    radius?: PercentSize;
+    startAngle?: number;
+    totalAngle?: number;
+    clockwise?: boolean;
+    legendByField?: boolean;
+    colorByValue?: boolean;
+}
+declare const _WaffleDirection: {
+    readonly ROW: "row";
+    readonly COL: "col";
+};
+type WaffleDirection = typeof _WaffleDirection[keyof typeof _WaffleDirection];
+declare const WaffleSeriesType = "waffle";
+interface WaffleSeriesOptions extends SparkSeriesOptions {
+    type?: typeof WaffleSeriesType;
+    rowCount?: number;
+    colCount?: number;
+    roundingMethod?: 'round' | 'trunc';
+    minCount?: number;
+    shape?: 'sqaure' | 'circle' | 'star' | 'diamond' | 'hexagon';
+    cellSize?: 5;
+    gap?: 2;
+    fillDirection?: WaffleDirection;
+    fillThreshold?: number;
+    valueDomain?: DataPointValueDomain;
+    minValue?: number;
+    maxValue?: number;
+    showNull?: boolean;
+}
+declare const _BubbleSizeMode: {
+    readonly WIDTH: "width";
+    readonly AREA: "area";
+};
+type BubbleSizeMode = typeof _BubbleSizeMode[keyof typeof _BubbleSizeMode];
+declare const BubbleSeriesType = "bubble";
+interface BubbleSeriesOptions extends MarkerSeriesOptions {
+    type?: typeof BubbleSeriesType;
+    subLabel?: DataPointLabelOptions | boolean;
+    minValue?: number;
+    maxValue?: number;
+    sizeMode?: BubbleSizeMode;
+    minSize?: PercentSize;
+    maxSize?: PercentSize;
+    position?: PointViewPosition;
+    tooltipText?: string;
+    alignToSurface?: boolean;
+}
+declare const _RouteLineType: {
+    readonly AIR: "air";
+    readonly STRAIGHT: "straight";
+    readonly CURVED: "curved";
+};
+type RouteLineType = typeof _RouteLineType[keyof typeof _RouteLineType];
+declare const _RouteArrowDisplay: {
+    readonly ALWAYS: "always";
+    readonly MOVING: "moving";
+    readonly NONE: "none";
+};
+type RouteArrowDisplay = typeof _RouteArrowDisplay[keyof typeof _RouteArrowDisplay];
+declare const RouteSeriesType = "route";
+interface RouteSeriesOptions extends SeriesOptions {
+    type?: typeof RouteSeriesType;
+    lineType?: RouteLineType;
+    lineWidth?: number;
+    arrowDisplay?: RouteArrowDisplay;
+}
+interface MapSeriesLabelOptions extends DataPointLabelOptions {
+    visible?: boolean;
+    hoverColor?: string;
+}
+interface DrilldownOptions extends ChartItemOptions {
+    enabled?: boolean;
+    autoMapChange?: boolean;
+}
+declare const MapSeriesType = "map";
+interface MapSeriesOptions extends ValueSeriesOptions {
+    type?: typeof MapSeriesType;
+    useMapData?: boolean;
+    mapKeys?: string | [string, string];
+    middleKeys?: [string, string];
+    nullStyle?: SVGStyleOrClass;
+    dummyStyle?: SVGStyleOrClass;
+    nullHovering?: boolean;
+    hoverColor?: string;
+    hoverStyle?: SVGStyleOrClass;
+    selectable?: boolean;
+    selectedStyle?: SVGStyleOrClass;
+    allAreas?: boolean;
+    colorRange?: ColorRange;
+    colorScale?: string | number;
+    drilldown?: DrilldownOptions;
+    detail?: MapSeriesOptions;
+    detailKey?: string;
+    detailZoom?: number;
+    bringToFront?: boolean;
+}
+declare const FeatureSeriesType = "feature";
+interface FeatureSeriesOptions extends ValueSeriesOptions {
+    type?: typeof FeatureSeriesType;
+    hoverColor?: string;
+    hoverStyle?: SVGStyleOrClass;
+    selectable?: boolean;
+    colorRange?: ColorRange;
+    colorScale?: string | number;
+    detail?: FeatureSeriesOptions;
+    detailKey?: string;
+    detailZoom?: number;
+    bringToFront?: boolean;
+}
+declare const PointSeriesType = "point";
+interface PointSeriesOptions extends MarkerSeriesOptions {
+    type?: typeof PointSeriesType;
+    shape?: Shape;
+    radius?: number;
+    position?: PointViewPosition;
+}
+interface ImageSeriesLabelOptions extends DataPointLabelOptions {
+    visible?: boolean;
+}
+declare const ImageSeriesType = "image";
+interface ImageSeriesOptions extends SeriesOptions {
+    type?: typeof ImageSeriesType;
+    pointLabel?: ImageSeriesLabelOptions;
+    imageField?: string;
+    rootUrl?: string;
+    imageWidth?: number;
+    imageHeight?: number;
+    rotation?: number;
+    position?: PointViewPosition;
+}
+declare const PinSeriesType = "pin";
+interface PinSeriesOptions extends MarkerSeriesOptions {
+    type?: typeof PinSeriesType;
+    radius?: number;
+    innerRadius?: number;
+    innerStyle?: SVGStyleOrClass;
+    innerLabel?: ChartTextOptions | string;
+    position?: PointViewPosition;
+}
+declare const FigureSeriesType = "figure";
+interface FigureSeriesOptions extends ValueSeriesOptions {
+    type?: typeof FigureSeriesType;
+    figure?: string;
+    rotation?: number;
+    innerLabel?: IconedTextOptions | string;
+    position?: PointViewPosition;
+}
+declare const _VectorHeadType: {
+    readonly NONE: "none";
+    readonly CLOSED_ARROW: "closedArrow";
+    readonly OPEN_ARROW: "openArrow";
+};
+type VectorHeadType = typeof _VectorHeadType[keyof typeof _VectorHeadType];
+declare const VectorSeriesType = "vector";
+interface VectorSeriesOptions extends MarkerSeriesOptions {
+    type?: typeof VectorSeriesType;
+    headType?: VectorHeadType;
+    lengthField?: string;
+    angleField?: string;
+    startAngle?: number;
+}
+interface HitmapGridModeOptions {
+    cellWidth?: number;
+    cellHeight?: number;
+    elliptic?: boolean;
+}
+interface HitmapPointModeOptions {
+}
+interface HitmapKdeModeOptions {
+}
+declare const _HitmapMode: {
+    readonly GRID: "grid";
+    readonly POINT: "point";
+    readonly KDE: "kde";
+};
+type HitmapMode = typeof _HitmapMode[keyof typeof _HitmapMode];
+declare const HeatmapSeriesType = "heatmap";
+interface HeatmapSeriesOptions extends MarkerSeriesOptions {
+    type?: typeof HeatmapSeriesType;
+    mode?: HitmapMode;
+    grid?: HitmapGridModeOptions;
+    point?: HitmapPointModeOptions;
+    kde?: HitmapKdeModeOptions;
+}
+interface PanelSeriesSectionOptions extends ChartItemOptions {
+    text?: string;
+    backgroundStyle?: SVGStyleOrClass | PointStyleCallback;
+}
+interface PanelSeriesHeaderOptions extends PanelSeriesSectionOptions {
+    minSize?: PercentSize;
+}
+interface PanelSeriesBodyOptions extends PanelSeriesSectionOptions {
+}
+interface PanelSeriesLabelOptions extends DataPointLabelOptions {
+    visible?: boolean;
+}
+declare const PanelSeriesType = "panel";
+interface PanelSeriesOptions extends ValueSeriesOptions {
+    type?: typeof PanelSeriesType;
+    orientation?: 'vertical' | 'horizontal';
+    pointLabel?: PanelSeriesLabelOptions;
+    header?: PanelSeriesHeaderOptions;
+    body?: PanelSeriesBodyOptions;
+    divider?: ChartItemOptions;
+    minWidth?: number;
+    minHeight?: number;
+    position?: PointViewPosition;
+}
+declare const TiledWebSeriesType = "tiledweb";
+interface TiledWebSeriesOptions extends SeriesOptions {
+    type?: typeof TiledWebSeriesType;
+}
+interface CircleGaugeFaceOptions extends ChartItemOptions {
+    visible?: boolean;
+}
+interface CircleGaugeRimOptions extends ChartItemOptions {
+}
+interface CircleGaugeValueRimOptions extends ChartOptionsOptions {
+    thickness?: PercentSize;
+    stroked?: boolean;
+}
+interface CircleGaugeHandOptions extends ChartItemOptions {
+    visible?: boolean;
+    radius?: PercentSize;
+    length?: PercentSize;
+    offset?: PercentSize;
+}
+interface CircleGaugePinOptions extends ChartItemOptions {
+    visible?: boolean;
+    radius?: PercentSize;
+}
+interface CircleGaugeLabelOptions extends ChartTextOptions {
+    offsetX?: PercentSize;
+    offsetY?: PercentSize;
+}
+declare const CircleGaugeType = "gauge";
+interface CircleGaugeOptions extends ValueGaugeOptions {
+    type?: typeof CircleGaugeType;
+    face?: CircleGaugeFaceOptions | boolean;
+    rim?: CircleGaugeRimOptions;
+    valueRim?: CircleGaugeValueRimOptions | boolean;
+    hand?: CircleGaugeHandOptions;
+    pin?: CircleGaugePinOptions;
+    gaugeLabel?: CircleGaugeLabelOptions;
+    centerX?: PercentSize;
+    centerY?: PercentSize;
+    radius?: PercentSize;
+    innerRadius?: PercentSize;
+    valueRadius?: PercentSize;
+    startAngle?: number;
+    sweepAngle?: number;
+    clockwise?: boolean;
+}
+interface ClockGaugeRimOptions extends ChartItemOptions {
+    thickness?: PercentSize;
+}
+interface ClockGaugeHandOptions extends ChartItemOptions {
+    thickness?: number;
+    length?: PercentSize;
+    pmStyle?: SVGStyleOrClass;
+}
+interface ClockGaugeSecondHandOptions extends ClockGaugeHandOptions {
+    animatable?: boolean;
+    duration?: number;
+}
+interface ClockGaugeTickOptions extends ChartItemOptions {
+    length?: number;
+}
+interface ClockGaugeTickLabelOptions extends ChartItemOptions {
+    step?: number;
+    offset?: number;
+}
+interface ClockGaugePinOptions extends ChartItemOptions {
+    radius?: number;
+}
+declare const _ClockGaugeLabelPosition: {
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+};
+type ClockGaugeLabelPosition = typeof _ClockGaugeLabelPosition[keyof typeof _ClockGaugeLabelPosition];
+interface ClockGaugeLabelOptions extends ChartTextOptions {
+    position?: ClockGaugeLabelPosition;
+}
+declare const ClockGaugeType = "clock";
+interface ClockGaugeOptions extends GaugeOptions {
+    type?: typeof ClockGaugeType;
+    size?: number;
+    centerX?: PercentSize;
+    centerY?: PercentSize;
+    radius?: PercentSize;
+    face?: ChartItemOptions | boolean;
+    rim?: ClockGaugeRimOptions | boolean;
+    hourHand?: ClockGaugeHandOptions | boolean;
+    minuteHand?: ClockGaugeHandOptions | boolean;
+    secondHand?: ClockGaugeSecondHandOptions | boolean;
+    tick?: ClockGaugeTickOptions | boolean;
+    tickLabel?: ClockGaugeTickLabelOptions | boolean;
+    pin?: ClockGaugePinOptions | boolean;
+    gaugeLabel?: ClockGaugeLabelOptions | boolean;
+    timezoneCallback?: (lon: number, lat: number) => number;
+    nightHours?: [number, number];
+    active?: boolean;
+}
+type SeriesOptionsType = MapSeriesOptions | FeatureSeriesOptions | PointSeriesOptions | PinSeriesOptions | FigureSeriesOptions | VectorSeriesOptions | RouteSeriesOptions | ImageSeriesOptions | BarSeriesOptions | PieSeriesOptions | WaffleSeriesOptions | LineSeriesOptions | BubbleSeriesOptions | HeatmapSeriesOptions | PanelSeriesOptions | TiledWebSeriesOptions | CircleGaugeOptions | ClockGaugeOptions;
+
+declare class MapScaleLabel extends IconedText<MapScaleLabelOptions> {
+    static defaults: MapScaleLabelOptions;
+    getText(value: any): string;
+    getDefaultIconPos(): IconPosition;
+}
+declare class MapScale extends ScaleBase<MapScaleOptions> {
+    static defaults: MapScaleOptions;
+    private _label;
+    private _scale;
+    protected _doInit(op: MapScaleOptions): void;
+    get label(): MapScaleLabel;
+    protected _getFirstSeries(chart: IChart): Series<SeriesOptions>;
+    protected _doApply(options: MapScaleOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+    private $_calcScale;
+}
+
+interface MapSourceOptions extends MapSource {
+}
+interface ChartConfiguration {
+    templates?: ConfigObject;
+    type?: 'map' | 'feature' | 'point' | 'pin' | 'vector' | 'bar' | 'pie' | 'figure' | 'bubble' | 'route' | 'image' | 'line' | 'heatmap' | 'panel' | 'waffle' | 'gauge' | 'clock';
+    startOfWeek?: number;
+    chart?: ChartOptionsOptions;
+    asset?: AssetOptionsType | AssetOptionsType[];
+    assets?: AssetOptionsType | AssetOptionsType[];
+    title?: TitleOptions | string;
+    subtitle?: SubtitleOptions | string;
+    map?: MapSourceOptions | MapSourceOptions[];
+    axis?: MapAxisOptions;
+    body?: BodyOptions;
+    legend?: LegendOptions | boolean;
+    colorScale?: ColorScaleOptions | ColorScaleOptions[];
+    colorScales?: ColorScaleOptions | ColorScaleOptions[];
+    bubbleScale?: BubbleScaleOptions | BubbleScaleOptions[];
+    bubbleScales?: BubbleScaleOptions | BubbleScaleOptions[];
+    mapScale?: MapScale;
+    zoomPanel?: ZoomPanelOptions | boolean;
+    drilldownPanel?: DrilldownPanelOptions | boolean;
+    tooltip?: TooltipOptions | boolean;
+    credits?: CreditsOptions | boolean;
+    series?: SeriesOptionsType | SeriesOptionsType[];
+    annotation?: AnnotationOptionsType | AnnotationOptionsType[];
+    annotations?: AnnotationOptionsType | AnnotationOptionsType[];
+    exporting?: ExporterOptions;
+}
+
+declare const _SeriesLoadAnimation: {
+    readonly DEFAULT: "default";
+    readonly REVEAL: "reveal";
+    readonly GROW: "grow";
+    readonly SLIDEIN: "slidein";
+    readonly SPREAD: "spread";
+    readonly FADEIN: "fadein";
+};
+type SeriesLoadAnimation = typeof _SeriesLoadAnimation[keyof typeof _SeriesLoadAnimation];
+
+declare abstract class AssetItem<T extends AssetItemOptions> {
+    source: T;
+    constructor(source: T);
+    hasDef(): boolean;
+    abstract getElement(doc: Document, source: T): Element;
+}
+interface IAssetOwner {
+    addDef(element: Element): void;
+    removeDef(element: string): void;
+}
+declare class AssetCollection {
+    private _items;
+    private _selectedFill;
+    private _map;
+    load(source: any): AssetOptionsType | AssetOptionsType[];
+    register(doc: Document, owner: IAssetOwner): void;
+    unregister(owner: IAssetOwner): void;
+    get(id: string): AssetItem<AssetItemOptions>;
+    updateOptions(source: any, render: boolean): void;
+    private $_loadItem;
+}
+
+interface IBubbleScaleStep {
+    value: number;
+    label: string;
+    rd: number;
+}
+declare class BubbleScaleTickLine extends ChartItem<BubbleScaleTickLineOptions> {
+    static defaults: BubbleScaleTickLineOptions;
+}
+declare class BubbleScaleTickLabel extends IconedText<BubbleScaleTickLabelOptions> {
+    static defaults: BubbleScaleTickLabelOptions;
+    getText(value: any): string;
+    getDefaultIconPos(): IconPosition;
+}
+declare class BubbleScaleTick extends ChartItem<BubbleScaleTickOptions> {
+    static defaults: BubbleScaleTickOptions;
+    private _line;
+    private _label;
+    protected _doInit(op: BubbleScaleTickOptions): void;
+    get line(): BubbleScaleTickLine;
+    get label(): BubbleScaleTickLabel;
+}
+declare class BubbleScale extends ScaleBase<BubbleScaleOptions> {
+    static defaults: BubbleScaleOptions;
+    private _tick;
+    private _steps;
+    protected _doInit(op: BubbleScaleOptions): void;
+    get tick(): BubbleScaleTick;
+    getSteps(wBody: number, hBody: number): IBubbleScaleStep[];
+    protected _getFirstSeries(chart: IChart): Series<SeriesOptions>;
+    protected _doApply(options: BubbleScaleOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+    private $_buildSteps;
+}
+declare class BubbleScaleCollection extends ScaleCollection<BubbleScale> {
+    protected _createScale(chart: IChart): BubbleScale;
+}
+
+interface ILegendSource {
+    visible: boolean;
+    canHide(): boolean;
+    legendMarker(doc: Document, size: number): RmElement;
+    legendColor(): string;
+    legendLabel(): string;
+}
+declare class LegendItem extends ChartItem<ChartItemOptions> {
+    legend: Legend;
+    source: ILegendSource;
+    static readonly MARKER_SIZE = 10;
+    constructor(legend: Legend, source: ILegendSource);
+    text(): string;
+}
+declare class Legend extends ChartItem<LegendOptions> {
+    static defaults: LegendOptions;
+    private _maxWidth;
+    private _maxHeight;
+    private _items;
+    private _maxWidthDim;
+    private _maxHeightDim;
+    private _location;
+    items(): LegendItem[];
+    isEmpty(): boolean;
+    isVisible(): boolean;
+    getLocation(): LegendLocation;
+    isInner(): boolean;
+    getLayout(): LegendLayout;
+    getMaxWidth(domain: number): number;
+    getMaxHeight(domain: number): number;
+    protected _doApply(options: LegendOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+interface IColorRanger {
+    getColor(min: number, max: number, value: number, color: Color): string;
+}
+declare class ColorScaleMarker extends ChartItem<ColorScaleMarkerOptions> {
+    static defaults: ColorScaleMarkerOptions;
+    private _label;
+    protected _doInit(op: ColorScaleMarkerOptions): void;
+    get label(): ChartText<ChartTextOptions>;
+    getMarkerSize(): number;
+}
+declare class ColorScaleTickLine extends ChartItem<ColorScaleTickLineOptions> {
+    static defaults: ColorScaleTickLineOptions;
+}
+declare class ColorScaleTickLabel extends IconedText<ColorScaleTickLabelOptions> {
+    static defaults: ColorScaleTickLabelOptions;
+    getDefaultIconPos(): IconPosition;
+}
+declare class ColorScaleTick extends ChartItem<ColorScaleTickOptions> {
+    static defaults: ColorScaleTickOptions;
+    private _line;
+    private _label;
+    protected _doInit(op: ColorScaleTickOptions): void;
+    get line(): ColorScaleTickLine;
+    get label(): ColorScaleTickLabel;
+}
+interface IColorScaleTick {
+    pos: number;
+    label?: string;
+}
+declare class ColorScaleStepLine extends ChartItem {
+}
+declare class ColorScale extends ScaleBase<ColorScaleOptions> implements IColorRanger {
+    static defaults: ColorScaleOptions;
+    private _barLength;
+    private _marker;
+    private _stepLine;
+    private _tick;
+    private _min;
+    private _max;
+    private _minColor;
+    private _maxColor;
+    private _colors;
+    private _barLengthDim;
+    private _logger;
+    private _steps;
+    private _valueSteps;
+    protected _doInit(op: ColorScaleOptions): void;
+    getColor(min: number, max: number, value: number, color: Color): string;
+    get marker(): ColorScaleMarker;
+    get stepLine(): ColorScaleStepLine;
+    get tick(): ColorScaleTick;
+    get minColor(): Color;
+    get maxColor(): Color;
+    getRanger(): IColorRanger;
+    getLayout(): ColorScaleLayout;
+    getBarSize(wDomain: number, hDomain: number, vertical: boolean): ISize;
+    getSplitPoints(len: number): number[];
+    getPosition(value: number): number;
+    getTicks(): IColorScaleTick[];
+    getSteps(): ColorScaleStep[];
+    getValueSteps(): number[];
+    getLegendSources(target: ILegendSource[]): void;
+    protected _doApply(options: ColorScaleOptions): void;
+    private $_parseColorStops;
+    protected _doPrepareRender(chart: IChart): void;
+    private $_parseValue;
+    private $_normalizeMin;
+    private $_parseColor;
+    private $_buildSteps;
+}
+declare class ColorScaleCollection extends ScaleCollection<ColorScale> {
+    getVisibles(loc: ScaleLocation): ColorScale[];
+    getLegendSources(): ILegendSource[];
+    protected _createScale(chart: IChart): ColorScale;
+}
+
+declare class Exporter extends ChartItem<ExporterOptions> {
+    static defaults: ExporterOptions;
+    private _module;
+    private _isCompose;
+    isCompose(): boolean;
+    compose(exporter: ChartExporter): void;
+    isContextMenuVisible(): boolean;
+    toggleContextMenu(): void;
+    exportToImage(dom: HTMLElement, options: ExportOptions, exporting: ExporterOptions): void;
+}
+
+interface MapProjection {
+    second?: MapProjection;
+    scroll: number;
+    bounds?: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    isGlobe?: boolean;
+    isElliptic?: boolean;
+    project(coord: MapCoord): MapCoord;
+    backward(coord: MapCoord): MapCoord;
+    clip(pts: MapCoord[]): MapCoord[];
+    isVisible(coord: MapCoord): boolean;
+    getVisible(coord: MapCoord): MapCoord;
+    getClipBounds(): MapCoord[];
+    isClipping(): boolean;
+}
+declare class MapArea extends RmObject implements ISelectionSource {
+    source?: AreaItem;
+    inset?: MapInset;
+    _insetChilds: number[];
+    private _info;
+    private _path;
+    h1: number;
+    h2: number;
+    v1: number;
+    v2: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    center: MapCoord;
+    visible: boolean;
+    dummy: boolean;
+    private _selected;
+    constructor(source?: AreaItem, inset?: MapInset);
+    setSelected(selected: boolean): void;
+    id: string;
+    name: string;
+    get path(): string;
+    get selected(): boolean;
+    displayText(): string;
+    getInfo(): any;
+    reset(): void;
+    private $_readBound;
+    private $_readInset;
+    private $_toPath;
+    readBounds(polys: number[]): {
+        h1: number;
+        v1: number;
+        h2: number;
+        v2: number;
+    };
+    readPath(prj: MapProjection): string;
+    getCenter(): MapCoord;
+    _clone(): MapArea;
+}
+interface IMapOwner {
+    getProjection(second: boolean): MapProjection;
+    projectionChanged(): void;
+    mapChanged(map: MapModel): void;
+}
+declare class MapModel extends RmObject {
+    owner: IChart & IMapOwner;
+    source: MapSourceImpl | MapModel;
+    private _second;
+    private _areas;
+    private _areaMap;
+    _insets: MapInset[];
+    private _mapAreaFinder;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    cx: number;
+    cy: number;
+    h1: number;
+    v1: number;
+    h2: number;
+    v2: number;
+    sibling: MapModel;
+    private _enabled;
+    private _hiddenAreas;
+    private _index;
+    private _name;
+    private _hiddens;
+    constructor(owner: IChart & IMapOwner, source: MapSourceImpl | MapModel, index: number);
+    get index(): number;
+    get name(): string;
+    get areaCount(): number;
+    get hiddenAreas(): string[];
+    set hiddenAreas(value: string[]);
+    get(index: number): MapArea;
+    areaOf(id: any): MapArea;
+    getAreaMap(prop: string): {
+        [key: string]: MapArea;
+    };
+    findByCoord(coord: MapCoord): MapArea | null;
+    reset(): void;
+    isVisible(area: string): boolean;
+    private $_resetAreas;
+    private $_load;
+    private $_copy;
+    _prepareSecond(): this;
+    _internalAreas(): MapArea[];
+}
+
+declare class MapAxisGridLine extends ChartItem<MapAxisGridLineOptions> {
+    static defaults: MapAxisGridLineOptions;
+    protected _doSetSimple(src: any): boolean;
+}
+declare class MapAxisGrid extends ChartItem<MapAxisGridOptions> {
+    static defaults: MapAxisGridOptions;
+    private _line;
+    private _lonLine;
+    private _latLine;
+    private _fitTo;
+    protected _doInit(op: MapAxisGridOptions): void;
+    get line(): MapAxisGridLine;
+    get lonLine(): MapAxisGridLine;
+    get latLine(): MapAxisGridLine;
+    get fitTo(): MapAxisGridFitTo;
+    getStep(map: MapModel): number;
+    getLonStep(map: MapModel): number;
+    getLatStep(map: MapModel): number;
+    protected _doApply(options: MapAxisGridOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+    private $_defaultStep;
+}
+declare class MapAxisLine extends ChartItem<MapAxisLineOptions> {
+    static defaults: MapAxisLineOptions;
+}
+declare class MapAxisTickLine extends ChartItem<MapAxisTickLineOptions> {
+    static defaults: MapAxisTickLineOptions;
+}
+declare class MapAxisTick extends ChartItem<MapAxisTickOptions> {
+    static defaults: MapAxisTickOptions;
+    private _line;
+    private _label;
+    protected _doInit(op: MapAxisTickOptions): void;
+    get line(): MapAxisTickLine;
+    get label(): ChartText<ChartTextOptions>;
+}
+declare class MapAxisGuideLabel extends IconedText<MapAxisGuideLabelOptions> {
+    static defaults: MapAxisGuideLabelOptions;
+    getDefaultIconPos(): IconPosition;
+}
+declare abstract class MapAxisGuide<OP extends MapAxisGuideOptions = MapAxisGuideOptions> extends ChartItem<OP> {
+    static defaults: MapAxisGuideOptions;
+    private _label;
+    protected _doInit(op: OP): void;
+    get label(): MapAxisGuideLabel;
+}
+declare class MapAxisLineGuide extends MapAxisGuide<MapAxisLineGuideOptions> {
+    static defaults: MapAxisLineGuideOptions;
+}
+declare class MapAxisBandGuide extends MapAxisGuide<MapAxisBandGuideOptions> {
+    static defaults: MapAxisBandGuideOptions;
+}
+declare class MapAxisRangeGuide extends MapAxisGuide<MapAxisRangeGuideOptions> {
+    static defaults: MapAxisRangeGuideOptions;
+}
+declare class CrosshairFlag extends ChartItem<CrosshairFlagOptions> {
+    static defaults: CrosshairFlagOptions;
+}
+declare class MapCrosshair extends ChartItem<MapCrosshairOptions> {
+    axis: MapAxis;
+    static defaults: MapCrosshairOptions;
+    private _flag;
+    private _args;
+    constructor(axis: MapAxis);
+    protected _doInit(op: MapCrosshairOptions): void;
+    get flag(): CrosshairFlag;
+    getFlag(pos: number): string;
+    moved(pos: IPoint, flag: string, points: DataPoint[]): void;
+    protected _doSetSimple(source: any): boolean;
+}
+declare class MapAxis extends ChartItem<MapAxisOptions> {
+    static defaults: MapAxisOptions;
+    private _line;
+    private _leftLine;
+    private _rightLine;
+    private _topLine;
+    private _bottomLine;
+    private _equatorLine;
+    private _meridianLine;
+    private _grid;
+    private _tick;
+    private _crosshair;
+    private _guides;
+    private _saveGuide;
+    protected _doInit(op: MapAxisOptions): void;
+    get line(): MapAxisLine;
+    get leftLine(): MapAxisLine;
+    get rightLine(): MapAxisLine;
+    get topLine(): MapAxisLine;
+    get bottomLine(): MapAxisLine;
+    get equatorLine(): MapAxisLine;
+    get meridianLine(): MapAxisLine;
+    get grid(): MapAxisGrid;
+    get tick(): MapAxisTick;
+    get crosshair(): MapCrosshair;
+    get guides(): MapAxisGuide<MapAxisGuideOptions>[];
+    protected _doApply(options: MapAxisOptions): void;
+    private $_loadGuides;
+}
+
+declare abstract class BodyPanel<OP extends BodyPanelOptions = BodyPanelOptions> extends ChartItem<OP> {
+    static readonly ITEM_GAP = 4;
+    static defaults: BodyPanelOptions;
+    getItemGap(): number;
+}
+declare class ZoomPanel extends BodyPanel<ZoomPanelOptions> {
+    static readonly BUTTON_SIZE = 24;
+    static defaults: ZoomPanelOptions;
+    get vertical(): boolean;
+    getButtonSize(): ISize;
+    getZoomStep(): number;
+    protected _isVisible(): boolean;
+}
+declare class DrilldownPanel extends BodyPanel<DrilldownPanelOptions> {
+    static defaults: DrilldownPanelOptions;
+    protected _isVisible(): boolean;
+}
+
+declare class Title<OP extends TitleOptions = TitleOptions> extends ChartItem<OP> {
+    static defaults: TitleOptions;
+    isVisible(): boolean;
+    protected _doSetSimple(src: any): boolean;
+}
+declare class Subtitle extends Title<SubtitleOptions> {
+    static defaults: SubtitleOptions;
+}
+
+interface ITooltipContext {
+    getTooltipText(series: ISeries, point: DataPoint): string;
+    getTooltipParam(series: ISeries, point: DataPoint, param: string): string;
+}
+interface ITooltipOwner {
+    chart: IChart;
+    getTooltipContext(level: TooltipScope, series: ISeries, point: DataPoint): ITooltipContext;
+}
+declare class Tooltip extends ChartItem<TooltipOptions> {
+    owner: ITooltipOwner;
+    static defaults: TooltipOptions;
+    private _numberFormat;
+    private _timeFormat;
+    _op: TooltipOptions;
+    private _ctx;
+    private _series;
+    private _point;
+    private _siblings;
+    private _domain;
+    constructor(owner: ITooltipOwner);
+    protected _doInit(): void;
+    setTarget(series: ISeries, point: DataPoint): ITooltipContext;
+    getTextDomain(): IRichTextDomain;
+    isFollowPointer(series: ISeries): boolean;
+    protected _doSetSimple(source: any): boolean;
+    protected _doApply(options: TooltipOptions): void;
+}
+
+declare class MapSeriesPoint extends ValuePoint {
+    area: MapArea;
+    center: MapCoord;
+    protected _readObject(series: MapSeries, v: any): void;
+    getLabel(index: number): string;
+    getParam(param: string): any;
+}
+declare class MapSeriesDrilldown extends ChartItem<DrilldownOptions> {
+    static defaults: DrilldownOptions;
+}
+declare class MapSeries extends ValueSeries<MapSeriesOptions> {
+    static type: string;
+    static defaults: MapSeriesOptions;
+    protected _doInit(op: MapSeriesOptions): void;
+    private _parent;
+    private _detail;
+    private _detailed;
+    private _drilldown;
+    private _areaPts;
+    private _minValue;
+    private _maxValue;
+    private _colorObj;
+    private _useMapData;
+    get areaCount(): number;
+    get parent(): MapSeries;
+    get detail(): MapSeries;
+    get drilldown(): MapSeriesDrilldown;
+    get color(): Color;
+    private _colorRanger;
+    getHistory(): MapSeries[];
+    get(second: boolean, index: number): MapArea;
+    pointOf(area: MapArea): MapSeriesPoint;
+    pointByProp(prop: string, value: any): MapSeriesPoint;
+    getBounds(projection: ProjectionType): IRect;
+    getCenter(p: MapSeriesPoint | string): MapCoord;
+    getValueRange(): {
+        min: number;
+        max: number;
+    };
+    getDetailed(): MapSeries;
+    showDetail(): void;
+    showParent(): void;
+    protected _createLabel(chart: IChart): DataPointLabel;
+    private $_createDetail;
+    protected _doLoad(options: ChartItemOptions, source: any): void;
+    protected _doApply(options: MapSeriesOptions): void;
+    needMapScale(): boolean;
+    getRangedColor(p: MapSeriesPoint): string;
+    followTooltipPointer(): boolean;
+    getLegendSources(list: ILegendSource[]): void;
+    protected _createPoint(source: any): MapSeriesPoint;
+    protected _getPointCallbackArgs(args: DataPointCallbackArgs, p: MapSeriesPoint): DataPointCallbackArgs;
+    _prepareRender(): void;
+    protected _doPrepareRender(chart: IChart): void;
+    protected _doLoadPoints(src: any): void;
+    setCalcedColor(color: string): void;
+    getColorScale(): string | number;
+    canSelect(): boolean;
+}
+
+declare class MapBackground extends ChartItem<MapBackgroundOptions> {
+    static defaults: MapBackgroundOptions;
+    isVisible(): boolean;
+}
+interface IBodyTransform {
+    tx: number;
+    ty: number;
+    scale: number;
+    vx: number;
+    vy: number;
+}
+declare class Body extends ChartItem<BodyOptions> implements IAnnotationOwner {
+    static defaults: BodyOptions;
+    private _projection;
+    private _mapBackground;
+    private _anns;
+    _annotations: AnnotationCollection;
+    _prj: MapProjection;
+    _points: {
+        [id: string]: MapCoord;
+    };
+    private _map;
+    private _zoom;
+    private _zoomAni;
+    private _panX;
+    private _panY;
+    private _wRate;
+    private _hRate;
+    private _scale;
+    private _vRect;
+    private _wMap;
+    private _reCalculateFlag;
+    private _dragDistance;
+    constructor(chart: IChart);
+    protected _doInit(op: BodyOptions): void;
+    anchorByName(name: string): ChartItem;
+    get projection(): MapProjection;
+    get mapBackground(): MapBackground;
+    get rotationX(): number;
+    set rotationX(value: number);
+    get rotationY(): number;
+    set rotationY(value: number);
+    get scroll(): number;
+    set scroll(value: number);
+    get panX(): number;
+    set panX(value: number);
+    get panY(): number;
+    set panY(value: number);
+    get zoom(): number;
+    set zoom(value: number);
+    get isZoomed(): boolean;
+    get scale(): number;
+    get center(): MapCoord;
+    get map(): MapModel;
+    set dragDistance(value: number);
+    isDrilldowned(): boolean;
+    prepareLayout(width: number, height: number): {
+        scale: number;
+        wMap: number;
+        hMap: number;
+        tx: number;
+        ty: number;
+    };
+    $_calcWMap(): number;
+    getPoint(id: string): MapCoord;
+    isVisible(coord: MapCoord): boolean;
+    isWorldMap(): boolean;
+    isScrollable(): boolean;
+    setZoom(value: number, duration?: number | AnimationOptions | (() => void)): void;
+    incZoom(delta: number): void;
+    _canSetZoom(value: number): boolean;
+    zoomTo(zoom: number, target: MapCoord, duration?: number): void;
+    zoomToArea(areaId: string, ratio?: number, duration?: number): void;
+    zoomToBounds(from: MapCoord, to: MapCoord, duration?: number): void;
+    focusTo(target: MapCoord, duration?: number): void;
+    $_moveTo(coords: MapCoord): void;
+    getAnnotations(): Annotation[];
+    getAnnotation(name: string): Annotation;
+    updateOption(prop: keyof BodyOptions, value: any, render?: boolean): this;
+    updateOptions(source?: BodyOptions, render?: boolean): this;
+    protected _doApply(options: BodyOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+    _getZoom(): number;
+}
+interface IMapChartEvents {
+    onModelChanged(chart: ChartObject, item: ChartItem, tag: any): void;
+    onMapChanged(chart: ChartObject, map: MapModel): void;
+    onProjectionChanged(chart: ChartObject, projection: MapProjection): void;
+    onZoomChanged(chart: ChartObject, oldZoom: number): void;
+    onRequestRender(chart: ChartObject, now: boolean): void;
+    onRequestShowSeries(chart: ChartObject, series: Series, visible: boolean): void;
+}
+declare class Credits extends ChartItem<CreditsOptions> {
+    static defaults: CreditsOptions;
+    isFloating(): boolean;
+}
+declare class ChartOptions extends ChartItem<ChartOptionsOptions> {
+    static defaults: ChartOptionsOptions;
+}
+declare class ChartObject extends RmEventProvider<IMapChartEvents> implements IChart, IMapOwner, IAnnotationOwner, ITooltipOwner, ISelectionOwner {
+    private static defaults;
+    _wrapper: any;
+    options: ChartConfiguration;
+    private _bases;
+    _templates: {
+        [key: string]: any;
+    };
+    _assets: AssetCollection;
+    private _chartOptions;
+    private _axis;
+    private _body;
+    _title: Title;
+    _subtitle: Subtitle;
+    _legend: Legend;
+    _zoomPanel: ZoomPanel;
+    _drilldownPanel: DrilldownPanel;
+    _credits: Credits;
+    _tooltip: Tooltip;
+    private _maps;
+    private _baseMap;
+    private _series;
+    _annotations: AnnotationCollection;
+    _colorScales: ColorScaleCollection;
+    _bubbleScales: BubbleScaleCollection;
+    _mapScale: MapScale;
+    private _selection;
+    _exporter: Exporter;
+    _loading: boolean;
+    private _point_shaes;
+    private _params;
+    _seriesIndex: number;
+    assignTemplates: (target: any) => any;
+    _dataDirty: boolean;
+    private _optionsLock;
+    _optionsDirty: boolean;
+    _loadAnimatable: boolean;
+    width: number;
+    height: number;
+    lockOptionsDirty(): void;
+    freeOptionsDirty(): void;
+    constructor(config?: ChartConfiguration, wrapper?: any);
+    private _initOptions;
+    get isGlobe(): boolean;
+    get selection(): MapSelection;
+    getFirstSeries(type: string): Series;
+    _getSeriesType(type: string): any;
+    _getAnnotationType(type: string): any;
+    _modelChanged(): void;
+    _optionChanged(item: ChartItem, tag?: any): void;
+    animatable(): boolean;
+    loadAnimatable(): boolean;
+    isVisible(coord: MapCoord): boolean;
+    requestShowSeries(series: Series, visible: boolean): void;
+    _selectionChanged(series: ISeries, p: DataPoint): void;
+    getNextPointShape(): Shape;
+    getProjection(second: boolean): MapProjection;
+    projectionChanged(): void;
+    zoomChanged(oldZoom: number): void;
+    mapChanged(map: MapModel): void;
+    anchorByName(name: string): ChartItem<ChartItemOptions>;
+    get chart(): IChart;
+    getTooltipContext(scope: TooltipScope, series: ISeries, point: DataPoint): ITooltipContext;
+    selectionChanged(selection: MapSelection): void;
+    selectionItemAdded(item: ISelectionSource): void;
+    selectionItemRemoved(item: ISelectionSource): void;
+    selectionCleared(): void;
+    get type(): "figure" | "map" | "feature" | "point" | "pin" | "vector" | "bar" | "line" | "pie" | "waffle" | "route" | "bubble" | "image" | "heatmap" | "panel" | "gauge" | "clock";
+    get chartOptions(): ChartOptions;
+    get legend(): Legend;
+    get credits(): Credits;
+    get map(): MapModel;
+    setBaseMap(indexOrName: number | string | MapModel): void;
+    get axis(): MapAxis;
+    get body(): Body;
+    get visibleSeries(): Series[];
+    get firstVisible(): Series;
+    get firstMapSeries(): MapSeries;
+    get colorScale(): ColorScale;
+    get bubbleScale(): BubbleScale;
+    get mapScale(): MapScale;
+    get isDirty(): boolean;
+    get isDrilldowned(): boolean;
+    getAnnotations(): Annotation[];
+    requestRender(now: boolean): void;
+    mapByName(name: string): MapModel;
+    mapAt(index: number): MapModel;
+    getMap(nameOrIndex: string | number): MapModel;
+    seriesByName(series: string): Series;
+    seriesByType(type: string): Series;
+    seriesAt(index: number): Series;
+    seriesByPoint(point: DataPoint): Series;
+    annotationByName(name: string): Annotation;
+    loadBase(source: any, model: string, type: string): any;
+    private _setProperties;
+    _load(config: ChartConfiguration): this;
+    private $_loadTemplates;
+    prepareRender(): void;
+    afterRender(): void;
+    update(options: ChartConfiguration, render: boolean): void;
+    export(options: ExportOptions): void;
+    _getLegendSources(): ILegendSource[];
+    getParam(target: any, param: string): any;
+    setParam(param: string, value: any, redraw?: boolean): ChartObject;
+    addSeries(source: any, animate: boolean): Series;
+    removeSeries(series: string | Series, animate: boolean): Series<SeriesOptions>;
+    _dataChanged(): void;
+    _isDataChanged(): boolean;
+    getColorScale(scale: string | number): ColorScale;
+    getBubbleScale(scale: string | number): BubbleScale;
+    drilldown(series: MapSeries, area: string): Promise<void>;
+    drillup(series?: MapSeries): Promise<void>;
+    _visibleChanged(item: ChartItem): void;
+    _hoverAreaChanged(series: Series, newArea: MapArea, oldArea: MapArea): void;
+    _areaClicked(series: Series, area: MapArea): void;
+}
+
+declare class RmTool<T extends RmControl = RmControl> {
+    private _control;
+    private _touchElement;
+    private _moveElement;
+    private _draggable;
+    private _dragTracker;
+    private _touchX;
+    private _touchY;
+    private _prevX;
+    private _prevY;
+    protected _touches: {
+        x: number;
+        y: number;
+        t: number;
+    }[];
+    protected _tapped: number;
+    private _firstTime;
+    private _secondTime;
+    private _longTimer;
+    protected _primaryId: number;
+    private _distance;
+    private _pinching;
+    constructor(control: T);
+    get control(): T;
+    get dragTracker(): DragTracker;
+    setDragTracker(value: DragTracker): void;
+    get dragging(): boolean;
+    touchX(): number;
+    touchY(): number;
+    pointerDown(ev: PointerEvent): boolean;
+    protected _stopEvent(ev: Event): void;
+    private $_doDrag;
+    private $_startMove;
+    pointerMove(ev: PointerEvent): void;
+    pointerUp(ev: PointerEvent): void;
+    pointerCancel(ev: PointerEvent): void;
+    pointerLeave(ev: PointerEvent): void;
+    touchStart(ev: TouchEvent): void;
+    touchMove(ev: TouchEvent): boolean;
+    protected _isPinchTarget(dom: Element): boolean;
+    protected _doPinch(dist: number): void;
+    touchEnd(ev: TouchEvent): void;
+    click(ev: PointerEvent): void;
+    dblClick(ev: PointerEvent): void;
+    keyPress(ev: KeyboardEvent): void;
+    wheel(ev: WheelEvent): void;
+    requestDrag(request: DragRequest): void;
+    getTrackerFromRequest(request: DragRequest): DragTracker;
+    protected _setDraggable(value: boolean): void;
+    protected _doClick(ev: PointerEvent): void;
+    protected _doDblClick(ev: PointerEvent): void;
+    protected _doPointerDown(ev: PointerEvent): boolean;
+    protected _doPointerMove(x: number, y: number, ev: PointerEvent): void;
+    protected _doPointerUp(ev: PointerEvent): boolean;
+    protected _doPointerCancel(ev: PointerEvent): void;
+    protected _doPointerLeave(ev: PointerEvent): void;
+    protected _doTouchStart(ev: TouchEvent, dom: Element): void;
+    protected _doTouchMove(ev: TouchEvent, dom: Element): boolean;
+    protected _doTouchEnd(ev: TouchEvent, dom: Element): void;
+    protected _doLongPressed(dom: Element, x: number, y: number): void;
+    protected _doKeyPress(ev: KeyboardEvent): void;
+    protected _doWheel(ev: WheelEvent): boolean;
+    protected _doSwipe(dom: Element, prevTracker: DragTracker, dir: RtDirection, duration: number, distance: number): boolean;
+    protected _getDragTracker(dom: Element, dx: number, dy: number): DragTracker;
+    private $_startDrag;
+    private $_drag;
+    private $_stopDragTracker;
+    private $_pointerToPoint;
+    private $_checkSwipe;
+    protected _clearTouchEffects(): void;
+    private $_getDistance;
+}
+declare abstract class DragRequest extends RmObject {
+}
+declare abstract class DragTracker<T extends RmControl = RmControl> extends RmObject {
+    private _control;
+    private _dragging;
+    constructor(control: T);
+    get control(): T;
+    get dragging(): boolean;
+    get startWhenCreated(): boolean;
+    get cursor(): string;
+    canSwipe(): boolean;
+    start(eventTarget: Element, xStart: number, yStart: number, x: number, y: number): boolean;
+    drag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
+    cancel(): void;
+    drop(eventTarget: HTMLElement, x: number, y: number): void;
+    swipe(dir: RtDirection, duration: number, distance: number): boolean;
+    end(x?: number, y?: number): void;
+    protected _doSwipe(dir: RtDirection, duration: number, distance: number): boolean;
+    protected _showFeedback(x: number, y: number): void;
+    protected _moveFeedback(x: number, y: number): void;
+    protected _hideFeedback(): void;
+    protected _doStart(eventTarget: Element, xStart: number, yStart: number, x: number, y: number): boolean;
+    protected abstract _doDrag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
+    protected _doCanceled(): void;
+    protected _canAccept(eventTarget: Element, x: number, y: number): boolean;
+    protected _doCompleted(eventTarget: Element, x: number, y: number): void;
+    protected _doEnded(x?: number, y?: number): void;
+}
+
+declare class GlobeSpinner extends DragTracker<ChartControl> {
+    protected _doDrag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
+}
+
+declare class MapScroller extends DragTracker<ChartControl> {
+    private _oldX;
+    private _oldY;
+    private _xStart;
+    private _yStart;
+    constructor(control: ChartControl);
+    protected _doStart(eventTarget: Element, xStart: number, yStart: number, x: number, y: number): boolean;
+    protected _doEnded(x?: number, y?: number): void;
+    protected _doDrag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
+    private $_mapView;
+}
+
+declare class MapTool extends RmTool<ChartControl> {
+    private _clickElement;
+    protected _doPointerDown(ev: PointerEvent): boolean;
+    protected _doPointerMove(x: number, y: number, ev: PointerEvent): void;
+    protected _doClick(ev: PointerEvent): void;
+    protected _doDblClick(ev: PointerEvent): void;
+    protected _doWheel(ev: WheelEvent): boolean;
+    protected _isPinchTarget(dom: Element): boolean;
+    protected _doPinch(dist: number): void;
+    protected _getDragTracker(dom: Element, dx: number, dy: number): GlobeSpinner | MapScroller;
+    private $_chart;
+    private $_chartView;
+}
+
+declare abstract class GroupElement extends RmElement {
+    private static IGNORE_ATTRS;
+    constructor(doc: Document, styleName?: string);
+    protected _movable(): boolean;
+    setAttr(attr: string, value: any): GroupElement;
+    protected _doInitChildren(doc: Document): void;
+}
+
+interface IRectShape extends IRect {
+    r?: number;
+    rx?: number;
+    ry?: number;
+    rLeft?: number;
+    rTop?: number;
+    rRight?: number;
+    rBottom?: number;
+}
+declare class RectElement extends RmElement {
+    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);
+    setBounds(x: number, y: number, width: number, height: number, r?: number): RectElement;
+    setRadius(value: number): void;
+    protected _setBackgroundBorderRadius(value: number): void;
+}
+
+declare abstract class ChartElement<T extends ChartItem = ChartItem> extends RmElement {
+    model: T;
+    protected options: ChartItemOptions;
+    mw: number;
+    mh: number;
+    _debugRect: RectElement;
+    constructor(doc: Document, styleName?: any);
+    chart(): IChart;
+    protected _prepareStyleOrClass(model: T): void;
+    setModel(model: T): void;
+    measure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
+    layout(param?: any): ChartElement<ChartItem>;
+    resizeByMeasured(): ChartElement<ChartItem>;
+    protected _getDebugRect(): IRect;
+    protected _doMeasure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(param: any): void;
+    protected _invalidate(): void;
+}
+declare abstract class BoundableElement<T extends ChartItem = ChartItem> extends ChartElement<T> {
+    protected _background: RectElement;
+    protected _margins: Sides;
+    protected _paddings: Sides;
+    constructor(doc: Document, styleName: string, backStyle: string);
+    protected _getDebugRect(): IRect;
+    measure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
+    layout(param?: any): ChartElement<ChartItem>;
+    protected abstract _setBackgroundStyle(back: RectElement): void;
+    protected _marginable(): boolean;
+    protected _resetBackBounds(): boolean;
+    protected _getBackOffset(): number;
+    protected _deflatePaddings(size: ISize): void;
+}
+declare abstract class SectionView extends GroupElement {
+    protected _inverted: boolean;
+    mw: number;
+    mh: number;
+    measure(doc: Document, chart: IChart, hintWidth: number, hintHeight: number): ISize;
+    resizeByMeasured(): SectionView;
+    layout(param?: any): SectionView;
+    layoutInner(width: number, height: number, param?: any): SectionView;
+    protected abstract _doMeasure(doc: Document, chart: IChart, hintWidth: number, hintHeight: number): ISize;
+    protected abstract _doLayout(param?: any): void;
+    protected abstract _doLayoutInner(width: number, height: number, param?: any): void;
+}
+declare abstract class ContentView<T extends ChartItem> extends ChartElement<T> {
+    protected _inverted: boolean;
+    protected _animatable: boolean;
+    protected _loadAnimatable: boolean;
+    _setChartOptions(inverted: boolean, animatable: boolean, loadAnimatable: boolean): void;
+}
+
+declare class LegendItemView extends ChartElement<LegendItem> {
+    _back: RectElement;
+    _marker: RmElement;
+    _label: TextElement;
+    _gap: number;
+    _rMarker: IRect;
+    _col: number;
+    constructor(doc: Document);
+    setMarker(elt: RmElement): RmElement;
+    protected _doMeasure(doc: Document, model: LegendItem, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(wMarker: number): void;
+}
+declare class LegendView extends BoundableElement<Legend> {
+    static readonly LEGEND_CLASS = "rm-legend";
+    private _itemViews;
+    private _vertical;
+    private _rowViews;
+    private _sizes;
+    private _wMarkers;
+    _gap: number;
+    _ipr: number;
+    constructor(doc: Document);
+    legendByDom(dom: Element): LegendItem;
+    legendOfSeries(series: Series): LegendItemView;
+    protected _setBackgroundStyle(back: RectElement): void;
+    protected _doMeasure(doc: Document, model: Legend, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(): void;
+    private $_prepareItems;
+    private $_measure;
+}
+
+interface IAnnotationAnchorOwner {
+    getAnnotationAnchor(model: any): RmElement;
+    tx: number;
+    ty: number;
+}
+declare abstract class AnnotationView<T extends Annotation = Annotation> extends BoundableElement<T> {
+    static readonly CLASS_NAME: string;
+    static register(...clses: [typeof Annotation<AnnotationOptions>, typeof AnnotationView<Annotation>][]): void;
+    protected options: AnnotationOptions;
+    constructor(doc: Document, styleName: string);
+    update(owner: IAnnotationAnchorOwner, hintWidth: number, hintHeight: number): void;
+    _layoutView(owner: IAnnotationAnchorOwner, x: number, y: number, w: number, h: number): void;
+    private _posByAnchor;
+    protected _marginable(): boolean;
+    protected _resetBackBounds(): boolean;
+    protected _setBackgroundStyle(back: RectElement): void;
+    protected _doLayout(p: IPoint): void;
+}
+
+declare class ColorScaleView extends ChartElement<ColorScale> {
+    static readonly SCALE_CLASS = "rm-color-scale";
+    static readonly SCALE_FILL = "rm-color-scale-fill";
+    private _vertical;
+    private _reversed;
+    private _fills;
+    private _barLayer;
+    private _bars;
+    private _splitLayer;
+    private _splits;
+    private _marker;
+    private _markerLabel;
+    private _tickLineLayer;
+    private _tickLabelLayer;
+    private _tickLines;
+    private _tickLabels;
+    private _gap;
+    private _markerSize;
+    private _labelSize;
+    private _tickLen;
+    private _tickLabelSize;
+    private _value;
+    constructor(doc: Document);
+    setValue(v: number): void;
+    protected _setBackgroundStyle(back: RectElement): void;
+    protected _doMeasure(doc: Document, model: ColorScale, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(): void;
+    private $_getFillId;
+    private $_getFillUrl;
+    private $_createGradient;
+    private $_setDir;
+    private $_fillStops;
+    private $_prepareBars;
+    private $_prepareSplits;
+    private $_prepareTickLines;
+    private $_prepareMarker;
+    private $_layoutSplits;
+    private $_layoutTickLines;
+    private $_resetMarker;
+}
+
+type Visitor<T extends RmElement> = (element: T, index?: number, count?: number) => void;
+declare class ElementPool<T extends RmElement> extends RmObject {
+    removeDelay: number;
+    private _owner;
+    private _creator;
+    private _pool;
+    private _views;
+    private _removes;
+    private _styleName;
+    constructor(owner: RmElement, 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;
+    prepare(count: number, visitor?: Visitor<T>, initor?: Visitor<T>): ElementPool<T>;
+    borrow(): T;
+    free(element: T, removeDelay?: number): void;
+    freeAll(elements: T[], removeDelay?: number): void;
+    clear(): void;
+    forEach(visitor: (v: T, i?: number, count?: number) => void): void;
+    visit(visitor: (v: T, i: number, count: number) => boolean): boolean;
+    find(visitor: (v: T) => boolean): T;
+    sort(compare: (v1: T, v2: T) => number): ElementPool<T>;
+    map(callback: (v: T) => any): any[];
+    setRemoveDelay(v: number): ElementPool<T>;
+    removeLater(v: RmElement, duration: number): void;
+    private $_create;
+    _getElementId(view: T): void;
+}
+
+declare class PathBuilder {
+    private _path;
+    clear(): PathBuilder;
+    end(close?: boolean): string;
+    close(): string;
+    move(x: number | IPoint, y?: number): PathBuilder;
+    moveBy(x: number | IPoint, y?: number): PathBuilder;
+    movep(x: number | IPoint, y?: number): PathBuilder;
+    line(x: number | IPoint, y?: number): PathBuilder;
+    linep(x: number | IPoint, y?: number): PathBuilder;
+    curve(cx1: number, cy1: number, cx2: number, cy2: number, x: number, y: number): PathBuilder;
+    q(x1: number, y1: number, x2: number, y2: number): PathBuilder;
+    rect(x: number, y: number, width: number, height: number): PathBuilder;
+    lines(...pts: (number | IPoint)[]): PathBuilder;
+    polygon(...pts: (number | IPoint)[]): PathBuilder;
+    circle(cx: number, cy: number, rd: number): PathBuilder;
+}
+
+type RmAnimationEndHandler = (ani: RmAnimation) => void;
+declare abstract class RmAnimation {
+    static readonly DURATION = 700;
+    static readonly SHORT_DURATION = 300;
+    delay: number;
+    duration: number;
+    easing: string;
+    endHandler: RmAnimationEndHandler;
+    private _easing;
+    private _started;
+    private _timer;
+    private _ani;
+    private _handler;
+    setDuration(value: number): RmAnimation;
+    start(endHandler?: RmAnimationEndHandler): RmAnimation;
+    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;
+}
+
+interface ILine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+declare class LineElement extends PathElement {
+    constructor(doc: Document, styleName?: string, line?: ILine);
+    setLine(x1: ILine | number, y1?: number, x2?: number, y2?: number): void;
+    setVLine(x: number, y1: number, y2: number): void;
+    setVLineC(x: number, y1: number, y2: number): void;
+    setHLine(y: number, x1: number, x2: number): void;
+    setHLineC(y: number, x1: number, x2: number): void;
+}
+
+type ShapeDrawer = (rd: number, rd2: number) => (string | number)[];
+
+declare class ImageElement extends RmElement {
+    private _dirty;
+    private _bounds;
+    private _proxy;
+    onloadProxy: () => void;
+    constructor(doc: Document, full: boolean, styleName?: string);
+    get url(): string;
+    set url(value: string);
+    setImage(url: string, width: number, height: number): boolean;
+    bbox(): IRect;
+}
+
+declare class LabelElement extends GroupElement {
+    private _back;
+    _outline: TextElement;
+    _text: TextElement;
+    _icon: ImageElement;
+    private _model;
+    private _box;
+    constructor(doc: Document, styleName: string);
+    setText(s: string): LabelElement;
+    setModel(doc: Document, model: IconedText, icon: string, contrastTarget: Element): LabelElement;
+    setContrast(target: Element): LabelElement;
+    layout(): LabelElement;
+    bbox(): IRect;
+}
+
+declare class HoverAnimation extends RmAnimation {
+    private _series;
+    _focused: boolean;
+    _marker: MarkerSeriesPointView;
+    constructor(sv: SeriesView<Series>, marker: MarkerSeriesPointView, focused: boolean, endHandler: RmAnimationEndHandler);
+    protected _doStart(): void;
+    protected _doUpdate(rate: number): boolean;
+    protected _doStop(): void;
+}
+interface IPointView {
+    point: DataPoint;
+    tooltipColor(): string;
+    tooltipPos?(): IPoint;
+    saveStyles(): void;
+    restoreStyles(): void;
+}
+declare class PointViewPool<T extends RmElement & IPointView> extends ElementPool<T> {
+    constructor(owner: RmElement, creator: {
+        new (doc: Document, group?: boolean): T;
+    });
+    _getElementId(view: T): number;
+}
+declare class PointLabelView extends LabelElement {
+    point: DataPoint;
+    constructor(doc: Document);
+}
+declare class PointLabelContainer extends LayerElement {
+    private _labels;
+    private _maps;
+    constructor(doc: Document, styleName: string);
+    isEmpty(): boolean;
+    clear(): void;
+    private $_prepareLabel;
+    prepare(doc: Document, owner: SeriesView): void;
+    get(point: DataPoint, index: number): PointLabelView;
+    removePoint(p: DataPoint, delay: number): void;
+}
+declare class PointCalloutView extends GroupElement {
+    private _line;
+    private _dummy;
+    private _anchor;
+    point: DataPoint;
+    index: number;
+    constructor(doc: Document);
+    render(model: DataPointCallout, point: DataPoint, coords: number[], pointColor: string): this;
+    setColor(color: string): this;
+}
+declare class CalloutMaskView extends MaskElement {
+    private _back;
+    private _mask;
+    constructor(doc: Document);
+    setBackground(r: IRect): this;
+    setCircle(cx: number, cy: number, rd: number): this;
+    setRects(r1: IRect, r2?: IRect): this;
+}
+declare class PointCalloutContainer extends LayerElement {
+    private _maskLayer;
+    private _masks;
+    private _callouts;
+    private _map;
+    constructor(doc: Document, styleName: string);
+    isEmpty(): boolean;
+    clear(): void;
+    prepare(doc: Document, owner: SeriesView): void;
+    get(point: DataPoint): PointCalloutView;
+    setMask(cv: PointCalloutView, pts: number[]): CalloutMaskView;
+}
+declare abstract class PointElement<T extends DataPoint = DataPoint> extends PathElementEx implements IPointView {
+    point: T;
+    constructor(doc: Document, group?: boolean);
+    tooltipColor(): string;
+    protected _drawSpline(pts: {
+        x: number;
+        y: number;
+    }[], start: number, end: number, sb: PathBuilder): void;
+}
+declare class PointContainer extends LayerElement {
+}
+type PointPositioner = (x: number, y: number, wPoint: number, hPoint: number) => IPoint;
+type LabelPositioner = (x: number, y: number, rLabel: IRect, wPoint: number, hPoint: number, off: number) => IPoint;
+declare abstract class SeriesView<T extends Series = Series> extends ContentView<T> {
+    static readonly POINT_CLASS = "rm-point";
+    static readonly DATA_HOVER = "hover";
+    static readonly DATA_UNHOVER = "unhover";
+    static readonly LEGEND_MARKER = "rm-legend-item-marker";
+    static register(...clses: [typeof Series<SeriesOptions>, typeof SeriesView<Series>][]): void;
+    static seriesOf(pv: RmElement): SeriesView;
+    private static _createDrawers;
+    private static _drawers;
+    static getDrawer(shape: string): ShapeDrawer;
+    protected _pointPositioner: {
+        [pos: string]: PointPositioner;
+    };
+    protected _labelPositioner: {
+        [pos: string]: LabelPositioner;
+    };
+    _second: boolean;
+    _pointLayer: LayerElement;
+    _pointContainer: PointContainer;
+    _calloutContainer: PointCalloutContainer;
+    _labelContainer: PointLabelContainer;
+    protected _visPoints: DataPoint[];
+    private _growRate;
+    private _posRate;
+    protected _prevRate: number;
+    _animations: Animation[];
+    _hoverAnis: HoverAnimation[];
+    _hoverPts: IPointView[];
+    protected _wBody: number;
+    protected _hBody: number;
+    _scale: number;
+    protected _scaler: (coord: MapCoord) => MapCoord;
+    _aniOpacity: number;
+    constructor(doc: Document, className: string, needLabels?: boolean);
+    protected _setCalcedColor(model: T, dom: Element): void;
+    protected _setModelColor(color: string): void;
+    prepare(doc: Document, model: T): void;
+    prepareLayout(doc: Document): void;
+    render(wBody: number, hBody: number): void;
+    reset(): void;
+    isPointLabelVisible(p: DataPoint): boolean;
+    isPointCalloutVisible(p: DataPoint): boolean;
+    setScaler(scaler: (coord: MapCoord) => MapCoord): void;
+    getPointView(dom: Element): IPointView;
+    pointerMoved(x: number, y: number, dom: Element): boolean;
+    setHoverStyle(pv: RmElement): void;
+    defaultAnimation(): string;
+    setGrowRate(rate: number): void;
+    setPosRate(rate: number): void;
+    setPrevRate(rate: number): void;
+    pointByDom(elt: Element): IPointView;
+    click(elt: Element): void;
+    select(elt: Element, clear: boolean): void;
+    toggleSelect(elt: Element): void;
+    runPointAddAnimation(p: DataPoint): void;
+    protected abstract _doPrepeare(doc: Document, model: T, dataDirty: boolean): void;
+    protected abstract _doRender(width: number, height: number): void;
+    protected abstract _doReset(): void;
+    _animating(): boolean;
+    protected _getPointPositioner(pos: PointViewPosition, autoPos: string): PointPositioner;
+    protected _getLabelPositioner(pos: PointLabelPosition, autoPos: string): LabelPositioner;
+    protected _labelViews(): PointLabelContainer;
+    protected _calloutViews(): PointCalloutContainer;
+    protected _getPointPool(): PointViewPool<PointElement>;
+    protected _collectVisPoints(model: T): DataPoint[];
+    protected _setPointColor(v: RmElement, color: string): void;
+    protected _setPointStyle(v: RmElement, model: T, p: DataPoint): void;
+    protected _doPointerMoved(x: number, y: number, dom: Element): boolean;
+    protected _getGrowRate(): number;
+    protected _doViewRateChanged(rate: number): void;
+    protected _doPosRateChanged(rate: number): void;
+    protected _doPrevRateChanged(rate: number): void;
+    protected _getShowAnimation(): RmAnimation;
+    protected _runShowEffect(firstTime: boolean): void;
+    _animationStarted(ani: Animation): void;
+    _animationFinished(ani: Animation): void;
+    protected _layoutLabel(lv: PointLabelView, parent: Element): PointLabelView;
+    protected _legendColorProp(): string;
+    protected _legendColorProp2(): string;
+    protected _doPointClicked(view: IPointView): void;
+}
+declare abstract class MarkerSeriesPointView<T extends MarkerSeriesPoint = MarkerSeriesPoint> extends PointElement<T> implements IPointView {
+    beginHover(series: SeriesView, focused: boolean): void;
+    setHoverRate(series: SeriesView, focused: boolean, rate: number): void;
+    endHover(series: SeriesView, focused: boolean): void;
+    distance(rd: number, x: number, y: number): number;
+}
+declare abstract class MarkerSeriesView<T extends MarkerSeries = MarkerSeries> extends SeriesView<T> {
+    protected _markers: PointViewPool<MarkerSeriesPointView<MarkerSeriesPoint>>;
+    constructor(doc: Document, styleName: string);
+    protected abstract _createMarkers(container: RmElement): PointViewPool<MarkerSeriesPointView<MarkerSeriesPoint>>;
+    getHintDistance(): number;
+    protected _getPointPool(): PointViewPool<PointElement>;
+}
+
+interface IBodyViewOwner {
+    showTooltip(series: Series, pv: IPointView, map: RmElement, p: IPoint): void;
+    hideTooltip(): void;
+    tooltipVisible(): boolean;
+    getScaleView(scale: ColorScale): ColorScaleView;
+}
+declare class BodyView extends ChartElement<Body> implements IAnnotationAnchorOwner {
+    private _owner;
+    private _back;
+    private _mapBack;
+    private _contentLayer;
+    private _axisGuideContainer;
+    private _secondAxisGuideContainer;
+    private _seriesContainer;
+    private _secondContainer;
+    private _annotationContainer;
+    private _frontAnnotationContainer;
+    _annotationViews: AnnotationView<Annotation>[];
+    private _annotationMap;
+    private _annotations;
+    private _frontAxisGuideContainer;
+    private _secondFrontAxisGuideContainer;
+    private _crosshairView;
+    private _clip;
+    private _clipMap;
+    private _requestShow;
+    private _transformInfo;
+    private _mousePos;
+    private _prevPrj;
+    constructor(doc: Document, owner: IBodyViewOwner);
+    getAnnotationAnchor(model: any): RmElement;
+    get transformInfo(): IBodyTransform;
+    get isProjectionChanged(): boolean;
+    getSeries(series: Series): SeriesView<Series<SeriesOptions>>;
+    canScroll(): boolean;
+    prepare(doc: Document, model: Body): void;
+    protected _doMeasure(doc: Document, model: Body, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(param: any): void;
+    afterRender(): void;
+    clean(): void;
+    reset(): void;
+    getTooltipPos(): IPoint;
+    pointerMoved(x: number, y: number, target: EventTarget): boolean;
+    seriesByDom(dom: Element): SeriesView;
+    showSeries(series: Series): void;
+    hideSeries(series: Series): void;
+    private pointToMap;
+    private $_prepareMeasureSeries;
+    private $_prepareLayoutSeries;
+    private $_prepareAnnotations;
+    private $_layoutAnnotations;
+    private $_layoutAxisGuides;
+    private $_doClipPathLayout;
+}
+
+declare class TitleView extends BoundableElement<Title> {
+    isSub: boolean;
+    static readonly TITLE_CLASS = "rm-title";
+    static readonly SUBTITLE_CLASS = "rm-subtitle";
+    private _textView;
+    private _richText;
+    constructor(doc: Document, isSub: boolean);
+    protected _marginable(): boolean;
+    protected _setBackgroundStyle(back: RectElement): void;
+    protected _doMeasure(doc: Document, model: Title, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(): void;
+}
+
+declare class ButtonElement extends RmElement {
+    static readonly STYLE = "rm-button";
+    static readonly BACK_STYLE = "rm-button-background";
+    private _back;
+    private _textView;
+    constructor(doc: Document, text: string, style?: string);
+    get text(): string;
+    setText(text: string): void;
+    layout(sz?: ISize, style?: SVGStyleOrClass): void;
+    click(): boolean;
+    setVisible(value: boolean): boolean;
+}
+
+declare class PanelButtonView extends ButtonElement {
+    callback: () => void;
+    constructor(doc: Document, text: string, callback: () => void);
+    click(): boolean;
+}
+declare abstract class BodyPanelView<T extends BodyPanel = BodyPanel> extends ChartElement<T> {
+}
+
+declare class DrilldownPanelView extends BodyPanelView<DrilldownPanel> {
+    private _btnBack;
+    private _textViews;
+    private _seperators;
+    private _history;
+    constructor(doc: Document);
+    getButton(dom: Element): PanelButtonView;
+    click(dom: Element): boolean;
+    protected _doMeasure(doc: Document, model: DrilldownPanel, hintWidth: number, hintHeight: number): ISize;
+    protected _doLayout(param: any): void;
+}
+
+declare class CreditView extends ChartElement<Credits> {
+    private _textView;
+    constructor(doc: Document);
+    click(dom: Element): void;
+    protected _doMeasure(doc: Document, model: Credits, intWidth: number, hintHeight: number): ISize;
+}
+declare class ChartView extends LayerElement implements IAnnotationAnchorOwner {
+    private _model;
+    private _annotationContainer;
+    private _bodyView;
+    private _titleSectionView;
+    private _scaleLayer;
+    private _colorScaleMap;
+    private _bubbleScaleMap;
+    private _legendSectionView;
+    private _frontAnnotationContainer;
+    private _annotationViews;
+    private _annotationMap;
+    private _annotations;
+    private _zoomPanelView;
+    private _drilldownPanelView;
+    private _mapScaleView;
+    private _creditView;
+    private _tooltipView;
+    constructor(doc: Document);
+    getAnnotationAnchor(model: any): RmElement;
+    titleView(): TitleView;
+    subtitleView(): TitleView;
+    legendView(): LegendView;
+    bodyView(): BodyView;
+    drilldownPanelView(): DrilldownPanelView;
+    measure(doc: Document, m: ChartObject, hintWidth: number, hintHeight: number): void;
+    layout(): void;
+    showTooltip(series: Series, pv: IPointView, map: BodyView, p: IPoint): void;
+    tooltipVisible(): boolean;
+    hideTooltip(): void;
+    clean(): void;
+    reset(): void;
+    legendByDom(dom: Element): LegendItem;
+    seriesByDom(dom: Element): SeriesView;
+    creditByDom(dom: Element): CreditView;
+    getScaleView(scale: ColorScale): ColorScaleView;
+    pointerMoved(x: number, y: number, target: EventTarget): void;
+    getButton(dom: Element): ButtonElement;
+    buttonClicked(button: ButtonElement): void;
+    updateAnnotation(anno: Annotation): void;
+    isAnimating(): void;
+    private $_prepareAnnotations;
+    private $_layoutAnnotations;
+    private $_layoutPanel;
+}
+
+declare class ChartControl extends RmControl implements IMapChartEvents {
+    private _chart;
+    private _chartView;
+    constructor(doc: Document, container: string | HTMLDivElement);
+    protected _initControl(document: Document, container: string | HTMLDivElement, className: string): void;
+    onModelChanged(chart: ChartObject, item: ChartItem<ChartItemOptions>, tag: any): void;
+    onProjectionChanged(chart: ChartObject, projection: MapProjection): void;
+    onMapChanged(chart: ChartObject, map: MapModel): void;
+    onZoomChanged(chart: ChartObject, oldZoom: number): void;
+    onPointAdded(chart: ChartObject, series: Series, p: DataPoint, animate: boolean): void;
+    onRequestRender(chart: ChartObject, now: boolean): void;
+    onRequestShowSeries(chart: ChartObject, series: Series, visible: boolean): void;
+    onExportRequest(chart: ChartObject, options: ExportOptions): void;
+    get chart(): MapChart;
+    set chart(value: MapChart);
+    get model(): ChartObject;
+    changeModel(model: ChartObject, oldModel: ChartObject): void;
+    chartView(): ChartView;
+    refresh(): void;
+    use(_module: any): void;
+    protected _creatDefaultTool(): MapTool;
+    protected _doBeforeRender(root: RmElement): void;
+    protected _doRender(bounds: IRect): void;
+    protected _doAfterRender(): void;
+    private _loadModules;
+    private _export;
+}
+
+declare abstract class RmControl extends RmObject {
+    static readonly CLASS_NAME = "rm-control";
+    static readonly SHADOW_FILTER = "rm-shadow-filter";
+    private _activeTool;
+    private _container;
+    private _dom;
+    private _htmlRoot;
+    private _debugger;
+    private _svg;
+    private _defs;
+    private _root;
+    private _inited;
+    private _testing;
+    private _dirty;
+    private _requestTimer;
+    private _defaultTool;
+    private _tool;
+    private _invalidElements;
+    private _toAnimation;
+    private _invalidateLock;
+    private _lockDirty;
+    private _cssVars;
+    loaded: boolean;
+    _padding: ISides;
+    _scrolling: boolean;
+    constructor(doc: Document, container: string | HTMLDivElement, className?: string);
+    protected _doDestory(): void;
+    isInited(): boolean;
+    isTesting(): boolean;
+    doc(): Document;
+    dom(): HTMLElement;
+    width(): number;
+    height(): number;
+    contentWidth(): number;
+    contentHeight(): number;
+    contentRight(): number;
+    clipContainer(): SVGElement;
+    activeTool(): RmTool<ChartControl>;
+    setSctiveTool(value: RmTool<ChartControl>): void;
+    clearDefs(): void;
+    private $_clearDefs;
+    clearAssetDefs(): void;
+    clearTemporaryDefs(): void;
+    appendDom<T extends HTMLElement>(elt: T): T;
+    addElement<T extends RmElement>(elt: T): T;
+    removeElement(elt: RmElement): void;
+    invalidate(force?: boolean): void;
+    invalidateLayout(force?: boolean): void;
+    setLock(): void;
+    releaseLock(validate?: boolean): void;
+    lock(func: (control: RmControl) => void): void;
+    silentLock(func: (control: RmControl) => void): void;
+    getBounds(): DOMRect;
+    setAnimation(to?: number): void;
+    fling(distance: number, duration: number): void;
+    getCssVar(name: string): string;
+    addDef(element: Element): void;
+    removeDef(element: Element | string): void;
+    clipBounds(x?: number, y?: number, width?: number, height?: number, rd?: number): ClipRectElement;
+    clip<T extends ClipElement>(clip: T): T;
+    protected _setTesting(): void;
+    protected _setSize(w: number, h: number): void;
+    private $_addListener;
+    protected _resigterEventHandlers(dom: HTMLElement): void;
+    protected _unresigterEventHandlers(dom: HTMLElement): void;
+    protected abstract _creatDefaultTool(): RmTool<ChartControl>;
+    protected _prepareRenderers(dom: HTMLElement): void;
+    protected _initControl(document: Document, container: string | HTMLDivElement, className: string): void;
+    protected _initDefs(doc: Document, defs: SVGElement): void;
+    protected _render(): void;
+    private $_requestRender;
+    updateNow(): void;
+    private $_render;
+    protected _setBackgroundStyle(style: CSSStyleDeclaration): void;
+    setDebug(message: any): void;
+    protected abstract _doRender(bounds: IRect): void;
+    protected _doBeforeRender(root: RmElement): void;
+    protected _doAfterRender(): void;
+    protected _doClick(event: PointerEvent): void;
+    protected _doDblClick(event: PointerEvent): void;
+    protected _doTouchStart(event: TouchEvent): void;
+    protected _doTouchMove(event: TouchEvent): boolean;
+    protected _doTouchEnd(event: TouchEvent): void;
+    protected _doPointerDown(event: PointerEvent): boolean;
+    protected _doPointerMove(event: PointerEvent): void;
+    protected _doPointerUp(event: PointerEvent): void;
+    protected _doPointerCancel(event: PointerEvent): void;
+    protected _doPointerLeave(event: PointerEvent): void;
+    protected _doKeyPress(event: KeyboardEvent): void;
+    protected _doWheel(event: WheelEvent): void;
+    protected _windowResizeHandler: (event: Event) => void;
+    protected _windowResized(): void;
+    private _clickHandler;
+    private _dblClickHandler;
+    private _touchStartHandler;
+    private _touchMoveHandler;
+    private _touchEndHandler;
+    private _pointerDownHandler;
+    private _pointerMoveHandler;
+    private _pointerUpHandler;
+    private _pointerCancelHandler;
+    private _pointerLeaveHandler;
+    private _keyPressHandler;
+    private _wheelHandler;
+}
+declare class RmElement extends RmObject {
+    static TESTING: boolean;
+    static DEBUGGING: boolean;
+    static ASSET_KEY: string;
+    static TEMP_KEY: string;
+    static shrink(elts: RmElement[], count: number): void;
+    static expand<T extends RmElement>(parent: RmElement, elts: T[], count: number, creator: () => T): void;
+    static fit<T extends RmElement>(doc: Document, parent: RmElement, elts: T[], count: number, creator: {
+        new (doc: Document, styleName?: string): T;
+    }, styleName: string): void;
+    private _visible;
+    private _x;
+    private _y;
+    private _width;
+    private _height;
+    private _zIndex;
+    private _tx;
+    private _ty;
+    private _scaleX;
+    private _scaleY;
+    private _rotation;
+    private _originX;
+    private _originY;
+    private _matrix;
+    protected _styleName: string;
+    protected _styles: any;
+    protected _styleDirty: boolean;
+    private _dom;
+    private _parent;
+    removing: boolean;
+    constructor(doc: Document, styleName: string, tag?: string);
+    protected _doInitStyles(): void;
+    protected _doDestory(): void;
+    get doc(): Document;
+    get dom(): SVGElement;
+    get parent(): RmElement;
+    get control(): RmControl;
+    get zIndex(): number;
+    set zIndex(value: number);
+    get x(): number;
+    set x(value: number);
+    get tx(): number;
+    get y(): number;
+    set y(value: number);
+    get ty(): number;
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    setVisible(value: boolean): boolean;
+    get rotation(): number;
+    set rotation(value: number);
+    setRotation(originX: number, originY: number, rotation: number): RmElement;
+    getStyle(prop: string): string;
+    hasStyle(className: string): boolean;
+    containsDom(dom: Element): boolean;
+    addDom(dom: SVGElement): SVGElement;
+    add<T extends RmElement>(child: T): T;
+    addAll(...children: RmElement[]): void;
+    insertChild<T extends RmElement>(child: T, before: RmElement): T;
+    insertFirst<T extends RmElement>(child: T): T;
+    removeChild(child: RmElement): void;
+    remove(): RmElement;
+    appendElement(doc: Document, tag: string): SVGElement;
+    insertElement(doc: Document, tag: string, before: Node): SVGElement;
+    moveToLast(child: RmElement): void;
+    getAttr(attr: string): any;
+    setAttr(attr: string, value: any): RmElement;
+    hasAttr(attr: string): boolean;
+    setAttrEx(attr: string, value: any): RmElement;
+    setAttrs(attrs: any): RmElement;
+    unsetAttr(attr: string): RmElement;
+    getBounds(): DOMRect;
+    setBounds(x: number, y: number, width: number, height: number): RmElement;
+    setRect(rect: IRect): RmElement;
+    getRect(): IRect;
+    getSize(): ISize;
+    bbox(): IRect;
+    move(x: number, y: number): RmElement;
+    scale(value: number, yValue?: number): this;
+    trans(x: number, y: number): RmElement;
+    transp(p: IPoint): RmElement;
+    transEx(x: number, y: number, duration?: number, invalidate?: boolean): RmElement;
+    transX(x: number): RmElement;
+    transY(y: number): RmElement;
+    resize(width: number, height: number, attr?: boolean): boolean;
+    appendDom(dom: Node): Node;
+    insertDom(dom: Node, before: Node): Node;
+    clearDom(): void;
+    private _saveStyle;
+    private _saveClass;
+    saveStyles(): void;
+    restoreStyles(): void;
+    internalClearStyles(): void;
+    clearStyles(): boolean;
+    clearStyle(props: string[]): boolean;
+    internalSetStyles(styles: any): void;
+    internalImportantStylesOrClass(style: any): void;
+    setStyles(styles: SVGStyles): boolean;
+    resetStyles(styles: any): boolean;
+    protected _resetClass(): void;
+    setClass(className: string): void;
+    clearStyleAndClass(): void;
+    internalClearStyleAndClass(): void;
+    setStyleOrClass(style: SVGStyleOrClass): void;
+    internalSetStyleOrClass(style: SVGStyleOrClass): void;
+    internalResetStyleOrClass(style: SVGStyleOrClass): void;
+    protected _setBackgroundBorderRadius(value: number): void;
+    setBackStyles(styles: any): boolean;
+    setStyle(prop: string, value: string): boolean;
+    internalSetStyle(prop: string, value: string): void;
+    internalSetImportantStyle(prop: string, value: string): void;
+    setBackStyle(prop: string, value: string): boolean;
+    putStyles(styles: any, buff?: any): any;
+    putStyle(prop: string, value: string, buff?: any): any;
+    setColor(color: string): this;
+    getFill(): any;
+    getStroke(): any;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setTransparent(important: boolean): void;
+    textAlign(): Align;
+    setData(data: string, value?: string): void;
+    unsetData(data: string): void;
+    setBoolData(data: string, value: boolean): void;
+    hasData(data: string): boolean;
+    removeLater(delay: number, callback?: (v: RmElement) => void): RmElement;
+    hide(delay: number): RmElement;
+    ignorePointer(): void;
+    invalidate(): void;
+    rotate(angle: number): RmElement;
+    internalRotate(angle: number): void;
+    setCursor(cursor: string): void;
+    clipRect(x: number, y: number, width: number, height: number, rd?: number): ClipRectElement;
+    clipPath(path: Path): ClipPathElement;
+    attachClipPath(clipId: string): void;
+    detachClipPath(): void;
+    private $_setClip;
+    private createClipId;
+    sort(children: RmElement[]): void;
+    getParent<T extends RmElement>(type: {
+        new (): T;
+    }): T;
+    protected _testing(): boolean;
+    protected _doAttached(parent: RmElement): void;
+    protected _doDetached(parent: RmElement): void;
+    protected _updateTransform(): void;
+}
+declare class LayerElement extends RmElement {
+    constructor(doc: Document, styleName?: any);
+}
+declare class PathElement extends RmElement {
+    _userData: any;
+    private _path;
+    constructor(doc: Document, styleName?: string, path?: Path);
+    path(): string;
+    setPath(path: Path): PathElement;
+}
+declare class PathElementEx extends RmElement {
+    group: boolean;
+    _userData: any;
+    private _path;
+    constructor(doc: Document, styleName: string, group?: boolean);
+    path(): string;
+    setPath(path: Path): PathElementEx;
+}
+declare class MaskElement extends RmElement {
+    private _id;
+    constructor(doc: Document);
+    get id(): string;
+}
+declare class ClipElement extends RmElement {
+    private _id;
+    constructor(doc: Document);
+    get id(): string;
+}
+declare class ClipRectElement extends ClipElement {
+    private _rect;
+    constructor(doc: Document, x?: number, y?: number, width?: number, height?: number, rx?: number, ry?: number);
+    setBounds(x: number, y: number, w: number, h: number): RmElement;
+    resize(width: number, height: number, attr?: boolean): boolean;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+}
+declare class ClipPathElement extends ClipElement {
+    private _path;
+    constructor(doc: Document, path?: Path);
+    get path(): PathElement;
+    setPath(path: Path): this;
+}
+
+declare enum TextAnchor {
+    START = "start",
+    MIDDLE = "middle",
+    END = "end"
+}
+declare enum TextLayout {
+    TOP = "top",
+    MIDDLE = "middle",
+    BOTTOM = "bottom"
+}
+declare class TextElement extends RmElement {
+    private _layout;
+    private _dirty;
+    private _text;
+    private _bounds;
+    _lineCount: number;
+    constructor(doc: Document, styleName?: string);
+    get text(): string;
+    set text(value: string);
+    get anchor(): TextAnchor;
+    set anchor(value: TextAnchor);
+    get layout(): TextLayout;
+    set layout(value: TextLayout);
+    get svg(): string;
+    set svg(value: string);
+    get opacity(): number;
+    set opacity(value: number);
+    getAscent(height: number): number;
+    layoutText(lineHeight?: number): void;
+    isFitIn(bounds: number): boolean;
+    calcWidth(): number;
+    calcRangeWidth(start?: number, end?: number): number;
+    truncate(bounds: number, ellipsis: boolean): void;
+    setContrast(target: Element, darkStyle: SVGStyleOrClass, brightStyle: SVGStyleOrClass): TextElement;
+    clearDom(): void;
+    setStyles(styles: any): boolean;
+    setStyle(prop: string, value: string): boolean;
+    bbox(): IRect;
+    getBBoundsTest(): IRect;
+    stain(): void;
+}
+
+type RichTextParamCallback = (target: any, param: string) => any;
+interface IRichTextDomain {
+    callback?: RichTextParamCallback;
+    numberFormatter?: NumberFormatter;
+    timeFormatter?: DatetimeFormatter;
+    textFormatter?: TextFormatter;
+    startOfWeek?: number;
+}
+declare class Word {
+    text: string;
+    private _literals;
+    tag(): string;
+    parse(str: string): Word;
+    getText(target: any, domain: IRichTextDomain): string;
+    prepareSpan(span: SVGTSpanElement, target: any, domain: IRichTextDomain): SVGTSpanElement;
+    protected _doParse(str: string): Word;
+}
+declare class SvgLine {
+    private _words;
+    get words(): Word[];
+    parse(s: string): SvgLine;
+}
+declare class SvgRichText {
+    _format: string;
+    lineHeight: number;
+    private _lines;
+    constructor(format?: string);
+    setFormat(value: string): void;
+    lines(): SvgLine[];
+    build(view: TextElement, maxWidth: number, maxHeight: number, target: any, domain: IRichTextDomain): void;
+    layout(tv: TextElement, align: Align, width: number, height: number, pad: Sides): void;
+    $_parse(fmt: string): void;
+}
+
+declare class DataPointLabel<OP extends DataPointLabelOptions = DataPointLabelOptions> extends IconedText<OP> {
+    static defaults: DataPointLabelOptions;
+    private _point;
+    _domain: IRichTextDomain;
+    getValue(p: DataPoint, index: number): any;
+    getTextDomain(p: DataPoint): IRichTextDomain;
+    getText(value: any): string;
+    isVisible(): boolean;
+    getDefaultIconPos(): IconPosition;
+    protected _doSetSimple(src: any): boolean;
+    protected _doPrepareRender(chart: IChart): void;
+}
+declare class DataPointAnchorPoint<OP extends CalloutAnchorPointOptions = CalloutAnchorPointOptions> extends ChartItem<OP> {
+    static defaults: CalloutAnchorPointOptions;
+}
+declare class DataPointCallout<OP extends DataPointCalloutOptions = DataPointCalloutOptions> extends ChartItem<OP> {
+    series: Series;
+    static defaults: DataPointCalloutOptions;
+    constructor(series: Series);
+    private _anchorPoint;
+    protected _doInit(op: OP): void;
+    get anchorPoint(): DataPointAnchorPoint<CalloutAnchorPointOptions>;
+}
+interface ISeries<T extends DataPoint = DataPoint> {
+    options: SeriesOptions;
+    chart: IChart;
+    color?: Color;
+    _idFielder: (src: any) => any;
+    _nameFielder?: (src: any) => string;
+    _valueFielder?: (src: any) => any;
+    _tupleFielder?: (src: any) => any[];
+    _lonFielder?: (src: any) => number;
+    _latFielder?: (src: any) => number;
+    _valuesFielder?: (src: any) => any[];
+    _colorFielder: (src: any) => string;
+    initPoints(source: any[]): T[];
+    followTooltipPointer(): boolean;
+    getValueRange?(): {
+        min: number;
+        max: number;
+    };
+    select(p: ISelectionSource): void;
+    unselect(p: ISelectionSource): void;
+}
+declare abstract class Series<OP extends SeriesOptions = SeriesOptions> extends ChartItem<OP> implements ILegendSource, ITooltipContext {
+    static readonly type: string;
+    static register(...clses: typeof Series<SeriesOptions>[]): void;
+    static defaults: SeriesOptions;
+    static getPointTooltipParam(series: Series, point: DataPoint, param: string): any;
+    private _data;
+    private _name;
+    index: number;
+    seriesIndex: number;
+    protected _map: MapModel;
+    protected _mapChanged: boolean;
+    protected _points: DataPointCollection;
+    private _pointLabel;
+    private _callout;
+    _optionsDirty: boolean;
+    _dataSourceDirty: boolean;
+    _zindexDirty: boolean;
+    _maxZindex: number;
+    _runPoints: DataPoint[];
+    _visPoints: DataPoint[];
+    _idFielder: (src: any) => any;
+    _lonFielder: (src: any) => any;
+    _latFielder: (src: any) => any;
+    _nameFielder: (src: any) => string;
+    _valueFielder: (src: any) => any;
+    _colorFielder: (src: any) => string;
+    _runColor: string;
+    _calcedColor: string;
+    private _legendMarker;
+    private _pointLabelCallback;
+    protected _pointArgs: DataPointCallbackArgs;
+    private _argsPoint;
+    private _loaded;
+    ani: RmAnimation;
+    constructor(chart: IChart);
+    protected _doInit(op: SeriesOptions): void;
+    protected _createLabel(chart: IChart): DataPointLabel;
+    getTooltipText(series: ISeries, point: DataPoint): string;
+    getTooltipParam(series: ISeries, point: DataPoint, param: string): any;
+    canHide(): boolean;
+    legendMarker(doc: Document, size: number): RmElement;
+    legendColor(): string;
+    legendLabel(): string;
+    _type(): string;
+    get name(): string;
+    get pointLabel(): DataPointLabel<DataPointLabelOptions>;
+    get map(): MapModel;
+    get callout(): DataPointCallout<DataPointCalloutOptions>;
+    displayName(): string;
+    get data(): any;
+    setData(value: any): void;
+    get pointCount(): number;
+    followTooltipPointer(): boolean;
+    isDataSeries(): boolean;
+    getDetailed(): Series;
+    needMapScale(): boolean;
+    contains(p: DataPoint): boolean;
+    initPoints(source: any[]): DataPoint[];
+    getPoint(index: number): DataPoint;
+    getPointText(p: DataPoint, index: number, label: any): string;
+    getPointCallbackArgs(p: DataPoint): DataPointCallbackArgs;
+    getPointStyle(p: DataPoint): any;
+    getPointLabelStyle(p: DataPoint): any;
+    getRangedColor(p: DataPoint): string;
+    isPointLabelsVisible(): boolean;
+    isPointLabelVisible(p: DataPoint): boolean;
+    pointLabelCount(): number;
+    getLabeledPoints(): DataPoint[];
+    getCallout(): DataPointCallout<DataPointCalloutOptions>;
+    isPointCalloutVisible(): boolean;
+    getLegendSources(list: ILegendSource[]): void;
+    getLabelOff(): number;
+    protected _defLabelOff(): number;
+    setCalcedColor(color: string): void;
+    coordOfArea(id: string): MapCoord;
+    getCoord(p: DataPoint): MapCoord;
+    pointById(id: string): DataPoint;
+    needRemoveAnimation(): boolean;
+    addPoint(source: any, index?: number, duration?: number): DataPoint;
+    removePoint(p: DataPoint | number, duration?: number): void;
+    removeFirst(duration?: number): void;
+    removeLast(duration?: number): void;
+    updatePoint(p: DataPoint | string | number, props: any): boolean;
+    getPointLabels(): DataPointLabel[];
+    getColorScale(): string | number;
+    setOptionsDirty(value: boolean): Series;
+    pointClicked(p: DataPoint): boolean;
+    show(force?: boolean, animate?: boolean): void;
+    hide(animate?: boolean): void;
+    getCalloutShape(p: DataPoint): string;
+    canSelect(): boolean;
+    select(p: ISelectionSource): void;
+    unselect(p: ISelectionSource): void;
+    private $_bringToFront;
+    lock(): void;
+    unlock(): void;
+    protected _doApply(options: SeriesOptions): void;
+    _prepareRender(): void;
+    protected _doAfterRender(): void;
+    protected _doMapChanged(): void;
+    protected _doPrepareRender(chart: IChart): void;
+    protected abstract _createPoint(source: any): DataPoint;
+    protected $_addPoint(source: any, i: number): DataPoint;
+    protected _createFielder(f: any): (v: any) => any;
+    protected _createFielders(op: SeriesOptions): void;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+    protected _defaultLoadAnimation(): SeriesLoadAnimation;
+    _load(source: any): OP;
+    protected _doLoadData(src: any): any[];
+    private $_loadPoints;
+    protected _doLoadPoints(src: any): void;
+    protected _createPointArgs(): DataPointCallbackArgs;
+    protected _getPointCallbackArgs(args: DataPointCallbackArgs, p: DataPoint): DataPointCallbackArgs;
+    protected _preparePointArgs(args: DataPointCallbackArgs): void;
+    protected _calcMinMax(pts: DataPoint[]): {
+        min: number;
+        max: number;
+    };
+}
+declare abstract class ValuePoint extends DataPoint {
+    value: number;
+    protected _readObject(series: ISeries, v: any): void;
+    getValue(): number;
+    getBaseValue(): number;
+}
+declare abstract class ValueSeries<OP extends ValueSeriesOptions = ValueSeriesOptions> extends Series<OP> {
+    static defaults: ValueSeriesOptions;
+    protected _createFielders(op: ValueSeriesOptions): void;
+}
+declare abstract class MarkerSeriesPoint extends ValuePoint {
+}
+declare abstract class MarkerSeries<OP extends MarkerSeriesOptions = MarkerSeriesOptions> extends ValueSeries<OP> {
+    static defaults: MarkerSeriesOptions;
+}
+declare class SparkSeriesPoint extends ValuePoint {
+    values: number[];
+    position: PointViewPosition;
+    getPoints(values: number[], minimum: number, maximum: number): number[];
+    getBasePoint(minimum: number, maximum: number, base: number): number;
+    protected _readObject(series: ISeries, v: any): void;
+}
+declare class SparkCategoryImpl implements ILegendSource {
+    name: string;
+    color: string;
+    constructor(name: string, color: string);
+    visible: boolean;
+    canHide(): boolean;
+    legendMarker(doc: Document, size: number): RmElement;
+    legendColor(): string;
+    legendLabel(): string;
+}
+declare abstract class SparkSeries<OP extends SparkSeriesOptions = SparkSeriesOptions> extends ValueSeries<OP> {
+    static defaults: SparkSeriesOptions;
+    _categories: SparkCategoryImpl[];
+    getMinMax(points: SparkSeriesPoint[]): {
+        min: number;
+        max: number;
+    };
+    protected _doApply(options: SparkSeriesOptions): void;
+    getLegendSources(list: ILegendSource[]): void;
+    private $_parseCategories;
+}
+declare abstract class OrthogonalSparkSeriesPoint extends SparkSeriesPoint {
+}
+declare abstract class OrthogonalSparkSeries<OP extends OrthogonalSparkSeriesOptions = OrthogonalSparkSeriesOptions> extends SparkSeries<OP> {
+    static readonly DEF_WIDTH = 80;
+    static readonly DEF_HEIGHT = 50;
+    static defaults: OrthogonalSparkSeriesOptions;
+    private _baseLine;
+    _width: number;
+    _height: number;
+    _minValue: number;
+    _maxValue: number;
+    _pointDomain: boolean;
+    protected _doInit(op: OrthogonalSparkSeriesOptions): void;
+    get baseLine(): ChartItem<ChartItemOptions>;
+    getPointExtents(values: number[], seriesExt: {
+        min: number;
+        max: number;
+    }): {
+        min: number;
+        max: number;
+        base: number;
+    };
+    protected _doApply(options: OrthogonalSparkSeriesOptions): void;
+}
+declare abstract class GaugePoint extends ValuePoint {
+    position: PointViewPosition;
+}
+declare abstract class Gauge<OP extends GaugeOptions = GaugeOptions> extends ValueSeries<OP> {
+    static readonly DEF_SIZE = 60;
+    static defaults: GaugeOptions;
+    _width: number;
+    _height: number;
+    protected _doApply(options: GaugeOptions): void;
+}
+declare abstract class ValueGauge<OP extends ValueGaugeOptions = ValueGaugeOptions> extends Gauge<OP> {
+    static defaults: ValueGaugeOptions;
+    private _minValue;
+    private _maxValue;
+    private _min;
+    private _max;
+    getValueRate(value: number): number;
+    protected _doApply(options: ValueGaugeOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+interface ISelectionSource {
+    setSelected(selected: boolean): void;
+}
+interface ISelectionOwner {
+    selectionChanged(selection: MapSelection): void;
+    selectionItemAdded(item: ISelectionSource): void;
+    selectionItemRemoved(item: ISelectionSource): void;
+    selectionCleared(): void;
+}
+declare class MapSelection extends RmObject {
+    private _owner;
+    private _items;
+    constructor(owner: ISelectionOwner);
+    get count(): number;
+    get first(): ISelectionSource;
+    get last(): ISelectionSource;
+    get(index: number): ISelectionSource;
+    contains(source: ISelectionSource): boolean;
+    clear(): boolean;
+    add(series: ISeries, source: ISelectionSource, clear?: boolean): boolean;
+    remove(series: ISeries, source: ISelectionSource): boolean;
+    toggle(series: ISeries, source: ISelectionSource): boolean;
+    protected _changed(): void;
+}
+
+declare class DataPoint implements ISelectionSource {
+    source?: any;
+    coord: MapCoord;
+    callout: MapCoord[];
+    offset: MapCoord[];
+    readonly pid: number;
+    id: string;
+    index: number;
+    isNull: boolean;
+    name: string;
+    color: string;
+    className: string;
+    visible: boolean;
+    xPos: number;
+    yPos: number;
+    _runColor: string;
+    _zindex: number;
+    private _selected;
+    _deleting: boolean;
+    _prev: any;
+    _vr: number;
+    constructor(source?: any);
+    setSelected(selected: boolean): void;
+    get lon(): number;
+    get lat(): number;
+    ariaHint(): string;
+    labelCount(): number;
+    copy(): any;
+    proxy(): any;
+    assignTo(proxy?: any): any;
+    getProp(fld: string | number): any;
+    parse(series: ISeries): void;
+    protected _doInitValues(): void;
+    getValue(): number;
+    getLabel(index: number): any;
+    updateValues(series: ISeries, values: any): any;
+    protected _valuesChanged(prev: any): boolean;
+    getBaseValue(): number;
+    getParam(param: string): any;
+    getCallout(coord: MapCoord): MapCoord[];
+    protected _assignTo(proxy: any): any;
+    protected _readArray(series: ISeries, v: any[]): void;
+    protected _readObject(series: ISeries, v: any): void;
+    private $_parseCallout;
+    protected _readSingle(v: any): void;
+}
+declare class DataPointCollection {
+    protected _owner: ISeries<DataPoint>;
+    private _points;
+    constructor(owner: ISeries<DataPoint>);
+    get count(): number;
+    get first(): DataPoint;
+    get last(): DataPoint;
+    isEmpty(): boolean;
+    getPoints(): DataPoint[];
+    get(index: number): DataPoint;
+    pointById(id: string): DataPoint;
+    contains(p: DataPoint): boolean;
+    load(source: any): void;
+    clear(): void;
+    insert(index: number, p: DataPoint): void;
+    add(p: DataPoint): void;
+    remove(p: DataPoint): boolean;
+    sort(callback: (p1: DataPoint, p2: DataPoint) => number): void;
+    forEach(callback: (p: DataPoint, i?: number) => any): void;
+}
+
+interface IChart {
+    options: ChartConfiguration;
+    chartOptions: ChartOptionsOptions;
+    _loading: boolean;
+    map: MapModel;
+    axis: MapAxis;
+    body: Body;
+    _tooltip: Tooltip;
+    _assets: AssetCollection;
+    _seriesIndex: number;
+    selection: MapSelection;
+    width: number;
+    height: number;
+    isGlobe: boolean;
+    firstVisible: Series;
+    firstMapSeries: Series;
+    isDirty: boolean;
+    mapAt(index: number): MapModel;
+    mapByName(name: string): MapModel;
+    getMap(nameOrIndex: string | number): MapModel;
+    getFirstSeries(type: string): Series;
+    animatable(): boolean;
+    loadAnimatable(): boolean;
+    loadBase(source: any, model: string, type: string): any;
+    assignTemplates(target: any): any;
+    projectionChanged(): void;
+    zoomChanged(oldZoom: number): void;
+    seriesByName(series: string): Series;
+    isVisible(coord: MapCoord): boolean;
+    getColorScale(scale: string | number): ColorScale;
+    requestShowSeries(series: Series, visible: boolean): void;
+    isDrilldowned: boolean;
+    drilldown(series: Series, area: string): void;
+    drillup(series?: Series): void;
+    _getSeriesType(type: string): any;
+    _getAnnotationType(type: string): any;
+    getProjection(second: boolean): MapProjection;
+    _visibleChanged(item: ChartItem): void;
+    _optionChanged(item: ChartItem, tag?: any): void;
+    _getLegendSources(): ILegendSource[];
+    _hoverAreaChanged(series: Series, newArea: MapArea, oldArea: MapArea): void;
+    _areaClicked(series: Series, newArea: MapArea): void;
+    getParam(target: any, param: string): any;
+    setParam(param: string, value: any, redraw?: boolean): void;
+    _dataChanged(): void;
+    _isDataChanged(): boolean;
+    lockOptionsDirty(): void;
+    freeOptionsDirty(): void;
+    _selectionChanged(series: ISeries, p: ISelectionSource): void;
+    getNextPointShape(): Shape;
+}
+declare class ChartItem<OP extends ChartItemOptions = ChartItemOptions> extends RmObject {
+    static readonly REFRESHED = "refreshed";
+    static defaults: ChartItemOptions;
+    readonly chart: IChart;
+    protected _op: OP;
+    _style: SVGStyleOrClass;
+    private _children;
+    constructor(chart: IChart);
+    _init(): OP;
+    protected _doInit(op: OP): void;
+    get options(): OP;
+    get visible(): boolean;
+    set visible(value: boolean);
+    protected _isVisible(): boolean;
+    _load(source: any): OP;
+    loadOptions(source: any): OP;
+    saveOptions(): any;
+    updateOptions(source?: OP, render?: boolean): this;
+    updateOption(prop: keyof OP, value: any, render?: boolean): this;
+    toggleOption(prop: keyof OP, render?: boolean): this;
+    removeOption(prop: keyof OP, render?: boolean): this;
+    clearOptions(render?: boolean): this;
+    _prepareRender(): void;
+    _afterRender(): void;
+    _optionChanged(tag?: any): void;
+    protected _doLoad(options: ChartItemOptions, source: any): void;
+    protected _doSetSimple(src: any): boolean;
+    protected _doLoadProp(prop: string, value: any): boolean;
+    private $_applyOptions;
+    protected _setDim(options: ChartItemOptions, prop: string): void;
+    protected _setDims(options: ChartItemOptions, ...props: string[]): void;
+    protected _doApply(options: ChartItemOptions): void;
+    protected _doSave(target: object): void;
+    protected _doUpdate(source: any): void;
+    protected _doPrepareRender(chart: IChart): void;
+    protected _doAfterRender(): void;
+}
+declare abstract class ChartItemCollection<T extends ChartItem> {
+    readonly chart: IChart;
+    protected _items: T[];
+    constructor(chart: IChart);
+    get count(): number;
+    get first(): T;
+    items(): T[];
+    _internalItems(): T[];
+    abstract load(src: any, tag?: any): void;
+    updateOptions(source: any, render: boolean): void;
+}
+declare class ChartText<OP extends ChartTextOptions = ChartTextOptions> extends ChartItem<OP> {
+    static defaults: ChartTextOptions;
+    private _outlineThickness;
+    private _numberSymbols;
+    private _numberFormat;
+    private _text;
+    _outlineWidth: string;
+    private _numSymbols;
+    protected _numberFormatter: NumberFormatter;
+    protected _richTextImpl: SvgRichText;
+    private _setOutlineThickness;
+    private _setNumberSymbols;
+    private _setNumberFormat;
+    private _setText;
+    isVisible(): boolean;
+    setText(value: string): void;
+    buildSvg(view: TextElement, outline: TextElement, maxWidth: number, maxHeight: number, target: any, domain: IRichTextDomain): void;
+    prepareRich(text: string): void;
+    protected _doSetSimple(src: any): boolean;
+    protected _doApply(options: ChartTextOptions): void;
+    private $_getNumberText;
+    protected _getText(text: any, value: any, useSymbols: boolean, forceSymbols: boolean): string;
+    getNumberText(value: any, useSymbols: boolean, forceSymbols: boolean, roundingMode: 'trunc' | 'ceil'): string;
+}
+declare abstract class IconedText<OP extends IconedTextOptions = IconedTextOptions> extends ChartText<OP> {
+    static defaults: IconedTextOptions;
+    private _images;
+    private _root;
+    abstract getDefaultIconPos(): IconPosition;
+    getIconPos(): IconPosition;
+    protected _doPrepareRender(chart: IChart): void;
+    getUrl(url: string): string;
+}
+declare abstract class ScaleBase<OP extends ScaleOptions = ScaleOptions> extends ChartItem<OP> {
+    static defaults: ScaleOptions;
+    index: number;
+    protected _location: ScaleLocation;
+    protected _series: ISeries;
+    get series(): ISeries<DataPoint>;
+    getLocation(): ScaleLocation;
+    isReversed(): boolean;
+    protected _doApply(options: ScaleOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+    protected _getFirstSeries(chart: IChart): Series<SeriesOptions>;
+}
+declare abstract class ScaleCollection<T extends ScaleBase = ScaleBase> extends ChartItemCollection<T> {
+    private _map;
+    protected _visibles: T[];
+    getVisibles(loc: ScaleLocation): T[];
+    get(name: string | number): T;
+    prepareRender(): void;
+    load(src: any): void;
+    protected abstract _createScale(chart: IChart): T;
+    private $_loadItem;
+}
+
+declare abstract class Annotation<OP extends AnnotationOptions = AnnotationOptions> extends ChartItem<OP> {
+    inBody: boolean;
+    static register(...clses: typeof Annotation<AnnotationOptions>[]): void;
+    static readonly type: string;
+    static defaults: AnnotationOptions;
+    private _width;
+    private _height;
+    private _offsetX;
+    private _offsetY;
+    index: number;
+    private _name;
+    private _widthDim;
+    private _heightDim;
+    private _offsetXDim;
+    private _offsetYDim;
+    _x: number;
+    _y: number;
+    _w: number;
+    _h: number;
+    _anchorObj: ChartItem;
+    constructor(chart: IChart, inBody: boolean);
+    _type(): string;
+    get name(): string;
+    getOffset(w: number, h: number): IPoint;
+    getSize(wDomain: number, hDomain: number): ISize;
+    getPosition(left: number, top: number, wDomain: number, hDomain: number, width: number, height: number): IPoint;
+    refresh(): void;
+    _load(source: any): OP;
+    protected _doApply(options: AnnotationOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+interface IAnnotationOwner {
+    chart: IChart;
+    options: {
+        annotations?: AnnotationOptions | AnnotationOptions[];
+    };
+    anchorByName(name: string): ChartItem;
+}
+declare class AnnotationCollection extends ChartItemCollection<Annotation> {
+    owner: IAnnotationOwner;
+    private _map;
+    private _visibles;
+    constructor(owner: IAnnotationOwner);
+    getVisibles(): Annotation[];
+    getAnnotation(name: string): Annotation;
+    get(name: string | number): Annotation;
+    load(src: any, inBody: boolean): void;
+    prepareRender(): void;
+    private $_loadItem;
+}
+
+declare class MapChart {
+    _obj: ChartObject;
+    private _modelCallback;
+    _loadCallback: () => void;
+    private _loaded;
+    constructor(config?: ChartConfiguration, callback?: (model: ChartObject, oldModel: ChartObject) => void);
+    get options(): ChartConfiguration;
+    get type(): string;
+    get body(): Body;
+    get assets(): AssetCollection;
+    get map(): MapModel;
+    get title(): Title;
+    get subtitle(): Subtitle;
+    get series(): Series;
+    get firstMapSeries(): MapSeries;
+    get legend(): Legend;
+    get colorScale(): ColorScale;
+    get bubbleScale(): BubbleScale;
+    get zoomPanel(): ZoomPanel;
+    get drilldownPanel(): DrilldownPanel;
+    get tooltip(): Tooltip;
+    get selection(): MapSelection;
+    get exporter(): Exporter;
+    setBaseMap(indexOrName?: number | string): void;
+    getMap(name: string | number): MapModel;
+    getSeries(name: string | number): Series;
+    seriesByType(type: string): Series;
+    getAnnotation(name: string): Annotation;
+    load(config: ChartConfiguration, loadAnimation?: boolean, callback?: () => void): MapChart;
+    loadAsync(config: ChartConfiguration, loadAnimation?: boolean, callback?: () => void): Promise<MapChart>;
+    updateOptions(options: ChartConfiguration, render?: boolean): void;
+    export(options: ExporterOptions): void;
+    render(now?: boolean): void;
+    setParam(param: string, value: any, redraw?: boolean): void;
+    addSeries(source: any, animate?: boolean): Series;
+    removeSeries(series: string | Series, animate?: boolean): void;
+    getPoint(id: string): MapCoord;
+    seriesAt(index: number): Series;
+    seriesByName(name: string): Series;
+    drilldown(series?: number | string | MapSeries, area?: string): Promise<void>;
+    drillup(series?: number | string | MapSeries): Promise<void>;
+}
+
+declare class Globals {
+    static getVersion(): string;
+    static setDebugging(debug: boolean): void;
+    static setLogging(logging: boolean): void;
+    static getDistance(p1: [number, number], p2: [number, number]): number;
+    static createChart(doc: Document, container: string | HTMLDivElement, config: any, animate?: boolean, callback?: () => void): MapChart;
+    static createChartAsync(doc: Document, container: string | HTMLDivElement, config: any, animate?: boolean, callback?: () => void): Promise<MapChart>;
+    static preset(name: string, info?: MapInsetDisplay): MapInset;
+}
+
+declare class BarSeriesPoint extends OrthogonalSparkSeriesPoint {
+}
+declare class BarSeries extends OrthogonalSparkSeries<BarSeriesOptions> {
+    static type: string;
+    static defaults: BarSeriesOptions;
+    private _subLabel;
+    protected _doInit(op: BarSeriesOptions): void;
+    get subLabel(): DataPointLabel<DataPointLabelOptions>;
+    pointLabelCount(): number;
+    protected _createPoint(source: any): BarSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+}
+
+declare class BubbleSeriesPoint extends MarkerSeriesPoint {
+    position: PointViewPosition;
+    labelCount(): number;
+    protected _readObject(series: ISeries<BubbleSeriesPoint>, v: any): void;
+    protected _valuesChanged(prev: any): boolean;
+    protected _assignTo(proxy: any): void;
+}
+declare class BubbleSeries extends MarkerSeries<BubbleSeriesOptions> {
+    static type: string;
+    static defaults: BubbleSeriesOptions;
+    private _subLabel;
+    private _minSizeDim;
+    private _maxSizeDim;
+    _minValue: number;
+    _maxValue: number;
+    _vMin: number;
+    _vMax: number;
+    _noSize: boolean;
+    private _alignToSurface;
+    protected _doInit(op: BubbleSeriesOptions): void;
+    get subLabel(): DataPointLabel<DataPointLabelOptions>;
+    get alignToSurface(): boolean;
+    set alignToSurface(value: boolean);
+    getShape(): Shape;
+    getPixelMinMax(len: number): {
+        min: number;
+        max: number;
+    };
+    getRadius(value: number, pxMin: number, pxMax: number): number;
+    getSubLabelOff(): number;
+    protected _doApply(options: BubbleSeriesOptions): void;
+    pointLabelCount(): number;
+    getPointLabels(): DataPointLabel<DataPointLabelOptions>[];
+    protected _createPoint(source: any): BubbleSeriesPoint;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+declare class CircleGaugeItem<OP extends ChartItemOptions> extends ChartItem<OP> {
+    gauge: CircleGauge;
+    constructor(gauge: CircleGauge);
+}
+declare class CircleGaugeFace extends CircleGaugeItem<CircleGaugeFaceOptions> {
+    static defaults: CircleGaugeFaceOptions;
+}
+declare class CircleGaugeRim extends CircleGaugeItem<CircleGaugeRimOptions> {
+    static defaults: CircleGaugeRimOptions;
+    private _thicknessDim;
+    protected _doApply(options: CircleGaugeValueRimOptions): void;
+}
+declare class CircleGaugeValueRim extends CircleGaugeItem<CircleGaugeValueRimOptions> {
+    static defaults: CircleGaugeValueRimOptions;
+    private _thicknessDim;
+    getThickness(domain: number): number;
+    protected _doApply(options: CircleGaugeValueRimOptions): void;
+}
+declare class CircleGaugeHand extends CircleGaugeItem<CircleGaugeHandOptions> {
+    static defaults: CircleGaugeHandOptions;
+    private _radiusDim;
+    private _lengthDim;
+    private _offsetDim;
+    getExtents(domain: number): {
+        radius: number;
+        length: number;
+        offset: number;
+    };
+    protected _doApply(options: CircleGaugeHandOptions): void;
+}
+declare class CircleGaugePin extends CircleGaugeItem<CircleGaugePinOptions> {
+    static defaults: CircleGaugePinOptions;
+    private _radiusDim;
+    getRadius(domain: number): number;
+    protected _doApply(options: CircleGaugePinOptions): void;
+}
+declare class CircleGaugeLabel extends ChartText<CircleGaugeLabelOptions> {
+    static defaults: CircleGaugeLabelOptions;
+    private _offsetXDim;
+    private _offsetYDim;
+    _domain: IRichTextDomain;
+    getOffset(width: number, height: number): IPoint;
+    protected _doApply(options: CircleGaugeLabelOptions): void;
+}
+interface ICircleGaugeExtents {
+    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();
+    centerX(): PercentSize;
+    setCenterX(value: PercentSize): void;
+    centerY(): PercentSize;
+    setCenterY(value: PercentSize): void;
+    radius(): PercentSize;
+    setRadius(value: PercentSize): void;
+    innerRadius(): PercentSize;
+    setInnerRadius(value: PercentSize): void;
+    valueRadius(): PercentSize;
+    setValueRadius(value: PercentSize): void;
+    getCenter(gaugeWidth: number, gaugeHeight: number): {
+        x: number;
+        y: number;
+    };
+    getExtents(gaugeSize: number): ICircleGaugeExtents;
+    prepareAngles(startAngle: number, sweepAngle: number): void;
+}
+declare class CircleGaugePoint extends GaugePoint {
+    protected _readObject(series: ISeries<CircleGaugePoint>, v: any): void;
+}
+declare class CircleGauge extends ValueGauge<CircleGaugeOptions> {
+    static readonly DEF_CENTER = "50%";
+    static readonly DEF_RADIUS = "50%";
+    static readonly DEF_INNER = "80%";
+    static type: string;
+    static defaults: CircleGaugeOptions;
+    private _face;
+    private _rim;
+    private _valueRim;
+    private _hand;
+    private _pin;
+    private _gaugeLabel;
+    _props: CircularProps;
+    protected _doInit(op: CircleGaugeOptions): void;
+    get face(): CircleGaugeFace;
+    get rim(): CircleGaugeRim;
+    get valueRim(): CircleGaugeValueRim;
+    get hand(): CircleGaugeHand;
+    get pin(): CircleGaugePin;
+    get gaugeLabel(): CircleGaugeLabel;
+    protected _createPoint(source: any): CircleGaugePoint;
+    protected _doApply(options: CircleGaugeOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+declare class ClockGaugeItem<OP extends ChartItemOptions> extends ChartItem<OP> {
+    gauge: ClockGauge;
+    constructor(gauge: ClockGauge);
+}
+declare class ClockGaugeRim extends ClockGaugeItem<ClockGaugeRimOptions> {
+    static defaults: ClockGaugeRimOptions;
+    private _thicknessDim;
+    getThickness(domain: number): number;
+    protected _doApply(options: ClockGaugeRimOptions): void;
+}
+declare class ClockGaugeHand<OP extends ClockGaugeHandOptions = ClockGaugeHandOptions> extends ClockGaugeItem<OP> {
+    static defaults: ClockGaugeHandOptions;
+    private _lengthDim;
+    getLength(domain: number): number;
+    protected _doApply(options: ClockGaugeHandOptions): void;
+}
+declare class ClockGaugeMinuteHand extends ClockGaugeHand<ClockGaugeHandOptions> {
+    static defaults: ClockGaugeHandOptions;
+}
+declare class ClockGaugeSecondHand extends ClockGaugeHand<ClockGaugeSecondHandOptions> {
+    static defaults: ClockGaugeSecondHandOptions;
+}
+declare class ClockGaugeTick extends ClockGaugeItem<ClockGaugeTickOptions> {
+    static defaults: ClockGaugeTickOptions;
+}
+declare class ClockGaugeTickLabel extends ClockGaugeItem<ClockGaugeTickLabelOptions> {
+    static defaults: ClockGaugeTickLabelOptions;
+}
+declare class ClockGaugePin extends ClockGaugeItem<ClockGaugePinOptions> {
+    static defaults: ClockGaugePinOptions;
+}
+declare class ClockGaugeLabel extends ChartText<ClockGaugeLabelOptions> {
+    static defaults: ClockGaugeLabelOptions;
+}
+declare class ClockGaugePoint extends GaugePoint {
+    timezone: number;
+    time: number | Date;
+    getTime(): Date;
+    protected _readObject(series: ISeries<ClockGaugePoint>, v: any): void;
+}
+declare class ClockGauge extends Gauge<ClockGaugeOptions> {
+    static readonly DEF_CENTER = "50%";
+    static readonly DEF_RADIUS = "50%";
+    static type: string;
+    static defaults: ClockGaugeOptions;
+    private _face;
+    private _rim;
+    private _hourHand;
+    private _minuteHand;
+    private _secondHand;
+    private _tick;
+    private _tickLabel;
+    private _pin;
+    private _gaugeLabel;
+    private _centerX;
+    private _centerY;
+    private _radius;
+    private _centerXDim;
+    private _centerYDim;
+    private _radiusDim;
+    protected _doInit(op: ClockGaugeOptions): void;
+    get face(): ChartItem<ChartItemOptions>;
+    get rim(): ClockGaugeRim;
+    get hourHand(): ClockGaugeHand<ClockGaugeHandOptions>;
+    get minuteHand(): ClockGaugeMinuteHand;
+    get secondHand(): ClockGaugeSecondHand;
+    get tick(): ClockGaugeTick;
+    get tickLabel(): ClockGaugeTickLabel;
+    get pin(): ClockGaugePin;
+    get gaugeLabel(): ClockGaugeLabel;
+    getExtents(gaugeWidth: number, gaugeHeight: number): {
+        cx: number;
+        cy: number;
+        rd: number;
+    };
+    protected _createPoint(source: any): ClockGaugePoint;
+    protected _doApply(options: ClockGaugeOptions): void;
+}
+
+declare class FigureSeriesPoint extends MarkerSeriesPoint {
+    figure: string;
+    position: PointViewPosition;
+    protected _readObject(series: ISeries<FigureSeriesPoint>, v: any): void;
+}
+declare class FigureSeries extends ValueSeries<FigureSeriesOptions> {
+    static type: string;
+    static defaults: FigureSeriesOptions;
+    private _innerLabel;
+    protected _doInit(op: FigureSeriesOptions): void;
+    getFigure(p: FigureSeriesPoint): string;
+    get innerLabel(): DataPointLabel<DataPointLabelOptions>;
+    protected _doApply(options: FigureSeriesOptions): void;
+    protected _createPoint(source: any): FigureSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doLoadPoints(src: any): void;
+}
+
+declare class HeatmapSeriesPoint extends MarkerSeriesPoint {
+    position: PointViewPosition;
+    protected _readObject(series: ISeries<HeatmapSeriesPoint>, v: any): void;
+}
+declare class HeatmapSeries extends MarkerSeries<HeatmapSeriesOptions> {
+    static type: string;
+    static defaults: HeatmapSeriesOptions;
+    private _root;
+    protected _doApply(options: HeatmapSeriesOptions): void;
+    protected _createPoint(source: any): HeatmapSeriesPoint;
+    protected _defLabelOff(): number;
+}
+
+declare class ImageSeriesPoint extends DataPoint {
+    imageUrl: string;
+    position: PointViewPosition;
+    protected _readObject(series: ImageSeries, v: any): void;
+}
+declare class ImageSeries extends Series<ImageSeriesOptions> {
+    static type: string;
+    static defaults: ImageSeriesOptions;
+    _imageFielder: (src: any) => string;
+    private _root;
+    getUrl(p: ImageSeriesPoint): string;
+    protected _createLabel(chart: IChart): DataPointLabel;
+    protected _createPoint(source: any): ImageSeriesPoint;
+    protected _createFielders(op: ImageSeriesOptions): void;
+    protected _defLabelOff(): number;
+    protected _doApply(options: ImageSeriesOptions): void;
+}
+
+declare class LineSeriesPoint extends OrthogonalSparkSeriesPoint {
+}
+declare class LineSeriesArea extends ChartItem<LineSeriesAreaOptions> {
+    static defaults: LineSeriesOptions;
+}
+declare class LineSeries extends OrthogonalSparkSeries<LineSeriesOptions> {
+    static type: string;
+    static defaults: LineSeriesOptions;
+    private _area;
+    protected _doInit(op: LineSeriesOptions): void;
+    get area(): LineSeriesArea;
+    protected _createPoint(source: any): LineSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+}
+
+declare class PanelSeriesPoint extends ValuePoint {
+    position: PointViewPosition;
+}
+declare abstract class PanelSeriesSection<OP extends PanelSeriesSectionOptions = PanelSeriesSectionOptions> extends ChartItem<OP> {
+    series: PanelSeries;
+    static defaults: PanelSeriesHeaderOptions;
+    protected _richTextImpl: SvgRichText;
+    private _point;
+    _domain: IRichTextDomain;
+    constructor(series: PanelSeries);
+    getTextDomain(p: PanelSeriesPoint): IRichTextDomain;
+    prepareRich(text: string): void;
+    buildSvg(view: TextElement, maxWidth: number, maxHeight: number, domain: IRichTextDomain): void;
+}
+declare class PanelSeriesHeader extends PanelSeriesSection<PanelSeriesHeaderOptions> {
+    static defaults: PanelSeriesHeaderOptions;
+    private _minSizeDim;
+    getMinSize(domain: number): number;
+    protected _doApply(options: ChartTextOptions): void;
+}
+declare class PanelSeriesBody extends PanelSeriesSection<PanelSeriesBodyOptions> {
+    static defaults: PanelSeriesBodyOptions;
+}
+declare class PanelSeries extends ValueSeries<PanelSeriesOptions> {
+    static readonly DEF_MIN_WIDTH = 80;
+    static readonly DEF_MIN_HEIGHT = 50;
+    static type: string;
+    static defaults: PanelSeriesOptions;
+    private _header;
+    private _divider;
+    private _body;
+    _vertical: boolean;
+    _width: number;
+    _height: number;
+    _minWidth: number;
+    _minHeight: number;
+    _maxWidth: number;
+    _maxHeight: number;
+    protected _doInit(op: PanelSeriesOptions): void;
+    get header(): PanelSeriesHeader;
+    get divider(): ChartItem<ChartItemOptions>;
+    get body(): PanelSeriesBody;
+    getExtents(calcedWidth: number, calcedHeight: number): ISize;
+    protected _createLabel(chart: IChart): DataPointLabel;
+    protected _createPoint(source: any): PanelSeriesPoint;
+    pointLabelCount(): number;
+    legendMarker(doc: Document, size: number): RmElement;
+    protected _doApply(options: PanelSeriesOptions): void;
+}
+
+declare class PieSeriesPoint extends SparkSeriesPoint {
+}
+declare class PieSeries extends SparkSeries<PieSeriesOptions> {
+    static type: string;
+    static defaults: PieSeriesOptions;
+    _startRad: number;
+    _totalRad: number;
+    private _radiusDim;
+    getRadius(domain: number): number;
+    protected _createPoint(source: any): PieSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doApply(options: PieSeriesOptions): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+declare class PinSeriesPoint extends MarkerSeriesPoint {
+    radius: number;
+    position: PointViewPosition;
+    protected _readObject(series: ISeries<PinSeriesPoint>, v: any): void;
+}
+declare class PinSeries extends MarkerSeries<PinSeriesOptions> {
+    private static readonly DEF_RADIUS;
+    static type: string;
+    static defaults: PinSeriesOptions;
+    private _rd;
+    private _innerRd;
+    getExt(p: PinSeriesPoint, rate: number): {
+        cx: number;
+        cy: number;
+        rd: number;
+        innerRd: number;
+    };
+    protected _doApply(options: PinSeriesOptions): void;
+    protected _createPoint(source: any): PinSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doLoadPoints(src: any): void;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+}
+
+declare class PointSeriesPoint extends MarkerSeriesPoint {
+    position: PointViewPosition;
+    protected _readObject(series: ISeries<PointSeriesPoint>, v: any): void;
+}
+declare class PointSeries extends MarkerSeries<PointSeriesOptions> {
+    static type: string;
+    static defaults: PointSeriesOptions;
+    private _shape;
+    constructor(chart: IChart);
+    getShape(p: PointSeriesPoint): Shape;
+    getRadius(): number;
+    protected _createPoint(source: any): PointSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doLoadPoints(src: any): void;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+    legendMarker(doc: Document, size: number): RmElement;
+}
+
+declare class RouteSeriesPoint extends DataPoint {
+    coords: [[number, number], [number, number]];
+    path: any[];
+    get lon1(): number;
+    get lat1(): number;
+    get lon2(): number;
+    get lat2(): number;
+    protected _assignTo(proxy: any): any;
+    protected _readObject(series: ISeries<RouteSeriesPoint>, v: any): void;
+}
+declare class RouteSeries extends Series<RouteSeriesOptions> {
+    static type: string;
+    static defaults: RouteSeriesOptions;
+    needMapScale(): boolean;
+    needRemoveAnimation(): boolean;
+    protected _createPoint(source: any): RouteSeriesPoint;
+    pointLabelCount(): number;
+    protected _defLabelOff(): number;
+    protected _doLoadPoints(src: any): void;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+}
+
+declare class VectorSeriesPoint extends MarkerSeriesPoint {
+    length: number;
+    angle: number;
+    protected _readObject(series: VectorSeries, v: any): void;
+}
+declare class VectorSeries extends MarkerSeries<VectorSeriesOptions> {
+    static type: string;
+    static defaults: VectorSeriesOptions;
+    _lengthFielder: (src: any) => any;
+    _angleFielder: (src: any) => any;
+    protected _createFielders(op: VectorSeriesOptions): void;
+    protected _createPoint(source: any): VectorSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doLoadPoints(src: any): void;
+    protected _createLegendMarker(doc: Document, size: number): RmElement;
+    legendMarker(doc: Document, size: number): RmElement;
+}
+
+type WaffleGrid = any[][];
+declare class WaffleSeriesPoint extends SparkSeriesPoint {
+    _sum: number;
+}
+declare class WaffleSeries extends SparkSeries<WaffleSeriesOptions> {
+    static readonly ROW_COUNT = 10;
+    static readonly COL_COUNT = 10;
+    static readonly THRESHOLD = 1;
+    static readonly CELL_SIZE = 5;
+    static readonly GAP = 2;
+    static type: string;
+    static defaults: WaffleSeriesOptions;
+    private _colCount;
+    private _rowCount;
+    private _threshold;
+    private _rounder;
+    private _cellSize;
+    private _gap;
+    private _runGrid;
+    getPointGrid(point: WaffleSeriesPoint, ext: {
+        min: number;
+        max: number;
+    }, rate: number): {
+        grid: WaffleGrid;
+        count: number;
+        rows: number;
+        cols: number;
+    };
+    protected _createPoint(source: any): WaffleSeriesPoint;
+    protected _defLabelOff(): number;
+    protected _doApply(op: WaffleSeriesOptions): void;
+    getWaffleInfo(): {
+        rowCount: number;
+        colCount: number;
+        wCell: number;
+        hCell: number;
+        gap: number;
+    };
+    protected _doPrepareRender(chart: IChart): void;
+    private $_caculate;
+    private $_rows;
+    private $_cols;
+    private $_fillRowFirst;
+    private $_fillColFirst;
+}
+
+declare class TextAnnotation extends Annotation<TextAnnotationOptions> {
+    static readonly type = "text";
+    static defaults: TextAnnotationOptions;
+    private _numberFormat;
+    private _timeFormat;
+    _domain: IRichTextDomain;
+    protected _isVisible(): boolean;
+    protected _doSetSimple(src: any): boolean;
+    protected _doApply(options: TextAnnotationOptions): void;
+}
+
+declare class ImageAnnotation extends Annotation<ImageAnnotationOptions> {
+    static type: string;
+    static defaults: ImageAnnotationOptions;
+    protected _isVisible(): boolean;
+    protected _doSetSimple(src: any): boolean;
+}
+
+declare class ShapeAnnotation extends Annotation<ShapeAnnotationOptions> {
+    static type: string;
+    static defaults: ShapeAnnotationOptions;
+    private _xRange;
+    private _yRange;
+    getSeries(): {
+        series: ISeries;
+        xRange: number[];
+        yRange: number[];
+    };
+    getShape(): Shape;
+    protected _doSetSimple(src: any): boolean;
+}
+
+declare abstract class SeriesAnimation {
+    static reveal(series: SeriesView<Series>, options?: IRevealAnimation): void;
+    static grow(series: SeriesView<Series>, endHandler?: RmAnimationEndHandler): void;
+    static spread(series: SeriesView<Series>, endHandler?: RmAnimationEndHandler): void;
+    static fadeIn(series: SeriesView<Series>): void;
+    constructor(sv: SeriesView<Series>, options?: any);
+    protected abstract _createAnimation(series: SeriesView<Series>, options?: any): Animation | RmAnimation;
+}
+interface IRevealAnimation {
+    from: 'left' | 'right' | 'top' | 'bottom';
+}
+
+interface ISectorShape {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    innerRadius?: number;
+    start: number;
+    angle: number;
+    borderRadius?: number;
+    clockwise?: boolean;
+}
+declare class SectorElement extends PathElement {
+    static create(doc: Document, styleName: string, x: number, y: number, rx: number, ry: number, start: number, angle: number, clockwise?: boolean): SectorElement;
+    static createInner(doc: Document, styleName: string, x: number, y: number, rx: number, ry: number, innerRadius: number, start: number, angle: number, clockwise?: boolean): SectorElement;
+    constructor(doc: Document, styleName?: string, shape?: ISectorShape);
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    innerRadius: number;
+    start: number;
+    angle: number;
+    clockwise: boolean;
+    rate: number;
+    equals(shape: ISectorShape): boolean;
+    setSector(shape: ISectorShape): void;
+    setSectorEx(shape: ISectorShape, stroked: boolean): void;
+    protected _getShape(): ISectorShape;
+    protected _assignShape(shape: ISectorShape, stroked: boolean): void;
+    private $_renderSector;
+    private $_renderArc;
+}
+
+declare class CircleElement extends RmElement {
+    constructor(doc: Document, styleName?: string, cx?: number, cy?: number, radius?: number);
+    setCircle(cx: number, cy: number, radius: number): void;
+}
+
+declare const isObject: (v: any) => boolean;
+declare const isArray: (arg: any) => arg is any[];
+declare const isString: (v: any) => v is string;
+declare const assignObj: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+declare const cos: (x: number) => number;
+declare const sin: (x: number) => number;
+declare const minv: (...values: number[]) => number;
+declare const maxv: (...values: number[]) => number;
+declare const absv: (x: number) => number;
+declare const copyObj: (v: any) => any;
+declare const pickNum: (v1: any, v2: any) => number;
+declare const pickProp: (v1: any, v2: any) => any;
+declare const pickProp3: (v1: any, v2: any, v3: any) => any;
+declare const incv: (prev: number, next: number, rate: number) => number;
+
+declare const _isIE: boolean;
+declare class Utils {
+    static LOGGING: boolean;
+    static log(...msg: any[]): void;
+    static logIf(condition: any, ...msg: any[]): void;
+    static week_days: string[];
+    static long_week_days: string[];
+    static month_days: number[][];
+    static now(): number;
+    static parseDate(date: string, defaultDate?: Date): Date;
+    static isLeapYear(year: number): boolean;
+    static dateOfYear(d: Date): number;
+    static incMonth(d: Date, delta: number): Date;
+    static minDate(d1: Date, d2: Date): Date;
+    static maxDate(d1: Date, d2: Date): Date;
+    static weekOfMonth(d: Date, startOfWeek: number, exact: boolean): number;
+    static weekOfYear(d: Date, startOfWeek: number): number;
+    static isObject(v: any): boolean;
+    static isValidObject(v: any): boolean;
+    static checkArray(v: any): any;
+    static makeArray(v: any, force?: boolean): any[];
+    static makeNumArray(v: any): number[];
+    static getIntArray(count: number, start?: number): number[];
+    static isValueArray(arr: any[]): boolean;
+    static toArray(v: any): any[];
+    static copyArray(v: any): any[];
+    static push(arr: Array<any>, items: Array<any>): void;
+    static isDefined(v: any): boolean;
+    static isNotDefined(v: any): boolean;
+    static isNum(value: any): value is number;
+    static canNumber(value: any): value is number;
+    static isValidNum(value: any): value is number;
+    static getNum(v: any, def?: number): number;
+    static toNum(value: any, def?: number): number;
+    static compareText(s1: string, s2: string, ignoreCase?: boolean): number;
+    static getTimeF(): number;
+    static getTimer(): number;
+    static isWhiteSpace(s: string): boolean;
+    static pad(value: number, len?: number, c?: string): string;
+    static pad16(value: number, len?: number, c?: string): string;
+    static pick(...args: any): any;
+    static toStr(value: any): string;
+    static extend(target: any, source: any): any;
+    static equalNumbers(a: number, b: number): boolean;
+    static equalArrays(a: any[], b: any[]): boolean;
+    static isEmpty(obj: {}): boolean;
+    static isNotEmpty(obj: {}): boolean;
+    static deepClone(obj: object): object;
+    static getArray(length: number, value?: any): any[];
+    static getNumArray(length: number, value?: number): number[];
+    static dedupe(list: any[], comparer?: (v1: any, v2: any) => number): any[];
+    static sortNum(list: number[]): number[];
+    static logElapsed(message: string, runner: () => void): void;
+    static clamp(v: number, min: number, max: number): number;
+    static clampEx(v: number, min: number, max: number): number;
+    static makeIntArray(from: number, to: number): number[];
+    static shuffle(arr: any[]): void;
+    static isDate(v: any): boolean;
+    static isValidDate(d: Date): boolean;
+    static asFunction(fn: any): any;
+    static getFieldProp(field: string): {
+        field: string;
+        props: string[];
+    };
+    static uniqueKey(): string;
+    static startsWith(str: string, search: string): boolean;
+    static endsWith(str: string, search: string): boolean;
+    static scaleNumber(value: number, symbols: string[], force: boolean): {
+        value: number;
+        symbol: string;
+    };
+    static jitter(v: number, amount: number): number;
+    static getDistance(p1: MapCoord, p2: MapCoord): number;
+    static getLogger(base: number): (v: number) => number;
+    static getMinMax(values: number[]): {
+        min: number;
+        max: number;
+    };
+}
+
+declare const getVersion: typeof Globals.getVersion;
+declare const setDebugging: typeof Globals.setDebugging;
+declare const setLogging: typeof Globals.setLogging;
+declare const getDistance: typeof Globals.getDistance;
+declare const createChart: typeof Globals.createChart;
+declare const createChartAsync: typeof Globals.createChartAsync;
+declare const preset: typeof Globals.preset;
+
+export { Align, Annotation, AnnotationAnimationOptions, AnnotationOptions, AnnotationOptionsType, AssetItemOptions, AssetOptionsType, BackgroundImageOptions, BarSeries, BarSeriesOptions, Body, BodyView, BubbleSeries, BubbleSeriesOptions, ChartConfiguration, ChartControl, ChartElement, ChartItem, ChartItemOptions, ChartOptionsOptions, ChartTextOptions, ChartView, CircleElement, CircleGauge, ClockGauge, Color, ColorListOptions, ContentView, CreditsOptions, DataPointCallbackArgs, DataPointLabel, DataPointLabelOptions, ElementPool, FigureSeries, GradientOptions, HeatmapSeries, HeatmapSeriesOptions, HeatmapSeriesType, IPercentSize, IPointView, IRect, ISeries, IconedTextOptions, ImageAnnotation, ImageAnnotationOptions, ImageListOptions, ImageSeries, Legend, LegendOptions, LineElement, LineSeries, LineSeriesOptions, LinearGradientOptions, MapAxis, MapAxisBandGuide, MapAxisGuide, MapAxisLineGuide, MapAxisRangeGuide, MapChart, MapCoord, MapCrosshair, MapInset, MapInsetDisplay, MapSeries, MapSeriesLabelOptions, MapSeriesOptions, MapSeriesType, MapBackgroundOptions as MapViewBackgroundOptions, BodyOptions as MapViewOptions, MarkerSeries, MarkerSeriesOptions, MarkerSeriesPointView, MarkerSeriesView, ORG_ANGLE, OrthogonalSparkSeries, PI_2, PanelSeries, PatternOptions, PercentSize, PieSeries, PieSeriesOptions, PinSeries, PointElement, PointLabelView, PointSeries, RAD_DEG, RadialGradientOptions, RectElement, RouteSeries, RouteSeriesOptions, RouteSeriesType, SVGStyleOrClass, SVGStyles, SectionView, SectorElement, Series, SeriesAnimation, SeriesOptions, SeriesOptionsType, SeriesView, ShapeAnnotation, ShapeAnnotationOptions, Size, SparkSeries, Subtitle, SubtitleOptions, TextAnchor, TextAnnotation, TextAnnotationOptions, TextElement, TextLayout, TiledWebSeriesOptions, TiledWebSeriesType, Title, TitleOptions, TooltipOptions, Utils, ValueSeries, VectorSeries, WaffleSeries, _isIE, absv, assignObj, calcPercent, copyObj, cos, createChart, createChartAsync, createRect, fixnum, getDistance, getVersion, incv, isArray, isEmptyRect, isObject, isString, maxv, minv, parsePercentSize, pickNum, pickProp, pickProp3, pixel, preset, rectToSize, setDebugging, setLogging, sin };