@antv/f2

  • Version 4.0.32
  • Published
  • 2.67 MB
  • 7 dependencies
  • MIT license

Install

npm i @antv/f2
yarn add @antv/f2
pnpm add @antv/f2

Overview

Charts for mobile visualization.

Index

Variables

Functions

Classes

Interfaces

Namespaces

Variables

variable ArcGuide

const ArcGuide: new (props: any) => {
chart: import('../../chart').default;
triggerRef: import('../../types').Ref;
willMount(): void;
didMount(): void;
didUpdate(): void;
getGuideBBox(): void;
parseReplaceStr(value: any, scale: any): any;
parsePoint(record: any): any;
convertPoints(records: any): any;
getGuideTheme(): any;
render(): import('../..').JSX.Element;
props: any;
state: any;
context: import('../../base/component').ComponentContext;
refs: { [key: string]: Component<any, any> };
updater: import('../../base/component').Updater<any>;
children: import('../..').JSX.Element;
container: any;
animate: boolean;
destroyed: boolean;
willReceiveProps(_props: any, context?: any): void;
willUpdate(): void;
didUnmount(): void;
setState(partialState: any, callback?: () => void): void;
forceUpdate(callback?: () => void): void;
setAnimate(animate: boolean): void;
destroy(): void;
};

    variable Area

    const Area: new (props: import('../line/types').LineProps, context?: any) => {
    getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
    mapping(): any[];
    splitPoints(points: any): any[][];
    splitNulls(points: any, connectNulls: any): any[];
    render(): import('../..').JSX.Element;
    isGeometry: boolean;
    geomType: import('../geometry/interface').GeomType;
    attrs: any;
    adjust: import('../geometry').AdjustProp;
    dataArray: any;
    records: any[];
    mappedArray: any;
    justifyContent: boolean;
    startOnZero: boolean;
    connectNulls: boolean;
    sortable: boolean;
    attrController: import('../../controller/attr').default;
    animation: import('../../canvas/animation/interface').AnimationCycle;
    willReceiveProps(nextProps: any): void;
    willMount(): void;
    willUpdate(): void;
    didMount(): void;
    _createAttrs(): void;
    _getThemeAttrsRange(): {
    x: import('../../coord/types').Range;
    y: import('../../coord/types').Range;
    color: any;
    size: any;
    shape: any;
    };
    _adjustScales(): void;
    _groupData(data: any): any[];
    _saveOrigin(originData: any): any[];
    _numberic(data: any): void;
    _adjustData(records: any): any;
    _updateStackRange(field: any, scale: any, dataArray: any): void;
    _processData(): void;
    _sortData(records: any): void;
    _initEvent(): void;
    getY0Value(): any;
    _getShapeStyle(shape: any, origin: any): any;
    _mapping(records: any): any;
    getClip(): {
    type: string;
    attrs: { x: number; y: number; width: number; height: number };
    };
    getAttr(attrName: string): any;
    getXScale(): any;
    getYScale(): any;
    _getXSnap(invertPointX: any): any;
    _getYSnapRecords(invertPointY: any, records: any): any;
    flatRecords(): any;
    getSnapRecords(point: any, inCoordRange?: any): any[];
    getLegendItems(): any;
    isSelected(record: any): boolean;
    getSelectionStyle(record: any): import('../../types').ShapeAttrs;
    props: import('../line/types').LineProps;
    state: import('../geometry/selection').SelectionState;
    context: import('../../base/component').ComponentContext;
    refs: { [key: string]: Component<any, any> };
    updater: import('../../base/component').Updater<
    import('../geometry/selection').SelectionState
    >;
    children: import('../..').JSX.Element;
    container: any;
    animate: boolean;
    destroyed: boolean;
    didUpdate(): void;
    didUnmount(): void;
    setState(
    partialState: import('../geometry/selection').SelectionState,
    callback?: () => void
    ): void;
    forceUpdate(callback?: () => void): void;
    setAnimate(animate: boolean): void;
    destroy(): void;
    };

      variable Axis

      const Axis: new (props: import('./types').AxisProps) => {
      style: import('./types').Style<void>;
      willReceiveProps(nextProps: import('./types').AxisProps): void;
      willMount(): void;
      willUpdate(): void;
      getScaleOption(props: import('./types').AxisProps): {
      type: any;
      tickCount: any;
      range: any;
      mask: any;
      formatter: any;
      min: any;
      max: any;
      nice: any;
      };
      _getDimType(): 'x' | 'y';
      getMaxBBox(
      ticks: any,
      style: import('./types').Style<void>
      ): { height: number; width: number };
      _getPosition(): 'left' | 'top' | 'right' | 'bottom';
      getTicks(): import('@antv/scale').Tick[];
      _generateGridPoints(ticks: any): any;
      _setTicksStyle(ticks: any): any;
      convertTicks(ticks: any): any;
      measureLayout():
      | import('../../chart').PositionLayout
      | import('../../chart').PositionLayout[];
      updateCoord(): void;
      render(): import('../..').JSX.Element;
      props: import('./types').AxisProps;
      state: {};
      context: import('../../base/component').ComponentContext;
      refs: { [key: string]: Component<any, any> };
      updater: import('../../base/component').Updater<{}>;
      children: import('../..').JSX.Element;
      container: any;
      animate: boolean;
      destroyed: boolean;
      didMount(): void;
      didUpdate(): void;
      didUnmount(): void;
      setState(partialState: {}, callback?: () => void): void;
      forceUpdate(callback?: () => void): void;
      setAnimate(animate: boolean): void;
      destroy(): void;
      };

        variable Children

        const Children: {
        cloneElement: typeof cloneElement;
        map: typeof map;
        toArray: typeof toArray;
        compare: typeof compare;
        };

          variable Gauge

          const Gauge: new (
          props: any,
          context?: import('../../base/component').ComponentContext,
          updater?: import('../../base/component').Updater<any>
          ) => {
          render(): import('../..').JSX.Element;
          props: any;
          state: any;
          context: import('../../base/component').ComponentContext;
          refs: { [key: string]: Component<any, any> };
          updater: import('../../base/component').Updater<any>;
          children: import('../..').JSX.Element;
          container: any;
          animate: boolean;
          destroyed: boolean;
          willMount(): void;
          didMount(): void;
          willReceiveProps(_props: any, context?: any): void;
          willUpdate(): void;
          didUpdate(): void;
          didUnmount(): void;
          setState(partialState: any, callback?: () => void): void;
          forceUpdate(callback?: () => void): void;
          setAnimate(animate: boolean): void;
          destroy(): void;
          };

            variable Guide

            const Guide: new (props: any) => {
            chart: import('../../chart').default;
            triggerRef: import('../../types').Ref;
            willMount(): void;
            didMount(): void;
            didUpdate(): void;
            getGuideBBox(): void;
            parseReplaceStr(value: any, scale: any): any;
            parsePoint(record: any): any;
            convertPoints(records: any): any;
            getGuideTheme(): any;
            render(): import('../..').JSX.Element;
            props: any;
            state: any;
            context: import('../../base/component').ComponentContext;
            refs: { [key: string]: Component<any, any> };
            updater: import('../../base/component').Updater<any>;
            children: import('../..').JSX.Element;
            container: any;
            animate: boolean;
            destroyed: boolean;
            willReceiveProps(_props: any, context?: any): void;
            willUpdate(): void;
            didUnmount(): void;
            setState(partialState: any, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            setAnimate(animate: boolean): void;
            destroy(): void;
            };

              variable ImageGuide

              const ImageGuide: new (props: any) => {
              chart: import('../../chart').default;
              triggerRef: import('../../types').Ref;
              willMount(): void;
              didMount(): void;
              didUpdate(): void;
              getGuideBBox(): void;
              parseReplaceStr(value: any, scale: any): any;
              parsePoint(record: any): any;
              convertPoints(records: any): any;
              getGuideTheme(): any;
              render(): import('../..').JSX.Element;
              props: any;
              state: any;
              context: import('../../base/component').ComponentContext;
              refs: { [key: string]: Component<any, any> };
              updater: import('../../base/component').Updater<any>;
              children: import('../..').JSX.Element;
              container: any;
              animate: boolean;
              destroyed: boolean;
              willReceiveProps(_props: any, context?: any): void;
              willUpdate(): void;
              didUnmount(): void;
              setState(partialState: any, callback?: () => void): void;
              forceUpdate(callback?: () => void): void;
              setAnimate(animate: boolean): void;
              destroy(): void;
              };

                variable Interval

                const Interval: new (
                props: import('../geometry/interface').GeometryProps,
                context?: any
                ) => {
                getDefaultCfg(): {
                geomType: string;
                justifyContent: boolean;
                startOnZero: boolean;
                };
                getDefaultSize(): number;
                mapping(): any[];
                getPointY0(): any;
                render(): import('../..').JSX.Element;
                isGeometry: boolean;
                geomType: import('../geometry/interface').GeomType;
                attrs: any;
                adjust: import('../geometry').AdjustProp;
                dataArray: any;
                records: any[];
                mappedArray: any;
                justifyContent: boolean;
                startOnZero: boolean;
                connectNulls: boolean;
                sortable: boolean;
                attrController: import('../../controller/attr').default;
                animation: import('../../canvas/animation/interface').AnimationCycle;
                willReceiveProps(nextProps: any): void;
                willMount(): void;
                willUpdate(): void;
                didMount(): void;
                _createAttrs(): void;
                _getThemeAttrsRange(): {
                x: import('../../coord/types').Range;
                y: import('../../coord/types').Range;
                color: any;
                size: any;
                shape: any;
                };
                _adjustScales(): void;
                _groupData(data: any): any[];
                _saveOrigin(originData: any): any[];
                _numberic(data: any): void;
                _adjustData(records: any): any;
                _updateStackRange(field: any, scale: any, dataArray: any): void;
                _processData(): void;
                _sortData(records: any): void;
                _initEvent(): void;
                getY0Value(): any;
                _getShapeStyle(shape: any, origin: any): any;
                _mapping(records: any): any;
                getClip(): {
                type: string;
                attrs: { x: number; y: number; width: number; height: number };
                };
                getAttr(attrName: string): any;
                getXScale(): any;
                getYScale(): any;
                _getXSnap(invertPointX: any): any;
                _getYSnapRecords(invertPointY: any, records: any): any;
                flatRecords(): any;
                getSnapRecords(point: any, inCoordRange?: any): any[];
                getLegendItems(): any;
                isSelected(record: any): boolean;
                getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                props: import('../geometry/interface').GeometryProps;
                state: import('../geometry/selection').SelectionState;
                context: import('../../base/component').ComponentContext;
                refs: { [key: string]: Component<any, any> };
                updater: import('../../base/component').Updater<
                import('../geometry/selection').SelectionState
                >;
                children: import('../..').JSX.Element;
                container: any;
                animate: boolean;
                destroyed: boolean;
                didUpdate(): void;
                didUnmount(): void;
                setState(
                partialState: import('../geometry/selection').SelectionState,
                callback?: () => void
                ): void;
                forceUpdate(callback?: () => void): void;
                setAnimate(animate: boolean): void;
                destroy(): void;
                };

                  variable Legend

                  const Legend: new (props: any) => {
                  style: import('../../types').Style;
                  itemWidth: Number;
                  getOriginItems(): any;
                  getItems(): any;
                  setItems(items: any): void;
                  getMaxItemBox(legendShape: any): { width: number; height: number };
                  _init(): void;
                  updateCoord(): void;
                  willMount(): void;
                  didMount(): void;
                  willUpdate(): void;
                  _initEvent(): void;
                  render(): import('../..').JSX.Element;
                  props: import('./withLegend').LegendProps;
                  state: any;
                  context: import('../../base/component').ComponentContext;
                  refs: { [key: string]: Component<any, any> };
                  updater: import('../../base/component').Updater<any>;
                  children: import('../..').JSX.Element;
                  container: any;
                  animate: boolean;
                  destroyed: boolean;
                  willReceiveProps(
                  _props: import('./withLegend').LegendProps,
                  context?: import('./withLegend').LegendProps
                  ): void;
                  didUpdate(): void;
                  didUnmount(): void;
                  setState(partialState: any, callback?: () => void): void;
                  forceUpdate(callback?: () => void): void;
                  setAnimate(animate: boolean): void;
                  destroy(): void;
                  };

                    variable Line

                    const Line: new (props: import('./types').LineProps, context?: any) => {
                    getDefaultCfg(): { geomType: string; sortable: boolean };
                    splitPoints(points: any): any[][];
                    splitNulls(points: any, connectNulls: any): any[];
                    mapping(): any[];
                    render(): import('../..').JSX.Element;
                    isGeometry: boolean;
                    geomType: import('../geometry/interface').GeomType;
                    attrs: any;
                    adjust: import('../geometry').AdjustProp;
                    dataArray: any;
                    records: any[];
                    mappedArray: any;
                    justifyContent: boolean;
                    startOnZero: boolean;
                    connectNulls: boolean;
                    sortable: boolean;
                    attrController: import('../../controller/attr').default;
                    animation: import('../../canvas/animation/interface').AnimationCycle;
                    willReceiveProps(nextProps: any): void;
                    willMount(): void;
                    willUpdate(): void;
                    didMount(): void;
                    _createAttrs(): void;
                    _getThemeAttrsRange(): {
                    x: import('../../coord/types').Range;
                    y: import('../../coord/types').Range;
                    color: any;
                    size: any;
                    shape: any;
                    };
                    _adjustScales(): void;
                    _groupData(data: any): any[];
                    _saveOrigin(originData: any): any[];
                    _numberic(data: any): void;
                    _adjustData(records: any): any;
                    _updateStackRange(field: any, scale: any, dataArray: any): void;
                    _processData(): void;
                    _sortData(records: any): void;
                    _initEvent(): void;
                    getY0Value(): any;
                    _getShapeStyle(shape: any, origin: any): any;
                    _mapping(records: any): any;
                    getClip(): {
                    type: string;
                    attrs: { x: number; y: number; width: number; height: number };
                    };
                    getAttr(attrName: string): any;
                    getXScale(): any;
                    getYScale(): any;
                    _getXSnap(invertPointX: any): any;
                    _getYSnapRecords(invertPointY: any, records: any): any;
                    flatRecords(): any;
                    getSnapRecords(point: any, inCoordRange?: any): any[];
                    getLegendItems(): any;
                    isSelected(record: any): boolean;
                    getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                    props: import('./types').LineProps;
                    state: import('../geometry/selection').SelectionState;
                    context: import('../../base/component').ComponentContext;
                    refs: { [key: string]: Component<any, any> };
                    updater: import('../../base/component').Updater<
                    import('../geometry/selection').SelectionState
                    >;
                    children: import('../..').JSX.Element;
                    container: any;
                    animate: boolean;
                    destroyed: boolean;
                    didUpdate(): void;
                    didUnmount(): void;
                    setState(
                    partialState: import('../geometry/selection').SelectionState,
                    callback?: () => void
                    ): void;
                    forceUpdate(callback?: () => void): void;
                    setAnimate(animate: boolean): void;
                    destroy(): void;
                    };

                      variable LineGuide

                      const LineGuide: new (props: any) => {
                      chart: import('../../chart').default;
                      triggerRef: import('../../types').Ref;
                      willMount(): void;
                      didMount(): void;
                      didUpdate(): void;
                      getGuideBBox(): void;
                      parseReplaceStr(value: any, scale: any): any;
                      parsePoint(record: any): any;
                      convertPoints(records: any): any;
                      getGuideTheme(): any;
                      render(): import('../..').JSX.Element;
                      props: any;
                      state: any;
                      context: import('../../base/component').ComponentContext;
                      refs: { [key: string]: Component<any, any> };
                      updater: import('../../base/component').Updater<any>;
                      children: import('../..').JSX.Element;
                      container: any;
                      animate: boolean;
                      destroyed: boolean;
                      willReceiveProps(_props: any, context?: any): void;
                      willUpdate(): void;
                      didUnmount(): void;
                      setState(partialState: any, callback?: () => void): void;
                      forceUpdate(callback?: () => void): void;
                      setAnimate(animate: boolean): void;
                      destroy(): void;
                      };

                        variable PieLabel

                        const PieLabel: new (props: any) => {
                        triggerRef: import('../../types').Ref;
                        labels: [];
                        willMount(): void;
                        didMount(): void;
                        getLabels(props: any): any[];
                        _handleEvent: (ev: any) => void;
                        _initEvent(): void;
                        render(): import('../..').JSX.Element;
                        props: any;
                        state: any;
                        context: import('../../base/component').ComponentContext;
                        refs: { [key: string]: Component<any, any> };
                        updater: import('../../base/component').Updater<any>;
                        children: import('../..').JSX.Element;
                        container: any;
                        animate: boolean;
                        destroyed: boolean;
                        willReceiveProps(_props: any, context?: any): void;
                        willUpdate(): void;
                        didUpdate(): void;
                        didUnmount(): void;
                        setState(partialState: any, callback?: () => void): void;
                        forceUpdate(callback?: () => void): void;
                        setAnimate(animate: boolean): void;
                        destroy(): void;
                        };

                          variable Point

                          const Point: new (
                          props: import('../geometry/interface').GeometryProps,
                          context?: any
                          ) => {
                          getDefaultCfg(): { geomType: string };
                          render(): import('../..').JSX.Element;
                          isGeometry: boolean;
                          geomType: import('../geometry/interface').GeomType;
                          attrs: any;
                          adjust: import('../geometry').AdjustProp;
                          dataArray: any;
                          records: any[];
                          mappedArray: any;
                          justifyContent: boolean;
                          startOnZero: boolean;
                          connectNulls: boolean;
                          sortable: boolean;
                          attrController: import('../../controller/attr').default;
                          animation: import('../../canvas/animation/interface').AnimationCycle;
                          willReceiveProps(nextProps: any): void;
                          willMount(): void;
                          willUpdate(): void;
                          didMount(): void;
                          _createAttrs(): void;
                          _getThemeAttrsRange(): {
                          x: import('../../coord/types').Range;
                          y: import('../../coord/types').Range;
                          color: any;
                          size: any;
                          shape: any;
                          };
                          _adjustScales(): void;
                          _groupData(data: any): any[];
                          _saveOrigin(originData: any): any[];
                          _numberic(data: any): void;
                          _adjustData(records: any): any;
                          _updateStackRange(field: any, scale: any, dataArray: any): void;
                          _processData(): void;
                          _sortData(records: any): void;
                          _initEvent(): void;
                          getY0Value(): any;
                          _getShapeStyle(shape: any, origin: any): any;
                          _mapping(records: any): any;
                          mapping(): any[];
                          getClip(): {
                          type: string;
                          attrs: { x: number; y: number; width: number; height: number };
                          };
                          getAttr(attrName: string): any;
                          getXScale(): any;
                          getYScale(): any;
                          _getXSnap(invertPointX: any): any;
                          _getYSnapRecords(invertPointY: any, records: any): any;
                          flatRecords(): any;
                          getSnapRecords(point: any, inCoordRange?: any): any[];
                          getLegendItems(): any;
                          isSelected(record: any): boolean;
                          getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                          props: import('../geometry/interface').GeometryProps;
                          state: import('../geometry/selection').SelectionState;
                          context: import('../../base/component').ComponentContext;
                          refs: { [key: string]: Component<any, any> };
                          updater: import('../../base/component').Updater<
                          import('../geometry/selection').SelectionState
                          >;
                          children: import('../..').JSX.Element;
                          container: any;
                          animate: boolean;
                          destroyed: boolean;
                          didUpdate(): void;
                          didUnmount(): void;
                          setState(
                          partialState: import('../geometry/selection').SelectionState,
                          callback?: () => void
                          ): void;
                          forceUpdate(callback?: () => void): void;
                          setAnimate(animate: boolean): void;
                          destroy(): void;
                          };

                            variable PointGuide

                            const PointGuide: new (props: any) => {
                            chart: import('../../chart').default;
                            triggerRef: import('../../types').Ref;
                            willMount(): void;
                            didMount(): void;
                            didUpdate(): void;
                            getGuideBBox(): void;
                            parseReplaceStr(value: any, scale: any): any;
                            parsePoint(record: any): any;
                            convertPoints(records: any): any;
                            getGuideTheme(): any;
                            render(): import('../..').JSX.Element;
                            props: any;
                            state: any;
                            context: import('../../base/component').ComponentContext;
                            refs: { [key: string]: Component<any, any> };
                            updater: import('../../base/component').Updater<any>;
                            children: import('../..').JSX.Element;
                            container: any;
                            animate: boolean;
                            destroyed: boolean;
                            willReceiveProps(_props: any, context?: any): void;
                            willUpdate(): void;
                            didUnmount(): void;
                            setState(partialState: any, callback?: () => void): void;
                            forceUpdate(callback?: () => void): void;
                            setAnimate(animate: boolean): void;
                            destroy(): void;
                            };

                              variable RectGuide

                              const RectGuide: new (props: any) => {
                              chart: import('../../chart').default;
                              triggerRef: import('../../types').Ref;
                              willMount(): void;
                              didMount(): void;
                              didUpdate(): void;
                              getGuideBBox(): void;
                              parseReplaceStr(value: any, scale: any): any;
                              parsePoint(record: any): any;
                              convertPoints(records: any): any;
                              getGuideTheme(): any;
                              render(): import('../..').JSX.Element;
                              props: any;
                              state: any;
                              context: import('../../base/component').ComponentContext;
                              refs: { [key: string]: Component<any, any> };
                              updater: import('../../base/component').Updater<any>;
                              children: import('../..').JSX.Element;
                              container: any;
                              animate: boolean;
                              destroyed: boolean;
                              willReceiveProps(_props: any, context?: any): void;
                              willUpdate(): void;
                              didUnmount(): void;
                              setState(partialState: any, callback?: () => void): void;
                              forceUpdate(callback?: () => void): void;
                              setAnimate(animate: boolean): void;
                              destroy(): void;
                              };

                                variable ScrollBar

                                const ScrollBar: new (props: import('./withScrollBar').ScrollBarProps) => {
                                willMount(): any;
                                render(): import('../..').JSX.Element;
                                startRange: { x?: import('../zoom').ZoomRange; y?: import('../zoom').ZoomRange };
                                scale: {};
                                originScale: {};
                                minScale: number;
                                dims: String[];
                                swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                loop: any;
                                didMount(): void;
                                willReceiveProps(nextProps: import('./withScrollBar').ScrollBarProps): void;
                                didUnmount(): void;
                                onStart: () => void;
                                onPan: (ev: any) => void;
                                update(): void;
                                onSwipe: (ev: any) => void;
                                onPinch: (ev: any) => void;
                                onEnd: () => void;
                                _doXPan(ev: any): import('../zoom').ZoomRange;
                                _doYPan(ev: any): import('../zoom').ZoomRange;
                                _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                _doXPinch(ev: any): any;
                                _doYPinch(ev: any): any;
                                _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                updateRange(
                                originalRange: import('../zoom').ZoomRange,
                                dim: any
                                ): import('../zoom').ZoomRange;
                                updateFollow(
                                scales: import('@antv/scale').Scale[],
                                mainScale: any,
                                data: any[]
                                ): void;
                                _getScale(dim: any): any;
                                _getFollowScales(dim: any): any[];
                                _bindEvents(): void;
                                _clearEvents(): void;
                                props: import('./withScrollBar').ScrollBarProps;
                                state: import('../zoom').ZoomState;
                                context: import('../../base/component').ComponentContext;
                                refs: { [key: string]: Component<any, any> };
                                updater: import('../../base/component').Updater<import('../zoom').ZoomState>;
                                children: import('../..').JSX.Element;
                                container: any;
                                animate: boolean;
                                destroyed: boolean;
                                willUpdate(): void;
                                didUpdate(): void;
                                setState(partialState: import('../zoom').ZoomState, callback?: () => void): void;
                                forceUpdate(callback?: () => void): void;
                                setAnimate(animate: boolean): void;
                                destroy(): void;
                                };

                                  variable Sunburst

                                  const Sunburst: new (props: any, context: any) => {
                                  coordController: import('../../controller/coord').default;
                                  coord: import('../../coord/base').default;
                                  color: import('../../attr/category').default;
                                  triggerRef: import('../../types').Ref[];
                                  didMount(): void;
                                  _mapping(children: any): void;
                                  sunburst(): any;
                                  render(): import('../..').JSX.Element;
                                  props: any;
                                  state: any;
                                  context: import('../../base/component').ComponentContext;
                                  refs: { [key: string]: Component<any, any> };
                                  updater: import('../../base/component').Updater<any>;
                                  children: import('../..').JSX.Element;
                                  container: any;
                                  animate: boolean;
                                  destroyed: boolean;
                                  willMount(): void;
                                  willReceiveProps(_props: any, context?: any): void;
                                  willUpdate(): void;
                                  didUpdate(): void;
                                  didUnmount(): void;
                                  setState(partialState: any, callback?: () => void): void;
                                  forceUpdate(callback?: () => void): void;
                                  setAnimate(animate: boolean): void;
                                  destroy(): void;
                                  };

                                    variable TagGuide

                                    const TagGuide: new (props: any) => {
                                    chart: import('../../chart').default;
                                    triggerRef: import('../../types').Ref;
                                    willMount(): void;
                                    didMount(): void;
                                    didUpdate(): void;
                                    getGuideBBox(): void;
                                    parseReplaceStr(value: any, scale: any): any;
                                    parsePoint(record: any): any;
                                    convertPoints(records: any): any;
                                    getGuideTheme(): any;
                                    render(): import('../..').JSX.Element;
                                    props: any;
                                    state: any;
                                    context: import('../../base/component').ComponentContext;
                                    refs: { [key: string]: Component<any, any> };
                                    updater: import('../../base/component').Updater<any>;
                                    children: import('../..').JSX.Element;
                                    container: any;
                                    animate: boolean;
                                    destroyed: boolean;
                                    willReceiveProps(_props: any, context?: any): void;
                                    willUpdate(): void;
                                    didUnmount(): void;
                                    setState(partialState: any, callback?: () => void): void;
                                    forceUpdate(callback?: () => void): void;
                                    setAnimate(animate: boolean): void;
                                    destroy(): void;
                                    };

                                      variable TextGuide

                                      const TextGuide: new (props: any) => {
                                      chart: import('../../chart').default;
                                      triggerRef: import('../../types').Ref;
                                      willMount(): void;
                                      didMount(): void;
                                      didUpdate(): void;
                                      getGuideBBox(): void;
                                      parseReplaceStr(value: any, scale: any): any;
                                      parsePoint(record: any): any;
                                      convertPoints(records: any): any;
                                      getGuideTheme(): any;
                                      render(): import('../..').JSX.Element;
                                      props: any;
                                      state: any;
                                      context: import('../../base/component').ComponentContext;
                                      refs: { [key: string]: Component<any, any> };
                                      updater: import('../../base/component').Updater<any>;
                                      children: import('../..').JSX.Element;
                                      container: any;
                                      animate: boolean;
                                      destroyed: boolean;
                                      willReceiveProps(_props: any, context?: any): void;
                                      willUpdate(): void;
                                      didUnmount(): void;
                                      setState(partialState: any, callback?: () => void): void;
                                      forceUpdate(callback?: () => void): void;
                                      setAnimate(animate: boolean): void;
                                      destroy(): void;
                                      };

                                        variable Tooltip

                                        const Tooltip: new (props: TooltipProps) => {
                                        updateCoord(): void;
                                        willMount(): void;
                                        didMount(): void;
                                        willReceiveProps(nextProps: any): void;
                                        _initShow(): void;
                                        _showByData(dataItem: any): void;
                                        _triggerOn: (ev: any) => void;
                                        _triggerOff: () => void;
                                        _initEvent(): void;
                                        didUnmount(): void;
                                        _clearEvents(): void;
                                        show(point: any, _ev?: any): void;
                                        hide(): void;
                                        render(): import('../..').JSX.Element;
                                        props: TooltipProps;
                                        state: import('./withTooltip').TooltipState;
                                        context: import('../../base/component').ComponentContext;
                                        refs: { [key: string]: Component<any, any> };
                                        updater: import('../../base/component').Updater<
                                        import('./withTooltip').TooltipState
                                        >;
                                        children: import('../..').JSX.Element;
                                        container: any;
                                        animate: boolean;
                                        destroyed: boolean;
                                        willUpdate(): void;
                                        didUpdate(): void;
                                        setState(
                                        partialState: import('./withTooltip').TooltipState,
                                        callback?: () => void
                                        ): void;
                                        forceUpdate(callback?: () => void): void;
                                        setAnimate(animate: boolean): void;
                                        destroy(): void;
                                        };

                                          variable Treemap

                                          const Treemap: new (props: any, context: any, updater?: any) => {
                                          coordController: import('../../controller/coord').default;
                                          coord: import('../../coord/base').default;
                                          color: import('../../attr/category').default;
                                          triggerRef: import('../../types').Ref[];
                                          treemapLayout(): any;
                                          render(): import('../..').JSX.Element;
                                          props: any;
                                          state: any;
                                          context: import('../../base/component').ComponentContext;
                                          refs: { [key: string]: Component<any, any> };
                                          updater: import('../../base/component').Updater<any>;
                                          children: import('../..').JSX.Element;
                                          container: any;
                                          animate: boolean;
                                          destroyed: boolean;
                                          willMount(): void;
                                          didMount(): void;
                                          willReceiveProps(_props: any, context?: any): void;
                                          willUpdate(): void;
                                          didUpdate(): void;
                                          didUnmount(): void;
                                          setState(partialState: any, callback?: () => void): void;
                                          forceUpdate(callback?: () => void): void;
                                          setAnimate(animate: boolean): void;
                                          destroy(): void;
                                          };

                                            Functions

                                            function AreaView

                                            AreaView: (props: any) => import('../..').JSX.Element;

                                              function AxisView

                                              AxisView: (props: PolarAxisProps | RectAxisProps) => import('../..').JSX.Element;

                                                function createElement

                                                createElement: (
                                                type: ElementType,
                                                config: any,
                                                ...children: any[]
                                                ) => JSXNamespace.Element;

                                                  function createRef

                                                  createRef: () => { current: any };

                                                    function Fragment

                                                    Fragment: (props: any) => any;

                                                      function GaugeView

                                                      GaugeView: (props: any) => import('../..').JSX.Element;

                                                        function IntervalView

                                                        IntervalView: (props: any) => import('../../..').JSX.Element;

                                                          function jsx

                                                          jsx: (
                                                          type: ElementType,
                                                          config: any,
                                                          ...children: any[]
                                                          ) => JSXNamespace.Element;

                                                            function LegendView

                                                            LegendView: (props: any) => import('../..').JSX.Element;

                                                              function LineView

                                                              LineView: (props: LineViewProps) => import('../..').JSX.Element;

                                                                function PieLabelView

                                                                PieLabelView: (props: any) => import('../..').JSX.Element;

                                                                  function PointView

                                                                  PointView: (props: any) => import('../..').JSX.Element;

                                                                    function render

                                                                    render: (element: JSX.Element, container: any, animate?: boolean) => any;

                                                                      function renderShape

                                                                      renderShape: (
                                                                      component: Component,
                                                                      children: JSX.Element,
                                                                      animate?: boolean
                                                                      ) => any;

                                                                        function ScrollBarView

                                                                        ScrollBarView: (props: any) => import('../..').JSX.Element;

                                                                          function SunburstView

                                                                          SunburstView: (props: any) => import('../..').JSX.Element;

                                                                            function TreemapView

                                                                            TreemapView: (props: any) => import('../..').JSX.Element;

                                                                              function withArea

                                                                              withArea: (
                                                                              View: any
                                                                              ) => new (props: import('../line/types').LineProps, context?: any) => {
                                                                              getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
                                                                              mapping(): any[];
                                                                              splitPoints(points: any): any[][];
                                                                              splitNulls(points: any, connectNulls: any): any[];
                                                                              render(): import('../..').JSX.Element;
                                                                              isGeometry: boolean;
                                                                              geomType: import('../geometry/interface').GeomType;
                                                                              attrs: any;
                                                                              adjust: import('../geometry').AdjustProp;
                                                                              dataArray: any;
                                                                              records: any[];
                                                                              mappedArray: any;
                                                                              justifyContent: boolean;
                                                                              startOnZero: boolean;
                                                                              connectNulls: boolean;
                                                                              sortable: boolean;
                                                                              attrController: import('../../controller/attr').default;
                                                                              animation: import('../../canvas/animation/interface').AnimationCycle;
                                                                              willReceiveProps(nextProps: any): void;
                                                                              willMount(): void;
                                                                              willUpdate(): void;
                                                                              didMount(): void;
                                                                              _createAttrs(): void;
                                                                              _getThemeAttrsRange(): {
                                                                              x: import('../../coord/types').Range;
                                                                              y: import('../../coord/types').Range;
                                                                              color: any;
                                                                              size: any;
                                                                              shape: any;
                                                                              };
                                                                              _adjustScales(): void;
                                                                              _groupData(data: any): any[];
                                                                              _saveOrigin(originData: any): any[];
                                                                              _numberic(data: any): void;
                                                                              _adjustData(records: any): any;
                                                                              _updateStackRange(field: any, scale: any, dataArray: any): void;
                                                                              _processData(): void;
                                                                              _sortData(records: any): void;
                                                                              _initEvent(): void;
                                                                              getY0Value(): any;
                                                                              _getShapeStyle(shape: any, origin: any): any;
                                                                              _mapping(records: any): any;
                                                                              getClip(): {
                                                                              type: string;
                                                                              attrs: { x: number; y: number; width: number; height: number };
                                                                              };
                                                                              getAttr(attrName: string): any;
                                                                              getXScale(): any;
                                                                              getYScale(): any;
                                                                              _getXSnap(invertPointX: any): any;
                                                                              _getYSnapRecords(invertPointY: any, records: any): any;
                                                                              flatRecords(): any;
                                                                              getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                              getLegendItems(): any;
                                                                              isSelected(record: any): boolean;
                                                                              getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                                                                              props: import('../line/types').LineProps;
                                                                              state: import('../geometry/selection').SelectionState;
                                                                              context: import('../../base/component').ComponentContext;
                                                                              refs: { [key: string]: Component<any, any> };
                                                                              updater: import('../../base/component').Updater<
                                                                              import('../geometry/selection').SelectionState
                                                                              >;
                                                                              children: import('../..').JSX.Element;
                                                                              container: any;
                                                                              animate: boolean;
                                                                              destroyed: boolean;
                                                                              didUpdate(): void;
                                                                              didUnmount(): void;
                                                                              setState(
                                                                              partialState: import('../geometry/selection').SelectionState,
                                                                              callback?: () => void
                                                                              ): void;
                                                                              forceUpdate(callback?: () => void): void;
                                                                              setAnimate(animate: boolean): void;
                                                                              destroy(): void;
                                                                              };

                                                                                function withAxis

                                                                                withAxis: (
                                                                                View: any
                                                                                ) => new (props: AxisProps) => {
                                                                                style: Style;
                                                                                willReceiveProps(nextProps: AxisProps): void;
                                                                                willMount(): void;
                                                                                willUpdate(): void;
                                                                                getScaleOption(props: AxisProps): {
                                                                                type: any;
                                                                                tickCount: any;
                                                                                range: any;
                                                                                mask: any;
                                                                                formatter: any;
                                                                                min: any;
                                                                                max: any;
                                                                                nice: any;
                                                                                };
                                                                                _getDimType(): 'x' | 'y';
                                                                                getMaxBBox(ticks: any, style: Style): BBox;
                                                                                _getPosition(): 'left' | 'top' | 'right' | 'bottom';
                                                                                getTicks(): import('@antv/scale').Tick[];
                                                                                _generateGridPoints(ticks: any): any;
                                                                                _setTicksStyle(ticks: any): any;
                                                                                convertTicks(ticks: any): any;
                                                                                measureLayout(): PositionLayout | PositionLayout[];
                                                                                updateCoord(): void;
                                                                                render(): import('../..').JSX.Element;
                                                                                props: AxisProps;
                                                                                state: {};
                                                                                context: import('../../base/component').ComponentContext;
                                                                                refs: { [key: string]: Component<any, any> };
                                                                                updater: import('../../base/component').Updater<{}>;
                                                                                children: import('../..').JSX.Element;
                                                                                container: any;
                                                                                animate: boolean;
                                                                                destroyed: boolean;
                                                                                didMount(): void;
                                                                                didUpdate(): void;
                                                                                didUnmount(): void;
                                                                                setState(partialState: {}, callback?: () => void): void;
                                                                                forceUpdate(callback?: () => void): void;
                                                                                setAnimate(animate: boolean): void;
                                                                                destroy(): void;
                                                                                };

                                                                                  function withGauge

                                                                                  withGauge: (
                                                                                  View: any
                                                                                  ) => new (
                                                                                  props: any,
                                                                                  context?: import('../../base/component').ComponentContext,
                                                                                  updater?: import('../../base/component').Updater<any>
                                                                                  ) => {
                                                                                  render(): import('../..').JSX.Element;
                                                                                  props: any;
                                                                                  state: any;
                                                                                  context: import('../../base/component').ComponentContext;
                                                                                  refs: { [key: string]: Component<any, any> };
                                                                                  updater: import('../../base/component').Updater<any>;
                                                                                  children: import('../..').JSX.Element;
                                                                                  container: any;
                                                                                  animate: boolean;
                                                                                  destroyed: boolean;
                                                                                  willMount(): void;
                                                                                  didMount(): void;
                                                                                  willReceiveProps(_props: any, context?: any): void;
                                                                                  willUpdate(): void;
                                                                                  didUpdate(): void;
                                                                                  didUnmount(): void;
                                                                                  setState(partialState: any, callback?: () => void): void;
                                                                                  forceUpdate(callback?: () => void): void;
                                                                                  setAnimate(animate: boolean): void;
                                                                                  destroy(): void;
                                                                                  };

                                                                                    function withGuide

                                                                                    withGuide: (
                                                                                    View: any
                                                                                    ) => new (props: any) => {
                                                                                    chart: Chart;
                                                                                    triggerRef: Ref;
                                                                                    willMount(): void;
                                                                                    didMount(): void;
                                                                                    didUpdate(): void;
                                                                                    getGuideBBox(): void;
                                                                                    parseReplaceStr(value: any, scale: any): any;
                                                                                    parsePoint(record: any): any;
                                                                                    convertPoints(records: any): any;
                                                                                    getGuideTheme(): any;
                                                                                    render(): import('../..').JSX.Element;
                                                                                    props: any;
                                                                                    state: any;
                                                                                    context: import('../../base/component').ComponentContext;
                                                                                    refs: { [key: string]: Component<any, any> };
                                                                                    updater: import('../../base/component').Updater<any>;
                                                                                    children: import('../..').JSX.Element;
                                                                                    container: any;
                                                                                    animate: boolean;
                                                                                    destroyed: boolean;
                                                                                    willReceiveProps(_props: any, context?: any): void;
                                                                                    willUpdate(): void;
                                                                                    didUnmount(): void;
                                                                                    setState(partialState: any, callback?: () => void): void;
                                                                                    forceUpdate(callback?: () => void): void;
                                                                                    setAnimate(animate: boolean): void;
                                                                                    destroy(): void;
                                                                                    };

                                                                                      function withInterval

                                                                                      withInterval: (
                                                                                      Views: any
                                                                                      ) => new (props: import('../geometry/interface').GeometryProps, context?: any) => {
                                                                                      getDefaultCfg(): {
                                                                                      geomType: string;
                                                                                      justifyContent: boolean;
                                                                                      startOnZero: boolean;
                                                                                      };
                                                                                      getDefaultSize(): number;
                                                                                      mapping(): any[];
                                                                                      getPointY0(): any;
                                                                                      render(): import('../..').JSX.Element;
                                                                                      isGeometry: boolean;
                                                                                      geomType: import('../geometry/interface').GeomType;
                                                                                      attrs: any;
                                                                                      adjust: import('../geometry').AdjustProp;
                                                                                      dataArray: any;
                                                                                      records: any[];
                                                                                      mappedArray: any;
                                                                                      justifyContent: boolean;
                                                                                      startOnZero: boolean;
                                                                                      connectNulls: boolean;
                                                                                      sortable: boolean;
                                                                                      attrController: import('../../controller/attr').default;
                                                                                      animation: import('../../canvas/animation/interface').AnimationCycle;
                                                                                      willReceiveProps(nextProps: any): void;
                                                                                      willMount(): void;
                                                                                      willUpdate(): void;
                                                                                      didMount(): void;
                                                                                      _createAttrs(): void;
                                                                                      _getThemeAttrsRange(): {
                                                                                      x: import('../../coord/types').Range;
                                                                                      y: import('../../coord/types').Range;
                                                                                      color: any;
                                                                                      size: any;
                                                                                      shape: any;
                                                                                      };
                                                                                      _adjustScales(): void;
                                                                                      _groupData(data: any): any[];
                                                                                      _saveOrigin(originData: any): any[];
                                                                                      _numberic(data: any): void;
                                                                                      _adjustData(records: any): any;
                                                                                      _updateStackRange(field: any, scale: any, dataArray: any): void;
                                                                                      _processData(): void;
                                                                                      _sortData(records: any): void;
                                                                                      _initEvent(): void;
                                                                                      getY0Value(): any;
                                                                                      _getShapeStyle(shape: any, origin: any): any;
                                                                                      _mapping(records: any): any;
                                                                                      getClip(): {
                                                                                      type: string;
                                                                                      attrs: { x: number; y: number; width: number; height: number };
                                                                                      };
                                                                                      getAttr(attrName: string): any;
                                                                                      getXScale(): any;
                                                                                      getYScale(): any;
                                                                                      _getXSnap(invertPointX: any): any;
                                                                                      _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                      flatRecords(): any;
                                                                                      getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                      getLegendItems(): any;
                                                                                      isSelected(record: any): boolean;
                                                                                      getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                                                                                      props: import('../geometry/interface').GeometryProps;
                                                                                      state: import('../geometry/selection').SelectionState;
                                                                                      context: import('../../base/component').ComponentContext;
                                                                                      refs: { [key: string]: Component<any, any> };
                                                                                      updater: import('../../base/component').Updater<
                                                                                      import('../geometry/selection').SelectionState
                                                                                      >;
                                                                                      children: import('../..').JSX.Element;
                                                                                      container: any;
                                                                                      animate: boolean;
                                                                                      destroyed: boolean;
                                                                                      didUpdate(): void;
                                                                                      didUnmount(): void;
                                                                                      setState(
                                                                                      partialState: import('../geometry/selection').SelectionState,
                                                                                      callback?: () => void
                                                                                      ): void;
                                                                                      forceUpdate(callback?: () => void): void;
                                                                                      setAnimate(animate: boolean): void;
                                                                                      destroy(): void;
                                                                                      };

                                                                                        function withLegend

                                                                                        withLegend: (
                                                                                        View: any
                                                                                        ) => new (props: any) => {
                                                                                        style: Style;
                                                                                        itemWidth: Number;
                                                                                        getOriginItems(): any;
                                                                                        getItems(): any;
                                                                                        setItems(items: any): void;
                                                                                        getMaxItemBox(legendShape: any): { width: number; height: number };
                                                                                        _init(): void;
                                                                                        updateCoord(): void;
                                                                                        willMount(): void;
                                                                                        didMount(): void;
                                                                                        willUpdate(): void;
                                                                                        _initEvent(): void;
                                                                                        render(): import('../..').JSX.Element;
                                                                                        props: LegendProps;
                                                                                        state: any;
                                                                                        context: import('../../base/component').ComponentContext;
                                                                                        refs: { [key: string]: Component<any, any> };
                                                                                        updater: import('../../base/component').Updater<any>;
                                                                                        children: import('../..').JSX.Element;
                                                                                        container: any;
                                                                                        animate: boolean;
                                                                                        destroyed: boolean;
                                                                                        willReceiveProps(_props: LegendProps, context?: LegendProps): void;
                                                                                        didUpdate(): void;
                                                                                        didUnmount(): void;
                                                                                        setState(partialState: any, callback?: () => void): void;
                                                                                        forceUpdate(callback?: () => void): void;
                                                                                        setAnimate(animate: boolean): void;
                                                                                        destroy(): void;
                                                                                        };

                                                                                          function withLine

                                                                                          withLine: (
                                                                                          View: any
                                                                                          ) => new (props: LineProps, context?: any) => {
                                                                                          getDefaultCfg(): { geomType: string; sortable: boolean };
                                                                                          splitPoints(points: any): any[][];
                                                                                          splitNulls(points: any, connectNulls: any): any[];
                                                                                          mapping(): any[];
                                                                                          render(): import('../..').JSX.Element;
                                                                                          isGeometry: boolean;
                                                                                          geomType: import('../geometry/interface').GeomType;
                                                                                          attrs: any;
                                                                                          adjust: import('../geometry').AdjustProp;
                                                                                          dataArray: any;
                                                                                          records: any[];
                                                                                          mappedArray: any;
                                                                                          justifyContent: boolean;
                                                                                          startOnZero: boolean;
                                                                                          connectNulls: boolean;
                                                                                          sortable: boolean;
                                                                                          attrController: import('../../controller/attr').default;
                                                                                          animation: import('../../canvas/animation/interface').AnimationCycle;
                                                                                          willReceiveProps(nextProps: any): void;
                                                                                          willMount(): void;
                                                                                          willUpdate(): void;
                                                                                          didMount(): void;
                                                                                          _createAttrs(): void;
                                                                                          _getThemeAttrsRange(): {
                                                                                          x: import('../../coord/types').Range;
                                                                                          y: import('../../coord/types').Range;
                                                                                          color: any;
                                                                                          size: any;
                                                                                          shape: any;
                                                                                          };
                                                                                          _adjustScales(): void;
                                                                                          _groupData(data: any): any[];
                                                                                          _saveOrigin(originData: any): any[];
                                                                                          _numberic(data: any): void;
                                                                                          _adjustData(records: any): any;
                                                                                          _updateStackRange(field: any, scale: any, dataArray: any): void;
                                                                                          _processData(): void;
                                                                                          _sortData(records: any): void;
                                                                                          _initEvent(): void;
                                                                                          getY0Value(): any;
                                                                                          _getShapeStyle(shape: any, origin: any): any;
                                                                                          _mapping(records: any): any;
                                                                                          getClip(): {
                                                                                          type: string;
                                                                                          attrs: { x: number; y: number; width: number; height: number };
                                                                                          };
                                                                                          getAttr(attrName: string): any;
                                                                                          getXScale(): any;
                                                                                          getYScale(): any;
                                                                                          _getXSnap(invertPointX: any): any;
                                                                                          _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                          flatRecords(): any;
                                                                                          getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                          getLegendItems(): any;
                                                                                          isSelected(record: any): boolean;
                                                                                          getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                                                                                          props: LineProps;
                                                                                          state: import('../geometry/selection').SelectionState;
                                                                                          context: import('../../base/component').ComponentContext;
                                                                                          refs: { [key: string]: Component<any, any> };
                                                                                          updater: import('../../base/component').Updater<
                                                                                          import('../geometry/selection').SelectionState
                                                                                          >;
                                                                                          children: import('../..').JSX.Element;
                                                                                          container: any;
                                                                                          animate: boolean;
                                                                                          destroyed: boolean;
                                                                                          didUpdate(): void;
                                                                                          didUnmount(): void;
                                                                                          setState(
                                                                                          partialState: import('../geometry/selection').SelectionState,
                                                                                          callback?: () => void
                                                                                          ): void;
                                                                                          forceUpdate(callback?: () => void): void;
                                                                                          setAnimate(animate: boolean): void;
                                                                                          destroy(): void;
                                                                                          };

                                                                                            function withPieLabel

                                                                                            withPieLabel: (
                                                                                            View: any
                                                                                            ) => new (props: any) => {
                                                                                            triggerRef: Ref;
                                                                                            labels: [];
                                                                                            willMount(): void;
                                                                                            didMount(): void;
                                                                                            getLabels(props: any): any[];
                                                                                            _handleEvent: (ev: any) => void;
                                                                                            _initEvent(): void;
                                                                                            render(): import('../..').JSX.Element;
                                                                                            props: any;
                                                                                            state: any;
                                                                                            context: import('../../base/component').ComponentContext;
                                                                                            refs: { [key: string]: Component<any, any> };
                                                                                            updater: import('../../base/component').Updater<any>;
                                                                                            children: import('../..').JSX.Element;
                                                                                            container: any;
                                                                                            animate: boolean;
                                                                                            destroyed: boolean;
                                                                                            willReceiveProps(_props: any, context?: any): void;
                                                                                            willUpdate(): void;
                                                                                            didUpdate(): void;
                                                                                            didUnmount(): void;
                                                                                            setState(partialState: any, callback?: () => void): void;
                                                                                            forceUpdate(callback?: () => void): void;
                                                                                            setAnimate(animate: boolean): void;
                                                                                            destroy(): void;
                                                                                            };

                                                                                              function withPoint

                                                                                              withPoint: (
                                                                                              View: any
                                                                                              ) => new (props: import('../geometry/interface').GeometryProps, context?: any) => {
                                                                                              getDefaultCfg(): { geomType: string };
                                                                                              render(): import('../..').JSX.Element;
                                                                                              isGeometry: boolean;
                                                                                              geomType: import('../geometry/interface').GeomType;
                                                                                              attrs: any;
                                                                                              adjust: import('../geometry').AdjustProp;
                                                                                              dataArray: any;
                                                                                              records: any[];
                                                                                              mappedArray: any;
                                                                                              justifyContent: boolean;
                                                                                              startOnZero: boolean;
                                                                                              connectNulls: boolean;
                                                                                              sortable: boolean;
                                                                                              attrController: import('../../controller/attr').default;
                                                                                              animation: import('../../canvas/animation/interface').AnimationCycle;
                                                                                              willReceiveProps(nextProps: any): void;
                                                                                              willMount(): void;
                                                                                              willUpdate(): void;
                                                                                              didMount(): void;
                                                                                              _createAttrs(): void;
                                                                                              _getThemeAttrsRange(): {
                                                                                              x: import('../../coord/types').Range;
                                                                                              y: import('../../coord/types').Range;
                                                                                              color: any;
                                                                                              size: any;
                                                                                              shape: any;
                                                                                              };
                                                                                              _adjustScales(): void;
                                                                                              _groupData(data: any): any[];
                                                                                              _saveOrigin(originData: any): any[];
                                                                                              _numberic(data: any): void;
                                                                                              _adjustData(records: any): any;
                                                                                              _updateStackRange(field: any, scale: any, dataArray: any): void;
                                                                                              _processData(): void;
                                                                                              _sortData(records: any): void;
                                                                                              _initEvent(): void;
                                                                                              getY0Value(): any;
                                                                                              _getShapeStyle(shape: any, origin: any): any;
                                                                                              _mapping(records: any): any;
                                                                                              mapping(): any[];
                                                                                              getClip(): {
                                                                                              type: string;
                                                                                              attrs: { x: number; y: number; width: number; height: number };
                                                                                              };
                                                                                              getAttr(attrName: string): any;
                                                                                              getXScale(): any;
                                                                                              getYScale(): any;
                                                                                              _getXSnap(invertPointX: any): any;
                                                                                              _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                              flatRecords(): any;
                                                                                              getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                              getLegendItems(): any;
                                                                                              isSelected(record: any): boolean;
                                                                                              getSelectionStyle(record: any): import('../../types').ShapeAttrs;
                                                                                              props: import('../geometry/interface').GeometryProps;
                                                                                              state: import('../geometry/selection').SelectionState;
                                                                                              context: import('../../base/component').ComponentContext;
                                                                                              refs: { [key: string]: Component<any, any> };
                                                                                              updater: import('../../base/component').Updater<
                                                                                              import('../geometry/selection').SelectionState
                                                                                              >;
                                                                                              children: import('../..').JSX.Element;
                                                                                              container: any;
                                                                                              animate: boolean;
                                                                                              destroyed: boolean;
                                                                                              didUpdate(): void;
                                                                                              didUnmount(): void;
                                                                                              setState(
                                                                                              partialState: import('../geometry/selection').SelectionState,
                                                                                              callback?: () => void
                                                                                              ): void;
                                                                                              forceUpdate(callback?: () => void): void;
                                                                                              setAnimate(animate: boolean): void;
                                                                                              destroy(): void;
                                                                                              };

                                                                                                function withScrollBar

                                                                                                withScrollBar: (
                                                                                                View: any
                                                                                                ) => new (props: ScrollBarProps) => {
                                                                                                willMount(): any;
                                                                                                render(): import('../..').JSX.Element;
                                                                                                startRange: { x?: import('../zoom').ZoomRange; y?: import('../zoom').ZoomRange };
                                                                                                scale: {};
                                                                                                originScale: {};
                                                                                                minScale: number;
                                                                                                dims: String[];
                                                                                                swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                                                                                loop: any;
                                                                                                didMount(): void;
                                                                                                willReceiveProps(nextProps: ScrollBarProps): void;
                                                                                                didUnmount(): void;
                                                                                                onStart: () => void;
                                                                                                onPan: (ev: any) => void;
                                                                                                update(): void;
                                                                                                onSwipe: (ev: any) => void;
                                                                                                onPinch: (ev: any) => void;
                                                                                                onEnd: () => void;
                                                                                                _doXPan(ev: any): import('../zoom').ZoomRange;
                                                                                                _doYPan(ev: any): import('../zoom').ZoomRange;
                                                                                                _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                                                                                _doXPinch(ev: any): any;
                                                                                                _doYPinch(ev: any): any;
                                                                                                _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                                                                                updateRange(
                                                                                                originalRange: import('../zoom').ZoomRange,
                                                                                                dim: any
                                                                                                ): import('../zoom').ZoomRange;
                                                                                                updateFollow(
                                                                                                scales: import('@antv/scale/lib/base').default[],
                                                                                                mainScale: any,
                                                                                                data: any[]
                                                                                                ): void;
                                                                                                _getScale(dim: any): any;
                                                                                                _getFollowScales(dim: any): any[];
                                                                                                _bindEvents(): void;
                                                                                                _clearEvents(): void;
                                                                                                props: ScrollBarProps;
                                                                                                state: import('../zoom').ZoomState;
                                                                                                context: import('../../base/component').ComponentContext;
                                                                                                refs: { [key: string]: Component<any, any> };
                                                                                                updater: import('../../base/component').Updater<import('../zoom').ZoomState>;
                                                                                                children: import('../..').JSX.Element;
                                                                                                container: any;
                                                                                                animate: boolean;
                                                                                                destroyed: boolean;
                                                                                                willUpdate(): void;
                                                                                                didUpdate(): void;
                                                                                                setState(partialState: import('../zoom').ZoomState, callback?: () => void): void;
                                                                                                forceUpdate(callback?: () => void): void;
                                                                                                setAnimate(animate: boolean): void;
                                                                                                destroy(): void;
                                                                                                };

                                                                                                  function withSunburst

                                                                                                  withSunburst: (
                                                                                                  View: any
                                                                                                  ) => new (props: any, context: any) => {
                                                                                                  coordController: CoordController;
                                                                                                  coord: Coord;
                                                                                                  color: Category;
                                                                                                  triggerRef: Ref[];
                                                                                                  didMount(): void;
                                                                                                  _mapping(children: any): void;
                                                                                                  sunburst(): any;
                                                                                                  render(): import('../..').JSX.Element;
                                                                                                  props: any;
                                                                                                  state: any;
                                                                                                  context: import('../../base/component').ComponentContext;
                                                                                                  refs: { [key: string]: Component<any, any> };
                                                                                                  updater: import('../../base/component').Updater<any>;
                                                                                                  children: import('../..').JSX.Element;
                                                                                                  container: any;
                                                                                                  animate: boolean;
                                                                                                  destroyed: boolean;
                                                                                                  willMount(): void;
                                                                                                  willReceiveProps(_props: any, context?: any): void;
                                                                                                  willUpdate(): void;
                                                                                                  didUpdate(): void;
                                                                                                  didUnmount(): void;
                                                                                                  setState(partialState: any, callback?: () => void): void;
                                                                                                  forceUpdate(callback?: () => void): void;
                                                                                                  setAnimate(animate: boolean): void;
                                                                                                  destroy(): void;
                                                                                                  };

                                                                                                    function withTooltip

                                                                                                    withTooltip: (
                                                                                                    View: any
                                                                                                    ) => new (props: TooltipProps) => {
                                                                                                    updateCoord(): void;
                                                                                                    willMount(): void;
                                                                                                    didMount(): void;
                                                                                                    willReceiveProps(nextProps: any): void;
                                                                                                    _initShow(): void;
                                                                                                    _showByData(dataItem: any): void;
                                                                                                    _triggerOn: (ev: any) => void;
                                                                                                    _triggerOff: () => void;
                                                                                                    _initEvent(): void;
                                                                                                    didUnmount(): void;
                                                                                                    _clearEvents(): void;
                                                                                                    show(point: any, _ev?: any): void;
                                                                                                    hide(): void;
                                                                                                    render(): import('../..').JSX.Element;
                                                                                                    props: TooltipProps;
                                                                                                    state: TooltipState;
                                                                                                    context: import('../../base/component').ComponentContext;
                                                                                                    refs: { [key: string]: Component<any, any> };
                                                                                                    updater: import('../../base/component').Updater<TooltipState>;
                                                                                                    children: import('../..').JSX.Element;
                                                                                                    container: any;
                                                                                                    animate: boolean;
                                                                                                    destroyed: boolean;
                                                                                                    willUpdate(): void;
                                                                                                    didUpdate(): void;
                                                                                                    setState(partialState: TooltipState, callback?: () => void): void;
                                                                                                    forceUpdate(callback?: () => void): void;
                                                                                                    setAnimate(animate: boolean): void;
                                                                                                    destroy(): void;
                                                                                                    };

                                                                                                      function withTreemap

                                                                                                      withTreemap: (
                                                                                                      View: any
                                                                                                      ) => new (props: any, context: any, updater?: any) => {
                                                                                                      coordController: CoordController;
                                                                                                      coord: Coord;
                                                                                                      color: Category;
                                                                                                      triggerRef: Ref[];
                                                                                                      treemapLayout(): any;
                                                                                                      render(): import('../..').JSX.Element;
                                                                                                      props: any;
                                                                                                      state: any;
                                                                                                      context: import('../../base/component').ComponentContext;
                                                                                                      refs: { [key: string]: Component<any, any> };
                                                                                                      updater: import('../../base/component').Updater<any>;
                                                                                                      children: import('../..').JSX.Element;
                                                                                                      container: any;
                                                                                                      animate: boolean;
                                                                                                      destroyed: boolean;
                                                                                                      willMount(): void;
                                                                                                      didMount(): void;
                                                                                                      willReceiveProps(_props: any, context?: any): void;
                                                                                                      willUpdate(): void;
                                                                                                      didUpdate(): void;
                                                                                                      didUnmount(): void;
                                                                                                      setState(partialState: any, callback?: () => void): void;
                                                                                                      forceUpdate(callback?: () => void): void;
                                                                                                      setAnimate(animate: boolean): void;
                                                                                                      destroy(): void;
                                                                                                      };

                                                                                                        Classes

                                                                                                        class Canvas

                                                                                                        class Canvas extends Component<ChartProps> {}

                                                                                                          constructor

                                                                                                          constructor(props: ChartProps);

                                                                                                            property animation

                                                                                                            animation?: Animation;

                                                                                                              property canvas

                                                                                                              canvas: GCanvas;

                                                                                                                property container

                                                                                                                container: GCanvas;

                                                                                                                  property layout

                                                                                                                  layout: Layout;

                                                                                                                    property theme

                                                                                                                    theme: any;

                                                                                                                      method destroy

                                                                                                                      destroy: () => void;

                                                                                                                        method draw

                                                                                                                        draw: () => void;

                                                                                                                          method emit

                                                                                                                          emit: (type: string, event?: any) => void;

                                                                                                                            method off

                                                                                                                            off: (type: string, listener?: any) => void;

                                                                                                                              method on

                                                                                                                              on: (type: string, listener: any) => void;

                                                                                                                                method play

                                                                                                                                play: () => void;

                                                                                                                                  method render

                                                                                                                                  render: () => any;

                                                                                                                                    method renderComponents

                                                                                                                                    renderComponents: (components: Component[]) => void;

                                                                                                                                      method resize

                                                                                                                                      resize: (width?: any, height?: any) => void;

                                                                                                                                        method update

                                                                                                                                        update: (nextProps: ChartProps) => void;

                                                                                                                                          method updateLayout

                                                                                                                                          updateLayout: (props: any) => void;

                                                                                                                                            class Chart

                                                                                                                                            class Chart extends Component implements IChart {}

                                                                                                                                              constructor

                                                                                                                                              constructor(props: any, context?: any, updater?: any);

                                                                                                                                                property data

                                                                                                                                                data: any;

                                                                                                                                                  property scale

                                                                                                                                                  scale: ScaleController;

                                                                                                                                                    method filter

                                                                                                                                                    filter: (field: string, condition: any) => void;

                                                                                                                                                      method getCoord

                                                                                                                                                      getCoord: () => Coord;

                                                                                                                                                        method getGeometrys

                                                                                                                                                        getGeometrys: () => Component<any, any>[];

                                                                                                                                                          method getLegendItems

                                                                                                                                                          getLegendItems: (point?: any) => any;

                                                                                                                                                            method getPosition

                                                                                                                                                            getPosition: (record: any) => { x: any; y: any };
                                                                                                                                                            • calculate dataset's position on canvas

                                                                                                                                                              Parameter record

                                                                                                                                                              the dataset {Object} return the position

                                                                                                                                                            method getScale

                                                                                                                                                            getScale: (field: string) => any;

                                                                                                                                                              method getScales

                                                                                                                                                              getScales: () => { [field: string]: any };

                                                                                                                                                                method getSnapRecords

                                                                                                                                                                getSnapRecords: (point: any, inCoordRange?: any) => any;

                                                                                                                                                                  method getXScales

                                                                                                                                                                  getXScales: () => any[];

                                                                                                                                                                    method getYScales

                                                                                                                                                                    getYScales: () => any[];

                                                                                                                                                                      method layoutCoord

                                                                                                                                                                      layoutCoord: (layout: PositionLayout) => void;

                                                                                                                                                                        method render

                                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                                          method resetCoordLayout

                                                                                                                                                                          resetCoordLayout: () => void;

                                                                                                                                                                            method setScale

                                                                                                                                                                            setScale: (field: string, option: ScaleConfig) => void;

                                                                                                                                                                              method updateCoordFor

                                                                                                                                                                              updateCoordFor: (
                                                                                                                                                                              component: Component,
                                                                                                                                                                              layout: PositionLayout | PositionLayout[]
                                                                                                                                                                              ) => void;

                                                                                                                                                                                method updateCoordLayout

                                                                                                                                                                                updateCoordLayout: (layout: PositionLayout | PositionLayout[]) => void;

                                                                                                                                                                                  method willReceiveProps

                                                                                                                                                                                  willReceiveProps: (nextProps: any, context: any) => void;

                                                                                                                                                                                    method willUpdate

                                                                                                                                                                                    willUpdate: () => void;

                                                                                                                                                                                      class Component

                                                                                                                                                                                      class Component<P extends IProps = any, S = any> {}

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(props: IProps, context?: ComponentContext, updater?: Updater<S>);

                                                                                                                                                                                          property animate

                                                                                                                                                                                          animate: boolean;

                                                                                                                                                                                            property children

                                                                                                                                                                                            children: JSX.Element;

                                                                                                                                                                                              property container

                                                                                                                                                                                              container: any;

                                                                                                                                                                                                property context

                                                                                                                                                                                                context: ComponentContext;

                                                                                                                                                                                                  property destroyed

                                                                                                                                                                                                  destroyed: boolean;

                                                                                                                                                                                                    property props

                                                                                                                                                                                                    props: IProps;

                                                                                                                                                                                                      property refs

                                                                                                                                                                                                      refs: { [key: string]: Component<any, any> };

                                                                                                                                                                                                        property state

                                                                                                                                                                                                        state: {};

                                                                                                                                                                                                          property updater

                                                                                                                                                                                                          updater: Updater<S>;

                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                              method didMount

                                                                                                                                                                                                              didMount: () => void;

                                                                                                                                                                                                                method didUnmount

                                                                                                                                                                                                                didUnmount: () => void;

                                                                                                                                                                                                                  method didUpdate

                                                                                                                                                                                                                  didUpdate: () => void;

                                                                                                                                                                                                                    method forceUpdate

                                                                                                                                                                                                                    forceUpdate: (callback?: () => void) => void;

                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                        method setAnimate

                                                                                                                                                                                                                        setAnimate: (animate: boolean) => void;

                                                                                                                                                                                                                          method setState

                                                                                                                                                                                                                          setState: (partialState: S, callback?: () => void) => void;

                                                                                                                                                                                                                            method willMount

                                                                                                                                                                                                                            willMount: () => void;

                                                                                                                                                                                                                              method willReceiveProps

                                                                                                                                                                                                                              willReceiveProps: (_props: P, context?: P) => void;

                                                                                                                                                                                                                                method willUpdate

                                                                                                                                                                                                                                willUpdate: () => void;

                                                                                                                                                                                                                                  class Geometry

                                                                                                                                                                                                                                  class Geometry<
                                                                                                                                                                                                                                  P extends GeometryProps = GeometryProps,
                                                                                                                                                                                                                                  S extends SelectionState = SelectionState
                                                                                                                                                                                                                                  > extends Selection<P, S> {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor(props: GeometryProps, context?: any);

                                                                                                                                                                                                                                      property adjust

                                                                                                                                                                                                                                      adjust: AdjustProp;

                                                                                                                                                                                                                                        property animation

                                                                                                                                                                                                                                        animation: AnimationCycle;

                                                                                                                                                                                                                                          property attrController

                                                                                                                                                                                                                                          attrController: AttrController;

                                                                                                                                                                                                                                            property attrs

                                                                                                                                                                                                                                            attrs: any;

                                                                                                                                                                                                                                              property connectNulls

                                                                                                                                                                                                                                              connectNulls: boolean;

                                                                                                                                                                                                                                                property dataArray

                                                                                                                                                                                                                                                dataArray: any;

                                                                                                                                                                                                                                                  property geomType

                                                                                                                                                                                                                                                  geomType: GeomType;

                                                                                                                                                                                                                                                    property isGeometry

                                                                                                                                                                                                                                                    isGeometry: boolean;

                                                                                                                                                                                                                                                      property justifyContent

                                                                                                                                                                                                                                                      justifyContent: boolean;

                                                                                                                                                                                                                                                        property mappedArray

                                                                                                                                                                                                                                                        mappedArray: any;

                                                                                                                                                                                                                                                          property records

                                                                                                                                                                                                                                                          records: any[];

                                                                                                                                                                                                                                                            property sortable

                                                                                                                                                                                                                                                            sortable: boolean;

                                                                                                                                                                                                                                                              property startOnZero

                                                                                                                                                                                                                                                              startOnZero: boolean;

                                                                                                                                                                                                                                                                method didMount

                                                                                                                                                                                                                                                                didMount: () => void;

                                                                                                                                                                                                                                                                  method flatRecords

                                                                                                                                                                                                                                                                  flatRecords: () => any;

                                                                                                                                                                                                                                                                    method getAttr

                                                                                                                                                                                                                                                                    getAttr: (attrName: string) => any;

                                                                                                                                                                                                                                                                      method getClip

                                                                                                                                                                                                                                                                      getClip: () => {
                                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                                      attrs: { x: number; y: number; width: number; height: number };
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        method getDefaultCfg

                                                                                                                                                                                                                                                                        getDefaultCfg: () => {};

                                                                                                                                                                                                                                                                          method getLegendItems

                                                                                                                                                                                                                                                                          getLegendItems: () => any;

                                                                                                                                                                                                                                                                            method getSnapRecords

                                                                                                                                                                                                                                                                            getSnapRecords: (point: any, inCoordRange?: any) => any[];

                                                                                                                                                                                                                                                                              method getXScale

                                                                                                                                                                                                                                                                              getXScale: () => Scale;

                                                                                                                                                                                                                                                                                method getY0Value

                                                                                                                                                                                                                                                                                getY0Value: () => any;

                                                                                                                                                                                                                                                                                  method getYScale

                                                                                                                                                                                                                                                                                  getYScale: () => Scale;

                                                                                                                                                                                                                                                                                    method mapping

                                                                                                                                                                                                                                                                                    mapping: () => any[];

                                                                                                                                                                                                                                                                                      method willMount

                                                                                                                                                                                                                                                                                      willMount: () => void;

                                                                                                                                                                                                                                                                                        method willReceiveProps

                                                                                                                                                                                                                                                                                        willReceiveProps: (nextProps: any) => void;

                                                                                                                                                                                                                                                                                          method willUpdate

                                                                                                                                                                                                                                                                                          willUpdate: () => void;

                                                                                                                                                                                                                                                                                            class Timeline

                                                                                                                                                                                                                                                                                            class Timeline extends Component {}

                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                              constructor(props: any);

                                                                                                                                                                                                                                                                                                property delay

                                                                                                                                                                                                                                                                                                delay: number;

                                                                                                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                                                                                                  index: number;

                                                                                                                                                                                                                                                                                                    property next

                                                                                                                                                                                                                                                                                                    next: () => void;

                                                                                                                                                                                                                                                                                                      method didMount

                                                                                                                                                                                                                                                                                                      didMount: () => void;

                                                                                                                                                                                                                                                                                                        method didUnmount

                                                                                                                                                                                                                                                                                                        didUnmount: () => void;

                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                          render: () => import('.').JSX.Element;

                                                                                                                                                                                                                                                                                                            class TooltipView

                                                                                                                                                                                                                                                                                                            class TooltipView extends Component {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(props: any);

                                                                                                                                                                                                                                                                                                                property arrowRef

                                                                                                                                                                                                                                                                                                                arrowRef: Ref;

                                                                                                                                                                                                                                                                                                                  property rootRef

                                                                                                                                                                                                                                                                                                                  rootRef: Ref;

                                                                                                                                                                                                                                                                                                                    method didMount

                                                                                                                                                                                                                                                                                                                    didMount: () => void;

                                                                                                                                                                                                                                                                                                                      method didUpdate

                                                                                                                                                                                                                                                                                                                      didUpdate: () => void;

                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                        render: () => import('../..').JSX.Element;

                                                                                                                                                                                                                                                                                                                          class Zoom

                                                                                                                                                                                                                                                                                                                          class Zoom<
                                                                                                                                                                                                                                                                                                                          P extends ZoomProps = ZoomProps,
                                                                                                                                                                                                                                                                                                                          S extends ZoomState = ZoomState
                                                                                                                                                                                                                                                                                                                          > extends Component<P, S> {}

                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                            constructor(props: ZoomProps);

                                                                                                                                                                                                                                                                                                                              property dims

                                                                                                                                                                                                                                                                                                                              dims: String[];

                                                                                                                                                                                                                                                                                                                                property loop

                                                                                                                                                                                                                                                                                                                                loop: any;

                                                                                                                                                                                                                                                                                                                                  property minScale

                                                                                                                                                                                                                                                                                                                                  minScale: number;

                                                                                                                                                                                                                                                                                                                                    property onEnd

                                                                                                                                                                                                                                                                                                                                    onEnd: () => void;

                                                                                                                                                                                                                                                                                                                                      property onPan

                                                                                                                                                                                                                                                                                                                                      onPan: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                        property onPinch

                                                                                                                                                                                                                                                                                                                                        onPinch: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                          property onStart

                                                                                                                                                                                                                                                                                                                                          onStart: () => void;

                                                                                                                                                                                                                                                                                                                                            property onSwipe

                                                                                                                                                                                                                                                                                                                                            onSwipe: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                              property originScale

                                                                                                                                                                                                                                                                                                                                              originScale: {};

                                                                                                                                                                                                                                                                                                                                                property scale

                                                                                                                                                                                                                                                                                                                                                scale: {};

                                                                                                                                                                                                                                                                                                                                                  property startRange

                                                                                                                                                                                                                                                                                                                                                  startRange: { x?: ZoomRange; y?: ZoomRange };

                                                                                                                                                                                                                                                                                                                                                    property swipeEnd

                                                                                                                                                                                                                                                                                                                                                    swipeEnd: { startX: number; startY: number; endX: number; endY: number };

                                                                                                                                                                                                                                                                                                                                                      method didMount

                                                                                                                                                                                                                                                                                                                                                      didMount: () => void;

                                                                                                                                                                                                                                                                                                                                                        method didUnmount

                                                                                                                                                                                                                                                                                                                                                        didUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                                          update: () => void;

                                                                                                                                                                                                                                                                                                                                                            method updateFollow

                                                                                                                                                                                                                                                                                                                                                            updateFollow: (scales: Scale[], mainScale: Scale, data: any[]) => void;

                                                                                                                                                                                                                                                                                                                                                              method updateRange

                                                                                                                                                                                                                                                                                                                                                              updateRange: (originalRange: ZoomRange, dim: any) => ZoomRange;

                                                                                                                                                                                                                                                                                                                                                                method willMount

                                                                                                                                                                                                                                                                                                                                                                willMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                  method willReceiveProps

                                                                                                                                                                                                                                                                                                                                                                  willReceiveProps: (nextProps: P) => void;

                                                                                                                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                                                                                                                    interface TooltipProps

                                                                                                                                                                                                                                                                                                                                                                    interface TooltipProps extends ChartChildProps {}

                                                                                                                                                                                                                                                                                                                                                                      property alwaysShow

                                                                                                                                                                                                                                                                                                                                                                      alwaysShow?: boolean;
                                                                                                                                                                                                                                                                                                                                                                      • 是否一直显示

                                                                                                                                                                                                                                                                                                                                                                      property background

                                                                                                                                                                                                                                                                                                                                                                      background?: RectAttrs;
                                                                                                                                                                                                                                                                                                                                                                      • 背景样式

                                                                                                                                                                                                                                                                                                                                                                      property crosshairsStyle

                                                                                                                                                                                                                                                                                                                                                                      crosshairsStyle?: LineAttrs;
                                                                                                                                                                                                                                                                                                                                                                      • 十字线样式

                                                                                                                                                                                                                                                                                                                                                                      property crosshairsType

                                                                                                                                                                                                                                                                                                                                                                      crosshairsType?: 'x' | 'y' | 'xy';
                                                                                                                                                                                                                                                                                                                                                                      • 十字线类型

                                                                                                                                                                                                                                                                                                                                                                      property nameStyle

                                                                                                                                                                                                                                                                                                                                                                      nameStyle?: TextAttrs;
                                                                                                                                                                                                                                                                                                                                                                      • 名称样式

                                                                                                                                                                                                                                                                                                                                                                      property padding

                                                                                                                                                                                                                                                                                                                                                                      padding?: px;
                                                                                                                                                                                                                                                                                                                                                                      • 顶部边距

                                                                                                                                                                                                                                                                                                                                                                      property showCrosshairs

                                                                                                                                                                                                                                                                                                                                                                      showCrosshairs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                      • 是否显示十字线

                                                                                                                                                                                                                                                                                                                                                                      property showItemMarker

                                                                                                                                                                                                                                                                                                                                                                      showItemMarker?: boolean;
                                                                                                                                                                                                                                                                                                                                                                      • 是否显示

                                                                                                                                                                                                                                                                                                                                                                      property snap

                                                                                                                                                                                                                                                                                                                                                                      snap?: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property triggerOff

                                                                                                                                                                                                                                                                                                                                                                        triggerOff?: string;
                                                                                                                                                                                                                                                                                                                                                                        • 消失的事件名,默认为 pressend, 可以为 touchend 等

                                                                                                                                                                                                                                                                                                                                                                        property triggerOn

                                                                                                                                                                                                                                                                                                                                                                        triggerOn?: string;
                                                                                                                                                                                                                                                                                                                                                                        • 显示事件名,默认为 press, 可以为 touchstart 等

                                                                                                                                                                                                                                                                                                                                                                        property valueStyle

                                                                                                                                                                                                                                                                                                                                                                        valueStyle?: TextAttrs;
                                                                                                                                                                                                                                                                                                                                                                        • 值样式

                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                        namespace createElement

                                                                                                                                                                                                                                                                                                                                                                        namespace createElement {}

                                                                                                                                                                                                                                                                                                                                                                          namespace createElement.JSX

                                                                                                                                                                                                                                                                                                                                                                          namespace createElement.JSX {}

                                                                                                                                                                                                                                                                                                                                                                            type Element

                                                                                                                                                                                                                                                                                                                                                                            type Element = JSXNamespace.Element;

                                                                                                                                                                                                                                                                                                                                                                              type ElementClass

                                                                                                                                                                                                                                                                                                                                                                              type ElementClass = JSXNamespace.ElementClass;

                                                                                                                                                                                                                                                                                                                                                                                type IntrinsicElements

                                                                                                                                                                                                                                                                                                                                                                                type IntrinsicElements = JSXNamespace.IntrinsicElements;

                                                                                                                                                                                                                                                                                                                                                                                  namespace jsx

                                                                                                                                                                                                                                                                                                                                                                                  namespace jsx {}

                                                                                                                                                                                                                                                                                                                                                                                    namespace JSX

                                                                                                                                                                                                                                                                                                                                                                                    namespace JSX {}

                                                                                                                                                                                                                                                                                                                                                                                      interface Element

                                                                                                                                                                                                                                                                                                                                                                                      interface Element {}

                                                                                                                                                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                                                                                                                                                        key: string;

                                                                                                                                                                                                                                                                                                                                                                                          property props

                                                                                                                                                                                                                                                                                                                                                                                          props: Props;

                                                                                                                                                                                                                                                                                                                                                                                            property ref

                                                                                                                                                                                                                                                                                                                                                                                            ref?: Ref;

                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                              type: ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementClass

                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementClass {}

                                                                                                                                                                                                                                                                                                                                                                                                    property props

                                                                                                                                                                                                                                                                                                                                                                                                    props: Props;

                                                                                                                                                                                                                                                                                                                                                                                                      property refs

                                                                                                                                                                                                                                                                                                                                                                                                      refs: {};

                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                        render: () => Element | null;

                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrinsicElements

                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrinsicElements {}

                                                                                                                                                                                                                                                                                                                                                                                                            property arc

                                                                                                                                                                                                                                                                                                                                                                                                            arc: ArcProps;

                                                                                                                                                                                                                                                                                                                                                                                                              property circle

                                                                                                                                                                                                                                                                                                                                                                                                              circle: CircleProps;

                                                                                                                                                                                                                                                                                                                                                                                                                property custom

                                                                                                                                                                                                                                                                                                                                                                                                                custom: CustomProps;

                                                                                                                                                                                                                                                                                                                                                                                                                  property group

                                                                                                                                                                                                                                                                                                                                                                                                                  group: GroupProps;

                                                                                                                                                                                                                                                                                                                                                                                                                    property image

                                                                                                                                                                                                                                                                                                                                                                                                                    image: ImageProps;

                                                                                                                                                                                                                                                                                                                                                                                                                      property line

                                                                                                                                                                                                                                                                                                                                                                                                                      line: LineProps;

                                                                                                                                                                                                                                                                                                                                                                                                                        property marker

                                                                                                                                                                                                                                                                                                                                                                                                                        marker: MarkerProps;

                                                                                                                                                                                                                                                                                                                                                                                                                          property polygon

                                                                                                                                                                                                                                                                                                                                                                                                                          polygon: PolygonProps;

                                                                                                                                                                                                                                                                                                                                                                                                                            property polyline

                                                                                                                                                                                                                                                                                                                                                                                                                            polyline: PolylineProps;

                                                                                                                                                                                                                                                                                                                                                                                                                              property rect

                                                                                                                                                                                                                                                                                                                                                                                                                              rect: RectProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                property sector

                                                                                                                                                                                                                                                                                                                                                                                                                                sector: SectorProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                                                  text: TextProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace jsx.JSX

                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace jsx.JSX {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Element

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Element = JSXNamespace.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElementClass

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElementClass = JSXNamespace.ElementClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type IntrinsicElements

                                                                                                                                                                                                                                                                                                                                                                                                                                          type IntrinsicElements = JSXNamespace.IntrinsicElements;

                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace Types

                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'es/types.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ArcProps

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ArcProps extends IntrinsicElementsProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                attrs?: ArcAttrs;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CircleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CircleProps extends IntrinsicElementsProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                    attrs?: CircleAttrs;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomProps extends IntrinsicElementsProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                        attrs?: CustomAttrs;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DataRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DataRecord {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                            origin: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                              [k: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GroupProps extends IntrinsicElementsProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attrs?: RectAttrs;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ImageProps