@antv/f2

  • Version 5.4.5
  • Published
  • 3.98 MB
  • 10 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

Type Aliases

Variables

variable ArcGuide

const ArcGuide: any;

    variable Area

    const Area: new <
    TRecord extends DataRecord = DataRecord,
    IProps extends AreaProps<TRecord> = AreaProps<TRecord>
    >(
    props: IProps & ChartChildProps<DataRecord>,
    context?: any
    ) => {
    getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
    getBaseY(): any;
    mapping(): any[];
    render(): any;
    splitPoints(points: any): any[][];
    splitNulls(points: any, connectNulls: any): any[];
    concatPoints(
    topPoints: import('../../chart').Point[],
    bottomPoints: import('../../chart').Point[]
    ): import('../../chart').Point[];
    isGeometry: boolean;
    geomType: import('../geometry').GeometryType;
    attrs: any;
    adjust: import('../geometry/Adjust').AdjustProps & {
    adjust: import('../../deps/f2-adjust/src').Adjust;
    };
    dataArray: any;
    dataRecords: any[];
    records: any[];
    mappedArray: any;
    justifyContent: boolean;
    startOnZero: boolean;
    connectNulls: boolean;
    sortable: boolean;
    attrController: import('../../controller/attr').default;
    animation: any;
    willReceiveProps(nextProps: any): void;
    willMount(): void;
    willUpdate(): void;
    didMount(): void;
    _initEvent(): void;
    _createAttrs(): void;
    _getThemeAttrsRange(): {
    x: import('../../coord/types').Range;
    y: import('../../coord/types').Range;
    color: any;
    size: any;
    shape: any;
    };
    _createAdjust(): import('../geometry/Adjust').AdjustProps & {
    adjust: import('../../deps/f2-adjust/src').Adjust;
    };
    _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;
    _readjustData(records: any): void;
    _sortData(records: any): void;
    getY0Value(): any;
    _getShapeStyle(shape: any, origin: any): any;
    _mapping(records: any): any[];
    getClip(): {
    type: string;
    style: { x: number; y: number; width: number; height: number };
    };
    getAttr(attrName: string): any;
    getXScale(): import('../..').Scale;
    getYScale(): import('../..').Scale;
    _getXSnap(invertPointX: any): any;
    _getYSnapRecords(invertPointY: any, records: any): any;
    _getXSnapRecords(invertPointX: any, records: any): any;
    flatRecords(): any;
    getSnapRecords(point: any, inCoordRange?: any): any[];
    getRecords(data: any, field?: string): any[];
    getLegendItems(): any;
    isSelected(record: any): boolean;
    getSelectionStyle(record: any): any;
    props: IProps & ChartChildProps<DataRecord>;
    state: import('../geometry/selection').SelectionState;
    context: any;
    refs: { [key: string]: any };
    updater: any;
    container: any;
    layout: any;
    children:
    | import('@antv/f-engine/es/canvas/vnode').VNode
    | import('@antv/f-engine/es/canvas/vnode').VNode[];
    isMounted: boolean;
    animate: boolean;
    animator: any;
    destroyed: boolean;
    _vNode: any;
    shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
    didUpdate(): void;
    willUnmount(): 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 <
      TRecord extends DataRecord = DataRecord,
      IProps extends AxisProps<TRecord, keyof TRecord> = AxisProps<
      TRecord,
      keyof TRecord
      >
      >(
      props: IProps & ChartChildProps<DataRecord>
      ) => {
      axisStyle: import('./types').Style<void>;
      willReceiveProps(nextProps: IProps & ChartChildProps<DataRecord>): void;
      willMount(): void;
      willUpdate(): void;
      getScaleOption(props: IProps): {
      type: string;
      tickCount: number;
      range: any;
      mask: string;
      formatter: (value: DataValue<TRecord, keyof TRecord>) => string | number;
      min: number;
      max: number;
      nice: boolean;
      ticks: any;
      };
      _getDimType(): 'x' | 'y';
      getMaxBBox(
      ticks: any,
      style: import('./types').Style<void>
      ): { height: number; width: number };
      _getPosition(): 'left' | 'top' | 'right' | 'bottom';
      getTicks(): import('../../deps/f2-scale/src').Tick[];
      _generateGridPoints(ticks: any): any;
      _setTicksStyle(ticks: any): any;
      convertTicks(ticks: any): any;
      measureLayout():
      | import('../../chart').PositionLayout
      | import('../../chart').PositionLayout[];
      updateCoord(): void;
      render(): any;
      props: IProps & ChartChildProps<DataRecord>;
      state: {};
      context: any;
      refs: { [key: string]: any };
      updater: any;
      container: any;
      layout: any;
      children:
      | import('@antv/f-engine/es/canvas/vnode').VNode
      | import('@antv/f-engine/es/canvas/vnode').VNode[];
      isMounted: boolean;
      animate: boolean;
      animator: any;
      destroyed: boolean;
      _vNode: any;
      didMount(): void;
      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
      didUpdate(): void;
      willUnmount(): void;
      didUnmount(): void;
      setState(partialState: {}, callback?: () => void): void;
      forceUpdate(callback?: () => void): void;
      setAnimate(animate: boolean): void;
      destroy(): void;
      };

        variable Candlestick

        const Candlestick: new <
        TRecord extends DataRecord = DataRecord,
        IProps extends CandlestickProps<TRecord> = CandlestickProps<TRecord>
        >(
        props: IProps & ChartChildProps<DataRecord>,
        context?: any
        ) => {
        getDefaultCfg(): { geomType: string };
        getSize(): number;
        _getColor(colors: any, child: any, prevChild: any): any;
        mapping(): any[];
        render(): any;
        isGeometry: boolean;
        geomType: import('../geometry').GeometryType;
        attrs: any;
        adjust: import('../geometry/Adjust').AdjustProps & {
        adjust: import('../../deps/f2-adjust/src').Adjust;
        };
        dataArray: any;
        dataRecords: any[];
        records: any[];
        mappedArray: any;
        justifyContent: boolean;
        startOnZero: boolean;
        connectNulls: boolean;
        sortable: boolean;
        attrController: import('../../controller/attr').default;
        animation: any;
        willReceiveProps(nextProps: any): void;
        willMount(): void;
        willUpdate(): void;
        didMount(): void;
        _initEvent(): void;
        _createAttrs(): void;
        _getThemeAttrsRange(): {
        x: import('../../coord/types').Range;
        y: import('../../coord/types').Range;
        color: any;
        size: any;
        shape: any;
        };
        _createAdjust(): import('../geometry/Adjust').AdjustProps & {
        adjust: import('../../deps/f2-adjust/src').Adjust;
        };
        _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;
        _readjustData(records: any): void;
        _sortData(records: any): void;
        getY0Value(): any;
        _getShapeStyle(shape: any, origin: any): any;
        _mapping(records: any): any[];
        getClip(): {
        type: string;
        style: { x: number; y: number; width: number; height: number };
        };
        getAttr(attrName: string): any;
        getXScale(): import('../..').Scale;
        getYScale(): import('../..').Scale;
        _getXSnap(invertPointX: any): any;
        _getYSnapRecords(invertPointY: any, records: any): any;
        _getXSnapRecords(invertPointX: any, records: any): any;
        flatRecords(): any;
        getSnapRecords(point: any, inCoordRange?: any): any[];
        getRecords(data: any, field?: string): any[];
        getLegendItems(): any;
        isSelected(record: any): boolean;
        getSelectionStyle(record: any): any;
        props: IProps & ChartChildProps<DataRecord>;
        state: import('../geometry/selection').SelectionState;
        context: any;
        refs: { [key: string]: any };
        updater: any;
        container: any;
        layout: any;
        children:
        | import('@antv/f-engine/es/canvas/vnode').VNode
        | import('@antv/f-engine/es/canvas/vnode').VNode[];
        isMounted: boolean;
        animate: boolean;
        animator: any;
        destroyed: boolean;
        _vNode: any;
        shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
        didUpdate(): void;
        willUnmount(): void;
        didUnmount(): void;
        setState(
        partialState: import('../geometry/selection').SelectionState,
        callback?: () => void
        ): void;
        forceUpdate(callback?: () => void): void;
        setAnimate(animate: boolean): void;
        destroy(): void;
        };

          variable Gauge

          const Gauge: new <P extends GaugeProps = GaugeProps>(
          props: P,
          context?: any,
          updater?: any
          ) => {
          render(): any;
          props: P;
          state: any;
          context: any;
          refs: { [key: string]: any };
          updater: any;
          container: any;
          layout: any;
          children:
          | import('@antv/f-engine/es/canvas/vnode').VNode
          | import('@antv/f-engine/es/canvas/vnode').VNode[];
          isMounted: boolean;
          animate: boolean;
          animator: any;
          destroyed: boolean;
          _vNode: any;
          willMount(): void;
          didMount(): void;
          shouldUpdate(_nextProps: P): boolean;
          willReceiveProps(_props: P, _context?: any): void;
          willUpdate(): void;
          didUpdate(): void;
          willUnmount(): void;
          didUnmount(): void;
          setState(partialState: any, callback?: () => void): void;
          forceUpdate(callback?: () => void): void;
          setAnimate(animate: boolean): void;
          destroy(): void;
          };

            variable Guide

            const Guide: any;

              variable ImageGuide

              const ImageGuide: any;

                variable Interval

                const Interval: new <
                TRecord extends DataRecord = DataRecord,
                IProps extends IntervalProps<TRecord> = IntervalProps<TRecord>
                >(
                props: IProps & ChartChildProps<DataRecord>,
                context?: any
                ) => {
                getDefaultCfg(): {
                geomType: string;
                justifyContent: boolean;
                startOnZero: boolean;
                };
                getDefaultSize(): number;
                mapping(): any[];
                getPointY0(): any;
                render(): any;
                isGeometry: boolean;
                geomType: import('../geometry').GeometryType;
                attrs: any;
                adjust: import('../geometry/Adjust').AdjustProps & {
                adjust: import('../../deps/f2-adjust/src').Adjust;
                };
                dataArray: any;
                dataRecords: any[];
                records: any[];
                mappedArray: any;
                justifyContent: boolean;
                startOnZero: boolean;
                connectNulls: boolean;
                sortable: boolean;
                attrController: import('../../controller/attr').default;
                animation: any;
                willReceiveProps(nextProps: any): void;
                willMount(): void;
                willUpdate(): void;
                didMount(): void;
                _initEvent(): void;
                _createAttrs(): void;
                _getThemeAttrsRange(): {
                x: import('../../coord/types').Range;
                y: import('../../coord/types').Range;
                color: any;
                size: any;
                shape: any;
                };
                _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                adjust: import('../../deps/f2-adjust/src').Adjust;
                };
                _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;
                _readjustData(records: any): void;
                _sortData(records: any): void;
                getY0Value(): any;
                _getShapeStyle(shape: any, origin: any): any;
                _mapping(records: any): any[];
                getClip(): {
                type: string;
                style: { x: number; y: number; width: number; height: number };
                };
                getAttr(attrName: string): any;
                getXScale(): import('../..').Scale;
                getYScale(): import('../..').Scale;
                _getXSnap(invertPointX: any): any;
                _getYSnapRecords(invertPointY: any, records: any): any;
                _getXSnapRecords(invertPointX: any, records: any): any;
                flatRecords(): any;
                getSnapRecords(point: any, inCoordRange?: any): any[];
                getRecords(data: any, field?: string): any[];
                getLegendItems(): any;
                isSelected(record: any): boolean;
                getSelectionStyle(record: any): any;
                props: IProps & ChartChildProps<DataRecord>;
                state: import('../geometry/selection').SelectionState;
                context: any;
                refs: { [key: string]: any };
                updater: any;
                container: any;
                layout: any;
                children:
                | import('@antv/f-engine/es/canvas/vnode').VNode
                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                isMounted: boolean;
                animate: boolean;
                animator: any;
                destroyed: boolean;
                _vNode: any;
                shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                didUpdate(): void;
                willUnmount(): 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 <IProps extends LegendProps = LegendProps>(props: any) => {
                  legendStyle: any;
                  itemWidth: Number;
                  getOriginItems(): any;
                  getItems(): any;
                  setItems(items: any): void;
                  getMaxItemBox(node: any): { width: number; height: number };
                  _init(): void;
                  updateCoord(): void;
                  willMount(): void;
                  didMount(): void;
                  willUpdate(): void;
                  _onclick: (item: any) => void;
                  render(): any;
                  props: IProps & ChartChildProps<DataRecord>;
                  state: any;
                  context: any;
                  refs: { [key: string]: any };
                  updater: any;
                  container: any;
                  layout: any;
                  children:
                  | import('@antv/f-engine/es/canvas/vnode').VNode
                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                  isMounted: boolean;
                  animate: boolean;
                  animator: any;
                  destroyed: boolean;
                  _vNode: any;
                  shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                  willReceiveProps(
                  _props: IProps & ChartChildProps<DataRecord>,
                  _context?: any
                  ): void;
                  didUpdate(): void;
                  willUnmount(): void;
                  didUnmount(): void;
                  setState(partialState: any, callback?: () => void): void;
                  forceUpdate(callback?: () => void): void;
                  setAnimate(animate: boolean): void;
                  destroy(): void;
                  };

                    variable Line

                    const Line: new <
                    TRecord extends DataRecord = DataRecord,
                    IProps extends LineProps<TRecord> = LineProps<TRecord>
                    >(
                    props: IProps & ChartChildProps<DataRecord>,
                    context?: any
                    ) => {
                    getDefaultCfg(): { geomType: string; sortable: boolean };
                    splitPoints(points: any): any[][];
                    splitNulls(points: any, connectNulls: any): any[];
                    mapping(): any[];
                    concatPoints(
                    topPoints: import('../../chart').Point[],
                    bottomPoints: import('../../chart').Point[]
                    ): import('../../chart').Point[];
                    render(): any;
                    isGeometry: boolean;
                    geomType: import('../geometry').GeometryType;
                    attrs: any;
                    adjust: import('../geometry/Adjust').AdjustProps & {
                    adjust: import('../../deps/f2-adjust/src').Adjust;
                    };
                    dataArray: any;
                    dataRecords: any[];
                    records: any[];
                    mappedArray: any;
                    justifyContent: boolean;
                    startOnZero: boolean;
                    connectNulls: boolean;
                    sortable: boolean;
                    attrController: import('../../controller/attr').default;
                    animation: any;
                    willReceiveProps(nextProps: any): void;
                    willMount(): void;
                    willUpdate(): void;
                    didMount(): void;
                    _initEvent(): void;
                    _createAttrs(): void;
                    _getThemeAttrsRange(): {
                    x: import('../../coord/types').Range;
                    y: import('../../coord/types').Range;
                    color: any;
                    size: any;
                    shape: any;
                    };
                    _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                    adjust: import('../../deps/f2-adjust/src').Adjust;
                    };
                    _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;
                    _readjustData(records: any): void;
                    _sortData(records: any): void;
                    getY0Value(): any;
                    _getShapeStyle(shape: any, origin: any): any;
                    _mapping(records: any): any[];
                    getClip(): {
                    type: string;
                    style: { x: number; y: number; width: number; height: number };
                    };
                    getAttr(attrName: string): any;
                    getXScale(): import('../..').Scale;
                    getYScale(): import('../..').Scale;
                    _getXSnap(invertPointX: any): any;
                    _getYSnapRecords(invertPointY: any, records: any): any;
                    _getXSnapRecords(invertPointX: any, records: any): any;
                    flatRecords(): any;
                    getSnapRecords(point: any, inCoordRange?: any): any[];
                    getRecords(data: any, field?: string): any[];
                    getLegendItems(): any;
                    isSelected(record: any): boolean;
                    getSelectionStyle(record: any): any;
                    props: IProps & ChartChildProps<DataRecord>;
                    state: import('../geometry/selection').SelectionState;
                    context: any;
                    refs: { [key: string]: any };
                    updater: any;
                    container: any;
                    layout: any;
                    children:
                    | import('@antv/f-engine/es/canvas/vnode').VNode
                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                    isMounted: boolean;
                    animate: boolean;
                    animator: any;
                    destroyed: boolean;
                    _vNode: any;
                    shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                    didUpdate(): void;
                    willUnmount(): 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: any;

                        variable LottieGuide

                        const LottieGuide: any;

                          variable PieLabel

                          const PieLabel: new <IProps extends PieLabelProps = PieLabelProps>(props: any) => {
                          labels: [];
                          willMount(): void;
                          didMount(): void;
                          getLabels(props: any): any[];
                          render(): any;
                          props: IProps & ChartChildProps<DataRecord>;
                          state: any;
                          context: any;
                          refs: { [key: string]: any };
                          updater: any;
                          container: any;
                          layout: any;
                          children:
                          | import('@antv/f-engine/es/canvas/vnode').VNode
                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                          isMounted: boolean;
                          animate: boolean;
                          animator: any;
                          destroyed: boolean;
                          _vNode: any;
                          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                          willReceiveProps(
                          _props: IProps & ChartChildProps<DataRecord>,
                          _context?: any
                          ): void;
                          willUpdate(): void;
                          didUpdate(): void;
                          willUnmount(): void;
                          didUnmount(): void;
                          setState(partialState: any, callback?: () => void): void;
                          forceUpdate(callback?: () => void): void;
                          setAnimate(animate: boolean): void;
                          destroy(): void;
                          };

                            variable Point

                            const Point: new <
                            TRecord extends DataRecord = DataRecord,
                            IProps extends PointProps<TRecord> = PointProps<TRecord>
                            >(
                            props: IProps & ChartChildProps<DataRecord>,
                            context?: any
                            ) => {
                            getDefaultCfg(): { geomType: string };
                            render(): any;
                            isGeometry: boolean;
                            geomType: import('../geometry').GeometryType;
                            attrs: any;
                            adjust: import('../geometry/Adjust').AdjustProps & {
                            adjust: import('../../deps/f2-adjust/src').Adjust;
                            };
                            dataArray: any;
                            dataRecords: any[];
                            records: any[];
                            mappedArray: any;
                            justifyContent: boolean;
                            startOnZero: boolean;
                            connectNulls: boolean;
                            sortable: boolean;
                            attrController: import('../../controller/attr').default;
                            animation: any;
                            willReceiveProps(nextProps: any): void;
                            willMount(): void;
                            willUpdate(): void;
                            didMount(): void;
                            _initEvent(): void;
                            _createAttrs(): void;
                            _getThemeAttrsRange(): {
                            x: import('../../coord/types').Range;
                            y: import('../../coord/types').Range;
                            color: any;
                            size: any;
                            shape: any;
                            };
                            _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                            adjust: import('../../deps/f2-adjust/src').Adjust;
                            };
                            _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;
                            _readjustData(records: any): void;
                            _sortData(records: any): void;
                            getY0Value(): any;
                            _getShapeStyle(shape: any, origin: any): any;
                            _mapping(records: any): any[];
                            mapping(): any[];
                            getClip(): {
                            type: string;
                            style: { x: number; y: number; width: number; height: number };
                            };
                            getAttr(attrName: string): any;
                            getXScale(): import('../..').Scale;
                            getYScale(): import('../..').Scale;
                            _getXSnap(invertPointX: any): any;
                            _getYSnapRecords(invertPointY: any, records: any): any;
                            _getXSnapRecords(invertPointX: any, records: any): any;
                            flatRecords(): any;
                            getSnapRecords(point: any, inCoordRange?: any): any[];
                            getRecords(data: any, field?: string): any[];
                            getLegendItems(): any;
                            isSelected(record: any): boolean;
                            getSelectionStyle(record: any): any;
                            props: IProps & ChartChildProps<DataRecord>;
                            state: import('../geometry/selection').SelectionState;
                            context: any;
                            refs: { [key: string]: any };
                            updater: any;
                            container: any;
                            layout: any;
                            children:
                            | import('@antv/f-engine/es/canvas/vnode').VNode
                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                            isMounted: boolean;
                            animate: boolean;
                            animator: any;
                            destroyed: boolean;
                            _vNode: any;
                            shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                            didUpdate(): void;
                            willUnmount(): 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: any;

                                variable RectGuide

                                const RectGuide: any;

                                  variable ScrollBar

                                  const ScrollBar: new (
                                  props: ScrollBarProps &
                                  import('../../chart').ChartChildProps<import('../../chart/Data').DataRecord>
                                  ) => {
                                  willMount(): any;
                                  render(): any;
                                  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: number;
                                  didMount(): void;
                                  willReceiveProps(
                                  nextProps: ScrollBarProps &
                                  import('../../chart').ChartChildProps<
                                  import('../../chart/Data').DataRecord
                                  >
                                  ): void;
                                  willUpdate(): void;
                                  didUnmount(): void;
                                  _requestAnimationFrame(calllback: Function): number;
                                  _cancelAnimationFrame(): void;
                                  onPanStart: () => void;
                                  onPan: (ev: any) => void;
                                  onPanEnd: () => void;
                                  onPinchStart: () => void;
                                  onPinch: (ev: any) => void;
                                  onPinchEnd: () => void;
                                  _bindEvents(): void;
                                  _unBindEvents(): void;
                                  onStart: () => void;
                                  update(): void;
                                  animateSwipe(
                                  dim: string,
                                  dimRange: import('../zoom').ZoomRange,
                                  velocity: number
                                  ): void;
                                  onSwipe: (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('../..').Scale[],
                                  mainScale: import('../..').Scale,
                                  data: any[]
                                  ): void;
                                  _getScale(dim: any): any;
                                  _getFollowScales(dim: any): any[];
                                  renderRange(range: any): void;
                                  props: ScrollBarProps &
                                  import('../../chart').ChartChildProps<import('../../chart/Data').DataRecord>;
                                  state: import('../zoom').ZoomState;
                                  context: any;
                                  refs: { [key: string]: any };
                                  updater: any;
                                  container: any;
                                  layout: any;
                                  children:
                                  | import('@antv/f-engine/es/canvas/vnode').VNode
                                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                  isMounted: boolean;
                                  animate: boolean;
                                  animator: any;
                                  destroyed: boolean;
                                  _vNode: any;
                                  shouldUpdate(
                                  _nextProps: ScrollBarProps &
                                  import('../../chart').ChartChildProps<
                                  import('../../chart/Data').DataRecord
                                  >
                                  ): boolean;
                                  didUpdate(): void;
                                  willUnmount(): void;
                                  setState(partialState: import('../zoom').ZoomState, callback?: () => void): void;
                                  forceUpdate(callback?: () => void): void;
                                  setAnimate(animate: boolean): void;
                                  destroy(): void;
                                  };

                                    variable Sunburst

                                    const Sunburst: new <
                                    TRecord extends DataRecord = DataRecord,
                                    IProps extends SunburstProps<TRecord> = SunburstProps<TRecord>
                                    >(
                                    props: IProps,
                                    context: any
                                    ) => {
                                    coord: import('../../controller/coord').default;
                                    color: import('../../attr/category').default;
                                    triggerRef: import('@antv/f-engine').Ref<any>[];
                                    willMount(): void;
                                    didMount(): void;
                                    _mapping(children: any): void;
                                    sunburst(): any;
                                    render(): any;
                                    props: IProps;
                                    state: any;
                                    context: any;
                                    refs: { [key: string]: any };
                                    updater: any;
                                    container: any;
                                    layout: any;
                                    children:
                                    | import('@antv/f-engine/es/canvas/vnode').VNode
                                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                    isMounted: boolean;
                                    animate: boolean;
                                    animator: any;
                                    destroyed: boolean;
                                    _vNode: any;
                                    shouldUpdate(_nextProps: IProps): boolean;
                                    willReceiveProps(_props: IProps, _context?: any): void;
                                    willUpdate(): void;
                                    didUpdate(): void;
                                    willUnmount(): void;
                                    didUnmount(): void;
                                    setState(partialState: any, callback?: () => void): void;
                                    forceUpdate(callback?: () => void): void;
                                    setAnimate(animate: boolean): void;
                                    destroy(): void;
                                    };

                                      variable TagGuide

                                      const TagGuide: any;

                                        variable TextGuide

                                        const TextGuide: any;

                                          variable Tooltip

                                          const Tooltip: new <IProps extends TooltipProps = TooltipProps>(
                                          props: IProps & ChartChildProps<DataRecord>
                                          ) => {
                                          updateCoord(): void;
                                          willMount(): void;
                                          didMount(): void;
                                          _initEvent(): void;
                                          willReceiveProps(nextProps: any): void;
                                          _initShow(): void;
                                          _showByData(dataItem: any): void;
                                          _triggerOn: (ev: any) => void;
                                          _triggerOff: () => void;
                                          show(point: any, _ev?: any): void;
                                          showSnapRecords(snapRecords: any): void;
                                          hide(): void;
                                          render(): any;
                                          props: IProps & ChartChildProps<DataRecord>;
                                          state: import('./withTooltip').TooltipState;
                                          context: any;
                                          refs: { [key: string]: any };
                                          updater: any;
                                          container: any;
                                          layout: any;
                                          children:
                                          | import('@antv/f-engine/es/canvas/vnode').VNode
                                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                          isMounted: boolean;
                                          animate: boolean;
                                          animator: any;
                                          destroyed: boolean;
                                          _vNode: any;
                                          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                          willUpdate(): void;
                                          didUpdate(): void;
                                          willUnmount(): void;
                                          didUnmount(): void;
                                          setState(
                                          partialState: import('./withTooltip').TooltipState,
                                          callback?: () => void
                                          ): void;
                                          forceUpdate(callback?: () => void): void;
                                          setAnimate(animate: boolean): void;
                                          destroy(): void;
                                          };

                                            variable Treemap

                                            const Treemap: new <
                                            TRecord extends DataRecord = DataRecord,
                                            P extends TreemapProps<TRecord> = TreemapProps<TRecord>
                                            >(
                                            props: P & TreemapProps<DataRecord>,
                                            context: any
                                            ) => {
                                            coord: import('../../controller/coord').default;
                                            color: import('../../attr/category').default;
                                            coordRef: any;
                                            records: import('./withTreemap').RecordNode<
                                            import('../../chart/Data').DataRecord
                                            >[];
                                            isSelected(record: any): boolean;
                                            getSelectionStyle(record: any): any;
                                            willMount(): void;
                                            willReceiveProps(nextProps: P): void;
                                            treemapLayout(): import('./withTreemap').RecordNode<
                                            import('../../chart/Data').DataRecord
                                            >[];
                                            select(ev: any, trigger: any): void;
                                            render(): any;
                                            props: P & TreemapProps<DataRecord>;
                                            state: any;
                                            context: any;
                                            refs: { [key: string]: any };
                                            updater: any;
                                            container: any;
                                            layout: any;
                                            children:
                                            | import('@antv/f-engine/es/canvas/vnode').VNode
                                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                            isMounted: boolean;
                                            animate: boolean;
                                            animator: any;
                                            destroyed: boolean;
                                            _vNode: any;
                                            didMount(): void;
                                            shouldUpdate(_nextProps: P & TreemapProps<DataRecord>): boolean;
                                            willUpdate(): void;
                                            didUpdate(): void;
                                            willUnmount(): 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) => any;

                                                function AxisView

                                                AxisView: (props: PolarAxisProps | RectAxisProps) => any;

                                                  function CandlestickView

                                                  CandlestickView: (props: any) => any;

                                                    function GaugeView

                                                    GaugeView: (props: GaugeProps) => any;

                                                      function IntervalView

                                                      IntervalView: (props: any) => any;

                                                        function LegendView

                                                        LegendView: (props: any) => any;

                                                          function LineView

                                                          LineView: (props: any) => any;

                                                            function PieLabelView

                                                            PieLabelView: (props: any) => any;

                                                              function PointView

                                                              PointView: (props: any) => any;

                                                                function ScrollBarView

                                                                ScrollBarView: (props: any) => any;

                                                                  function SunburstView

                                                                  SunburstView: (props: any) => any;

                                                                    function TreemapView

                                                                    TreemapView: (props: TreemapProps<DataRecord> & { coord: Coord }) => any;

                                                                      function withArea

                                                                      withArea: (
                                                                      View: any
                                                                      ) => new <
                                                                      TRecord extends DataRecord = DataRecord,
                                                                      IProps extends AreaProps<TRecord> = AreaProps<TRecord>
                                                                      >(
                                                                      props: IProps & ChartChildProps<DataRecord>,
                                                                      context?: any
                                                                      ) => {
                                                                      getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
                                                                      getBaseY(): any;
                                                                      mapping(): any[];
                                                                      render(): any;
                                                                      splitPoints(points: any): any[][];
                                                                      splitNulls(points: any, connectNulls: any): any[];
                                                                      concatPoints(
                                                                      topPoints: import('../../chart').Point[],
                                                                      bottomPoints: import('../../chart').Point[]
                                                                      ): import('../../chart').Point[];
                                                                      isGeometry: boolean;
                                                                      geomType: import('../geometry').GeometryType;
                                                                      attrs: any;
                                                                      adjust: import('../geometry/Adjust').AdjustProps & {
                                                                      adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                      };
                                                                      dataArray: any;
                                                                      dataRecords: any[];
                                                                      records: any[];
                                                                      mappedArray: any;
                                                                      justifyContent: boolean;
                                                                      startOnZero: boolean;
                                                                      connectNulls: boolean;
                                                                      sortable: boolean;
                                                                      attrController: import('../../controller/attr').default;
                                                                      animation: any;
                                                                      willReceiveProps(nextProps: any): void;
                                                                      willMount(): void;
                                                                      willUpdate(): void;
                                                                      didMount(): void;
                                                                      _initEvent(): void;
                                                                      _createAttrs(): void;
                                                                      _getThemeAttrsRange(): {
                                                                      x: import('../../coord/types').Range;
                                                                      y: import('../../coord/types').Range;
                                                                      color: any;
                                                                      size: any;
                                                                      shape: any;
                                                                      };
                                                                      _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                      adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                      };
                                                                      _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;
                                                                      _readjustData(records: any): void;
                                                                      _sortData(records: any): void;
                                                                      getY0Value(): any;
                                                                      _getShapeStyle(shape: any, origin: any): any;
                                                                      _mapping(records: any): any[];
                                                                      getClip(): {
                                                                      type: string;
                                                                      style: { x: number; y: number; width: number; height: number };
                                                                      };
                                                                      getAttr(attrName: string): any;
                                                                      getXScale(): import('../..').Scale;
                                                                      getYScale(): import('../..').Scale;
                                                                      _getXSnap(invertPointX: any): any;
                                                                      _getYSnapRecords(invertPointY: any, records: any): any;
                                                                      _getXSnapRecords(invertPointX: any, records: any): any;
                                                                      flatRecords(): any;
                                                                      getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                      getRecords(data: any, field?: string): any[];
                                                                      getLegendItems(): any;
                                                                      isSelected(record: any): boolean;
                                                                      getSelectionStyle(record: any): any;
                                                                      props: IProps & ChartChildProps<DataRecord>;
                                                                      state: import('../geometry/selection').SelectionState;
                                                                      context: any;
                                                                      refs: { [key: string]: any };
                                                                      updater: any;
                                                                      container: any;
                                                                      layout: any;
                                                                      children:
                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                      isMounted: boolean;
                                                                      animate: boolean;
                                                                      animator: any;
                                                                      destroyed: boolean;
                                                                      _vNode: any;
                                                                      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                      didUpdate(): void;
                                                                      willUnmount(): 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 <
                                                                        TRecord extends DataRecord = DataRecord,
                                                                        IProps extends AxisProps<TRecord, keyof TRecord> = AxisProps<
                                                                        TRecord,
                                                                        keyof TRecord
                                                                        >
                                                                        >(
                                                                        props: IProps & ChartChildProps<DataRecord>
                                                                        ) => {
                                                                        axisStyle: Style;
                                                                        willReceiveProps(nextProps: IProps & ChartChildProps<DataRecord>): void;
                                                                        willMount(): void;
                                                                        willUpdate(): void;
                                                                        getScaleOption(props: IProps): {
                                                                        type: string;
                                                                        tickCount: number;
                                                                        range: any;
                                                                        mask: string;
                                                                        formatter: (value: DataValue<TRecord, keyof TRecord>) => string | number;
                                                                        min: number;
                                                                        max: number;
                                                                        nice: boolean;
                                                                        ticks: any;
                                                                        };
                                                                        _getDimType(): 'x' | 'y';
                                                                        getMaxBBox(ticks: any, style: Style): BBox;
                                                                        _getPosition(): 'left' | 'top' | 'right' | 'bottom';
                                                                        getTicks(): import('../../deps/f2-scale/src').Tick[];
                                                                        _generateGridPoints(ticks: any): any;
                                                                        _setTicksStyle(ticks: any): any;
                                                                        convertTicks(ticks: any): any;
                                                                        measureLayout(): PositionLayout | PositionLayout[];
                                                                        updateCoord(): void;
                                                                        render(): any;
                                                                        props: IProps & ChartChildProps<DataRecord>;
                                                                        state: {};
                                                                        context: any;
                                                                        refs: { [key: string]: Component<any, any> };
                                                                        updater: any;
                                                                        container: any;
                                                                        layout: any;
                                                                        children:
                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                        isMounted: boolean;
                                                                        animate: boolean;
                                                                        animator: any;
                                                                        destroyed: boolean;
                                                                        _vNode: any;
                                                                        didMount(): void;
                                                                        shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                        didUpdate(): void;
                                                                        willUnmount(): void;
                                                                        didUnmount(): void;
                                                                        setState(partialState: {}, callback?: () => void): void;
                                                                        forceUpdate(callback?: () => void): void;
                                                                        setAnimate(animate: boolean): void;
                                                                        destroy(): void;
                                                                        };

                                                                          function withCandlestick

                                                                          withCandlestick: (
                                                                          View: ComponentType
                                                                          ) => new <
                                                                          TRecord extends DataRecord = DataRecord,
                                                                          IProps extends CandlestickProps<TRecord> = CandlestickProps<TRecord>
                                                                          >(
                                                                          props: IProps & ChartChildProps<DataRecord>,
                                                                          context?: any
                                                                          ) => {
                                                                          getDefaultCfg(): { geomType: string };
                                                                          getSize(): number;
                                                                          _getColor(colors: any, child: any, prevChild: any): any;
                                                                          mapping(): any[];
                                                                          render(): any;
                                                                          isGeometry: boolean;
                                                                          geomType: import('../geometry').GeometryType;
                                                                          attrs: any;
                                                                          adjust: import('../geometry/Adjust').AdjustProps & {
                                                                          adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                          };
                                                                          dataArray: any;
                                                                          dataRecords: any[];
                                                                          records: any[];
                                                                          mappedArray: any;
                                                                          justifyContent: boolean;
                                                                          startOnZero: boolean;
                                                                          connectNulls: boolean;
                                                                          sortable: boolean;
                                                                          attrController: import('../../controller/attr').default;
                                                                          animation: any;
                                                                          willReceiveProps(nextProps: any): void;
                                                                          willMount(): void;
                                                                          willUpdate(): void;
                                                                          didMount(): void;
                                                                          _initEvent(): void;
                                                                          _createAttrs(): void;
                                                                          _getThemeAttrsRange(): {
                                                                          x: import('../../coord/types').Range;
                                                                          y: import('../../coord/types').Range;
                                                                          color: any;
                                                                          size: any;
                                                                          shape: any;
                                                                          };
                                                                          _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                          adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                          };
                                                                          _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;
                                                                          _readjustData(records: any): void;
                                                                          _sortData(records: any): void;
                                                                          getY0Value(): any;
                                                                          _getShapeStyle(shape: any, origin: any): any;
                                                                          _mapping(records: any): any[];
                                                                          getClip(): {
                                                                          type: string;
                                                                          style: { x: number; y: number; width: number; height: number };
                                                                          };
                                                                          getAttr(attrName: string): any;
                                                                          getXScale(): import('../..').Scale;
                                                                          getYScale(): import('../..').Scale;
                                                                          _getXSnap(invertPointX: any): any;
                                                                          _getYSnapRecords(invertPointY: any, records: any): any;
                                                                          _getXSnapRecords(invertPointX: any, records: any): any;
                                                                          flatRecords(): any;
                                                                          getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                          getRecords(data: any, field?: string): any[];
                                                                          getLegendItems(): any;
                                                                          isSelected(record: any): boolean;
                                                                          getSelectionStyle(record: any): any;
                                                                          props: IProps & ChartChildProps<DataRecord>;
                                                                          state: import('../geometry/selection').SelectionState;
                                                                          context: any;
                                                                          refs: { [key: string]: any };
                                                                          updater: any;
                                                                          container: any;
                                                                          layout: any;
                                                                          children:
                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                          isMounted: boolean;
                                                                          animate: boolean;
                                                                          animator: any;
                                                                          destroyed: boolean;
                                                                          _vNode: any;
                                                                          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                          didUpdate(): void;
                                                                          willUnmount(): void;
                                                                          didUnmount(): void;
                                                                          setState(
                                                                          partialState: import('../geometry/selection').SelectionState,
                                                                          callback?: () => void
                                                                          ): void;
                                                                          forceUpdate(callback?: () => void): void;
                                                                          setAnimate(animate: boolean): void;
                                                                          destroy(): void;
                                                                          };

                                                                            function withGauge

                                                                            withGauge: <IProps extends GaugeProps = GaugeProps>(
                                                                            View: ComponentType<IProps>
                                                                            ) => new <P extends IProps = IProps>(props: P, context?: any, updater?: any) => {
                                                                            render(): any;
                                                                            props: P;
                                                                            state: any;
                                                                            context: any;
                                                                            refs: { [key: string]: Component<any, any> };
                                                                            updater: any;
                                                                            container: any;
                                                                            layout: any;
                                                                            children:
                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                            isMounted: boolean;
                                                                            animate: boolean;
                                                                            animator: any;
                                                                            destroyed: boolean;
                                                                            _vNode: any;
                                                                            willMount(): void;
                                                                            didMount(): void;
                                                                            shouldUpdate(_nextProps: P): boolean;
                                                                            willReceiveProps(_props: P, _context?: any): void;
                                                                            willUpdate(): void;
                                                                            didUpdate(): void;
                                                                            willUnmount(): void;
                                                                            didUnmount(): void;
                                                                            setState(partialState: any, callback?: () => void): void;
                                                                            forceUpdate(callback?: () => void): void;
                                                                            setAnimate(animate: boolean): void;
                                                                            destroy(): void;
                                                                            };

                                                                              function withGuide

                                                                              withGuide: <IProps extends GuideProps = GuideProps>(
                                                                              View: ComponentType<IProps & ChartChildProps<DataRecord>>
                                                                              ) => ComponentType<IProps & ChartChildProps<DataRecord>>;

                                                                                function withInterval

                                                                                withInterval: (
                                                                                Views: any
                                                                                ) => new <
                                                                                TRecord extends DataRecord = DataRecord,
                                                                                IProps extends IntervalProps<TRecord> = IntervalProps<TRecord>
                                                                                >(
                                                                                props: IProps & ChartChildProps<DataRecord>,
                                                                                context?: any
                                                                                ) => {
                                                                                getDefaultCfg(): {
                                                                                geomType: string;
                                                                                justifyContent: boolean;
                                                                                startOnZero: boolean;
                                                                                };
                                                                                getDefaultSize(): number;
                                                                                mapping(): any[];
                                                                                getPointY0(): any;
                                                                                render(): any;
                                                                                isGeometry: boolean;
                                                                                geomType: import('../geometry').GeometryType;
                                                                                attrs: any;
                                                                                adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                };
                                                                                dataArray: any;
                                                                                dataRecords: any[];
                                                                                records: any[];
                                                                                mappedArray: any;
                                                                                justifyContent: boolean;
                                                                                startOnZero: boolean;
                                                                                connectNulls: boolean;
                                                                                sortable: boolean;
                                                                                attrController: import('../../controller/attr').default;
                                                                                animation: any;
                                                                                willReceiveProps(nextProps: any): void;
                                                                                willMount(): void;
                                                                                willUpdate(): void;
                                                                                didMount(): void;
                                                                                _initEvent(): void;
                                                                                _createAttrs(): void;
                                                                                _getThemeAttrsRange(): {
                                                                                x: import('../../coord/types').Range;
                                                                                y: import('../../coord/types').Range;
                                                                                color: any;
                                                                                size: any;
                                                                                shape: any;
                                                                                };
                                                                                _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                };
                                                                                _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;
                                                                                _readjustData(records: any): void;
                                                                                _sortData(records: any): void;
                                                                                getY0Value(): any;
                                                                                _getShapeStyle(shape: any, origin: any): any;
                                                                                _mapping(records: any): any[];
                                                                                getClip(): {
                                                                                type: string;
                                                                                style: { x: number; y: number; width: number; height: number };
                                                                                };
                                                                                getAttr(attrName: string): any;
                                                                                getXScale(): import('../..').Scale;
                                                                                getYScale(): import('../..').Scale;
                                                                                _getXSnap(invertPointX: any): any;
                                                                                _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                flatRecords(): any;
                                                                                getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                getRecords(data: any, field?: string): any[];
                                                                                getLegendItems(): any;
                                                                                isSelected(record: any): boolean;
                                                                                getSelectionStyle(record: any): any;
                                                                                props: IProps & ChartChildProps<DataRecord>;
                                                                                state: import('../geometry/selection').SelectionState;
                                                                                context: any;
                                                                                refs: { [key: string]: any };
                                                                                updater: any;
                                                                                container: any;
                                                                                layout: any;
                                                                                children:
                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                isMounted: boolean;
                                                                                animate: boolean;
                                                                                animator: any;
                                                                                destroyed: boolean;
                                                                                _vNode: any;
                                                                                shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                didUpdate(): void;
                                                                                willUnmount(): 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 <IProps extends LegendProps = LegendProps>(props: any) => {
                                                                                  legendStyle: GroupStyleProps;
                                                                                  itemWidth: Number;
                                                                                  getOriginItems(): any;
                                                                                  getItems(): any;
                                                                                  setItems(items: any): void;
                                                                                  getMaxItemBox(node: any): { width: number; height: number };
                                                                                  _init(): void;
                                                                                  updateCoord(): void;
                                                                                  willMount(): void;
                                                                                  didMount(): void;
                                                                                  willUpdate(): void;
                                                                                  _onclick: (item: any) => void;
                                                                                  render(): any;
                                                                                  props: IProps & ChartChildProps<DataRecord>;
                                                                                  state: any;
                                                                                  context: any;
                                                                                  refs: { [key: string]: Component<any, any> };
                                                                                  updater: any;
                                                                                  container: any;
                                                                                  layout: any;
                                                                                  children:
                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                  isMounted: boolean;
                                                                                  animate: boolean;
                                                                                  animator: any;
                                                                                  destroyed: boolean;
                                                                                  _vNode: any;
                                                                                  shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                  willReceiveProps(
                                                                                  _props: IProps & ChartChildProps<DataRecord>,
                                                                                  _context?: any
                                                                                  ): void;
                                                                                  didUpdate(): void;
                                                                                  willUnmount(): 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 <
                                                                                    TRecord extends DataRecord = DataRecord,
                                                                                    IProps extends LineProps<TRecord> = LineProps<TRecord>
                                                                                    >(
                                                                                    props: IProps & ChartChildProps<DataRecord>,
                                                                                    context?: any
                                                                                    ) => {
                                                                                    getDefaultCfg(): { geomType: string; sortable: boolean };
                                                                                    splitPoints(points: any): any[][];
                                                                                    splitNulls(points: any, connectNulls: any): any[];
                                                                                    mapping(): any[];
                                                                                    concatPoints(topPoints: Point[], bottomPoints: Point[]): Point[];
                                                                                    render(): any;
                                                                                    isGeometry: boolean;
                                                                                    geomType: import('../geometry').GeometryType;
                                                                                    attrs: any;
                                                                                    adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                    adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                    };
                                                                                    dataArray: any;
                                                                                    dataRecords: any[];
                                                                                    records: any[];
                                                                                    mappedArray: any;
                                                                                    justifyContent: boolean;
                                                                                    startOnZero: boolean;
                                                                                    connectNulls: boolean;
                                                                                    sortable: boolean;
                                                                                    attrController: import('../../controller/attr').default;
                                                                                    animation: any;
                                                                                    willReceiveProps(nextProps: any): void;
                                                                                    willMount(): void;
                                                                                    willUpdate(): void;
                                                                                    didMount(): void;
                                                                                    _initEvent(): void;
                                                                                    _createAttrs(): void;
                                                                                    _getThemeAttrsRange(): {
                                                                                    x: import('../../coord/types').Range;
                                                                                    y: import('../../coord/types').Range;
                                                                                    color: any;
                                                                                    size: any;
                                                                                    shape: any;
                                                                                    };
                                                                                    _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                    adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                    };
                                                                                    _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;
                                                                                    _readjustData(records: any): void;
                                                                                    _sortData(records: any): void;
                                                                                    getY0Value(): any;
                                                                                    _getShapeStyle(shape: any, origin: any): any;
                                                                                    _mapping(records: any): any[];
                                                                                    getClip(): {
                                                                                    type: string;
                                                                                    style: { x: number; y: number; width: number; height: number };
                                                                                    };
                                                                                    getAttr(attrName: string): any;
                                                                                    getXScale(): import('../..').Scale;
                                                                                    getYScale(): import('../..').Scale;
                                                                                    _getXSnap(invertPointX: any): any;
                                                                                    _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                    _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                    flatRecords(): any;
                                                                                    getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                    getRecords(data: any, field?: string): any[];
                                                                                    getLegendItems(): any;
                                                                                    isSelected(record: any): boolean;
                                                                                    getSelectionStyle(record: any): any;
                                                                                    props: IProps & ChartChildProps<DataRecord>;
                                                                                    state: import('../geometry/selection').SelectionState;
                                                                                    context: any;
                                                                                    refs: { [key: string]: any };
                                                                                    updater: any;
                                                                                    container: any;
                                                                                    layout: any;
                                                                                    children:
                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                    isMounted: boolean;
                                                                                    animate: boolean;
                                                                                    animator: any;
                                                                                    destroyed: boolean;
                                                                                    _vNode: any;
                                                                                    shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                    didUpdate(): void;
                                                                                    willUnmount(): 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 <IProps extends PieLabelProps = PieLabelProps>(props: any) => {
                                                                                      labels: [];
                                                                                      willMount(): void;
                                                                                      didMount(): void;
                                                                                      getLabels(props: any): any[];
                                                                                      render(): any;
                                                                                      props: IProps & ChartChildProps<DataRecord>;
                                                                                      state: any;
                                                                                      context: any;
                                                                                      refs: { [key: string]: Component<any, any> };
                                                                                      updater: any;
                                                                                      container: any;
                                                                                      layout: any;
                                                                                      children:
                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                      isMounted: boolean;
                                                                                      animate: boolean;
                                                                                      animator: any;
                                                                                      destroyed: boolean;
                                                                                      _vNode: any;
                                                                                      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                      willReceiveProps(
                                                                                      _props: IProps & ChartChildProps<DataRecord>,
                                                                                      _context?: any
                                                                                      ): void;
                                                                                      willUpdate(): void;
                                                                                      didUpdate(): void;
                                                                                      willUnmount(): 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 <
                                                                                        TRecord extends DataRecord = DataRecord,
                                                                                        IProps extends PointProps<TRecord> = PointProps<TRecord>
                                                                                        >(
                                                                                        props: IProps & ChartChildProps<DataRecord>,
                                                                                        context?: any
                                                                                        ) => {
                                                                                        getDefaultCfg(): { geomType: string };
                                                                                        render(): any;
                                                                                        isGeometry: boolean;
                                                                                        geomType: import('../geometry').GeometryType;
                                                                                        attrs: any;
                                                                                        adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                        adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                        };
                                                                                        dataArray: any;
                                                                                        dataRecords: any[];
                                                                                        records: any[];
                                                                                        mappedArray: any;
                                                                                        justifyContent: boolean;
                                                                                        startOnZero: boolean;
                                                                                        connectNulls: boolean;
                                                                                        sortable: boolean;
                                                                                        attrController: import('../../controller/attr').default;
                                                                                        animation: any;
                                                                                        willReceiveProps(nextProps: any): void;
                                                                                        willMount(): void;
                                                                                        willUpdate(): void;
                                                                                        didMount(): void;
                                                                                        _initEvent(): void;
                                                                                        _createAttrs(): void;
                                                                                        _getThemeAttrsRange(): {
                                                                                        x: import('../../coord/types').Range;
                                                                                        y: import('../../coord/types').Range;
                                                                                        color: any;
                                                                                        size: any;
                                                                                        shape: any;
                                                                                        };
                                                                                        _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                        adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                        };
                                                                                        _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;
                                                                                        _readjustData(records: any): void;
                                                                                        _sortData(records: any): void;
                                                                                        getY0Value(): any;
                                                                                        _getShapeStyle(shape: any, origin: any): any;
                                                                                        _mapping(records: any): any[];
                                                                                        mapping(): any[];
                                                                                        getClip(): {
                                                                                        type: string;
                                                                                        style: { x: number; y: number; width: number; height: number };
                                                                                        };
                                                                                        getAttr(attrName: string): any;
                                                                                        getXScale(): import('../..').Scale;
                                                                                        getYScale(): import('../..').Scale;
                                                                                        _getXSnap(invertPointX: any): any;
                                                                                        _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                        _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                        flatRecords(): any;
                                                                                        getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                        getRecords(data: any, field?: string): any[];
                                                                                        getLegendItems(): any;
                                                                                        isSelected(record: any): boolean;
                                                                                        getSelectionStyle(record: any): any;
                                                                                        props: IProps & ChartChildProps<DataRecord>;
                                                                                        state: import('../geometry/selection').SelectionState;
                                                                                        context: any;
                                                                                        refs: { [key: string]: any };
                                                                                        updater: any;
                                                                                        container: any;
                                                                                        layout: any;
                                                                                        children:
                                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                        isMounted: boolean;
                                                                                        animate: boolean;
                                                                                        animator: any;
                                                                                        destroyed: boolean;
                                                                                        _vNode: any;
                                                                                        shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                        didUpdate(): void;
                                                                                        willUnmount(): 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 & ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                          ) => {
                                                                                          willMount(): any;
                                                                                          render(): any;
                                                                                          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: number;
                                                                                          didMount(): void;
                                                                                          willReceiveProps(
                                                                                          nextProps: ScrollBarProps &
                                                                                          ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                          ): void;
                                                                                          willUpdate(): void;
                                                                                          didUnmount(): void;
                                                                                          _requestAnimationFrame(calllback: Function): number;
                                                                                          _cancelAnimationFrame(): void;
                                                                                          onPanStart: () => void;
                                                                                          onPan: (ev: any) => void;
                                                                                          onPanEnd: () => void;
                                                                                          onPinchStart: () => void;
                                                                                          onPinch: (ev: any) => void;
                                                                                          onPinchEnd: () => void;
                                                                                          _bindEvents(): void;
                                                                                          _unBindEvents(): void;
                                                                                          onStart: () => void;
                                                                                          update(): void;
                                                                                          animateSwipe(
                                                                                          dim: string,
                                                                                          dimRange: import('../zoom').ZoomRange,
                                                                                          velocity: number
                                                                                          ): void;
                                                                                          onSwipe: (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('../..').Scale[],
                                                                                          mainScale: import('../..').Scale,
                                                                                          data: any[]
                                                                                          ): void;
                                                                                          _getScale(dim: any): any;
                                                                                          _getFollowScales(dim: any): any[];
                                                                                          renderRange(range: any): void;
                                                                                          props: ScrollBarProps & ChartChildProps<import('../../chart/Data').DataRecord>;
                                                                                          state: import('../zoom').ZoomState;
                                                                                          context: any;
                                                                                          refs: { [key: string]: any };
                                                                                          updater: any;
                                                                                          container: any;
                                                                                          layout: any;
                                                                                          children:
                                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                          isMounted: boolean;
                                                                                          animate: boolean;
                                                                                          animator: any;
                                                                                          destroyed: boolean;
                                                                                          _vNode: any;
                                                                                          shouldUpdate(
                                                                                          _nextProps: ScrollBarProps &
                                                                                          ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                          ): boolean;
                                                                                          didUpdate(): void;
                                                                                          willUnmount(): 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 <
                                                                                            TRecord extends DataRecord = DataRecord,
                                                                                            IProps extends SunburstProps<TRecord> = SunburstProps<TRecord>
                                                                                            >(
                                                                                            props: IProps,
                                                                                            context: any
                                                                                            ) => {
                                                                                            coord: CoordController;
                                                                                            color: Category;
                                                                                            triggerRef: Ref[];
                                                                                            willMount(): void;
                                                                                            didMount(): void;
                                                                                            _mapping(children: any): void;
                                                                                            sunburst(): any;
                                                                                            render(): any;
                                                                                            props: IProps;
                                                                                            state: any;
                                                                                            context: any;
                                                                                            refs: { [key: string]: Component<any, any> };
                                                                                            updater: any;
                                                                                            container: any;
                                                                                            layout: any;
                                                                                            children:
                                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                            isMounted: boolean;
                                                                                            animate: boolean;
                                                                                            animator: any;
                                                                                            destroyed: boolean;
                                                                                            _vNode: any;
                                                                                            shouldUpdate(_nextProps: IProps): boolean;
                                                                                            willReceiveProps(_props: IProps, _context?: any): void;
                                                                                            willUpdate(): void;
                                                                                            didUpdate(): void;
                                                                                            willUnmount(): 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 <IProps extends TooltipProps = TooltipProps>(
                                                                                              props: IProps & ChartChildProps<DataRecord>
                                                                                              ) => {
                                                                                              updateCoord(): void;
                                                                                              willMount(): void;
                                                                                              didMount(): void;
                                                                                              _initEvent(): void;
                                                                                              willReceiveProps(nextProps: any): void;
                                                                                              _initShow(): void;
                                                                                              _showByData(dataItem: any): void;
                                                                                              _triggerOn: (ev: any) => void;
                                                                                              _triggerOff: () => void;
                                                                                              show(point: any, _ev?: any): void;
                                                                                              showSnapRecords(snapRecords: any): void;
                                                                                              hide(): void;
                                                                                              render(): any;
                                                                                              props: IProps & ChartChildProps<DataRecord>;
                                                                                              state: TooltipState;
                                                                                              context: any;
                                                                                              refs: { [key: string]: Component<any, any> };
                                                                                              updater: any;
                                                                                              container: any;
                                                                                              layout: any;
                                                                                              children:
                                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                              isMounted: boolean;
                                                                                              animate: boolean;
                                                                                              animator: any;
                                                                                              destroyed: boolean;
                                                                                              _vNode: any;
                                                                                              shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                              willUpdate(): void;
                                                                                              didUpdate(): void;
                                                                                              willUnmount(): void;
                                                                                              didUnmount(): void;
                                                                                              setState(partialState: TooltipState, callback?: () => void): void;
                                                                                              forceUpdate(callback?: () => void): void;
                                                                                              setAnimate(animate: boolean): void;
                                                                                              destroy(): void;
                                                                                              };

                                                                                                function withTreemap

                                                                                                withTreemap: <
                                                                                                IProps extends TreemapProps<DataRecord> = TreemapProps<DataRecord>
                                                                                                >(
                                                                                                View: ComponentType<IProps>
                                                                                                ) => new <
                                                                                                TRecord extends DataRecord = DataRecord,
                                                                                                P extends TreemapProps<TRecord> = TreemapProps<TRecord>
                                                                                                >(
                                                                                                props: P & IProps,
                                                                                                context: any
                                                                                                ) => {
                                                                                                coord: CoordController;
                                                                                                color: Category;
                                                                                                coordRef: Ref;
                                                                                                records: RecordNode<DataRecord>[];
                                                                                                isSelected(record: any): boolean;
                                                                                                getSelectionStyle(record: any): any;
                                                                                                willMount(): void;
                                                                                                willReceiveProps(nextProps: P): void;
                                                                                                treemapLayout(): RecordNode[];
                                                                                                select(ev: any, trigger: any): void;
                                                                                                render(): any;
                                                                                                props: P & IProps;
                                                                                                state: any;
                                                                                                context: any;
                                                                                                refs: { [key: string]: Component<any, any> };
                                                                                                updater: any;
                                                                                                container: any;
                                                                                                layout: any;
                                                                                                children:
                                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                isMounted: boolean;
                                                                                                animate: boolean;
                                                                                                animator: any;
                                                                                                destroyed: boolean;
                                                                                                _vNode: any;
                                                                                                didMount(): void;
                                                                                                shouldUpdate(_nextProps: P & IProps): boolean;
                                                                                                willUpdate(): void;
                                                                                                didUpdate(): void;
                                                                                                willUnmount(): void;
                                                                                                didUnmount(): void;
                                                                                                setState(partialState: any, callback?: () => void): void;
                                                                                                forceUpdate(callback?: () => void): void;
                                                                                                setAnimate(animate: boolean): void;
                                                                                                destroy(): void;
                                                                                                };

                                                                                                  function Zoom

                                                                                                  Zoom: (
                                                                                                  View: any
                                                                                                  ) => new <P extends ZoomProps = ZoomProps, S extends ZoomState = ZoomState>(
                                                                                                  props: P
                                                                                                  ) => {
                                                                                                  startRange: { x?: ZoomRange; y?: ZoomRange };
                                                                                                  scale: {};
                                                                                                  originScale: {};
                                                                                                  minScale: number;
                                                                                                  dims: Array<String>;
                                                                                                  swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                                                                                  loop: number;
                                                                                                  didMount(): void;
                                                                                                  willReceiveProps(nextProps: P): void;
                                                                                                  willMount(): void;
                                                                                                  willUpdate(): void;
                                                                                                  didUnmount(): void;
                                                                                                  _requestAnimationFrame(calllback: Function): number;
                                                                                                  _cancelAnimationFrame(): void;
                                                                                                  onPanStart: () => void;
                                                                                                  onPan: (ev: any) => void;
                                                                                                  onPanEnd: () => void;
                                                                                                  onPinchStart: () => void;
                                                                                                  onPinch: (ev: any) => void;
                                                                                                  onPinchEnd: () => void;
                                                                                                  _bindEvents(): void;
                                                                                                  _unBindEvents(): void;
                                                                                                  onStart: () => void;
                                                                                                  update(): void;
                                                                                                  animateSwipe(dim: string, dimRange: ZoomRange, velocity: number): void;
                                                                                                  onSwipe: (ev: any) => void;
                                                                                                  onEnd: () => void;
                                                                                                  _doXPan(ev: any): ZoomRange;
                                                                                                  _doYPan(ev: any): ZoomRange;
                                                                                                  _doPan(ratio: number, dim: string): ZoomRange;
                                                                                                  _doXPinch(ev: any): any;
                                                                                                  _doYPinch(ev: any): any;
                                                                                                  _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                                                                                  updateRange(originalRange: ZoomRange, dim: any): ZoomRange;
                                                                                                  updateFollow(scales: Scale[], mainScale: Scale, data: any[]): void;
                                                                                                  _getScale(dim: any): any;
                                                                                                  _getFollowScales(dim: any): any[];
                                                                                                  renderRange(range: any): void;
                                                                                                  render(): any;
                                                                                                  props: P & ChartChildProps<DataRecord>;
                                                                                                  state: S;
                                                                                                  context: any;
                                                                                                  refs: { [key: string]: Component<any, any> };
                                                                                                  updater: any;
                                                                                                  container: any;
                                                                                                  layout: any;
                                                                                                  children:
                                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                  isMounted: boolean;
                                                                                                  animate: boolean;
                                                                                                  animator: any;
                                                                                                  destroyed: boolean;
                                                                                                  _vNode: any;
                                                                                                  shouldUpdate(_nextProps: P & ChartChildProps<DataRecord>): boolean;
                                                                                                  didUpdate(): void;
                                                                                                  willUnmount(): void;
                                                                                                  setState(partialState: S, callback?: () => void): void;
                                                                                                  forceUpdate(callback?: () => void): void;
                                                                                                  setAnimate(animate: boolean): void;
                                                                                                  destroy(): void;
                                                                                                  };

                                                                                                    Classes

                                                                                                    class Chart

                                                                                                    class Chart<
                                                                                                    TRecord extends DataRecord = DataRecord,
                                                                                                    IProps extends ChartProps<TRecord> = ChartProps<TRecord>
                                                                                                    > extends Component<IProps, ChartState> {}

                                                                                                      constructor

                                                                                                      constructor(props: ChartProps<TRecord>, context?: IContext);

                                                                                                        property coord

                                                                                                        coord: CoordController;

                                                                                                          property coordRef

                                                                                                          coordRef: Ref;

                                                                                                            property scale

                                                                                                            scale: ScaleController;

                                                                                                              method filter

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

                                                                                                                method getCoord

                                                                                                                getCoord: () => Coord;

                                                                                                                  method getGeometrys

                                                                                                                  getGeometrys: () => Component<
                                                                                                                  import('@antv/f-engine').IProps,
                                                                                                                  import('@antv/f-engine').IState
                                                                                                                  >[];

                                                                                                                    method getLayout

                                                                                                                    getLayout: () => import('../controller/coord').Layout;

                                                                                                                      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 getRecords

                                                                                                                        getRecords: (data: any, field: any) => any;

                                                                                                                          method getScale

                                                                                                                          getScale: (field: string) => import('../deps/f2-scale/src').Scale;

                                                                                                                            method getScales

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

                                                                                                                              method getSnapRecords

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

                                                                                                                                method getXScales

                                                                                                                                getXScales: () => any[];

                                                                                                                                  method getYScales

                                                                                                                                  getYScales: () => any[];

                                                                                                                                    method layoutCoord

                                                                                                                                    layoutCoord: (layout: PositionLayout) => void;

                                                                                                                                      method off

                                                                                                                                      off: (eventName: string, listener: (...args: any[]) => void) => void;

                                                                                                                                        method on

                                                                                                                                        on: (eventName: string, listener: (...args: any[]) => void) => void;

                                                                                                                                          method removeComponentsPositionCache

                                                                                                                                          removeComponentsPositionCache: () => void;

                                                                                                                                            method render

                                                                                                                                            render: () => any;

                                                                                                                                              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 willMount

                                                                                                                                                      willMount: () => void;

                                                                                                                                                        method willReceiveProps

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

                                                                                                                                                          method willUpdate

                                                                                                                                                          willUpdate: () => void;

                                                                                                                                                            class Geometry

                                                                                                                                                            class Geometry<
                                                                                                                                                            TRecord extends DataRecord = DataRecord,
                                                                                                                                                            P extends GeometryProps<TRecord> = GeometryProps<TRecord>,
                                                                                                                                                            S extends SelectionState = SelectionState
                                                                                                                                                            > extends Selection<P & ChartChildProps, S> {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(
                                                                                                                                                              props: GeometryProps<TRecord> & ChartChildProps<DataRecord>,
                                                                                                                                                              context?: any
                                                                                                                                                              );

                                                                                                                                                                property adjust

                                                                                                                                                                adjust: AdjustProps & { adjust: Adjust };

                                                                                                                                                                  property animation

                                                                                                                                                                  animation: AnimationProps;

                                                                                                                                                                    property attrController

                                                                                                                                                                    attrController: AttrController;

                                                                                                                                                                      property attrs

                                                                                                                                                                      attrs: any;

                                                                                                                                                                        property connectNulls

                                                                                                                                                                        connectNulls: boolean;

                                                                                                                                                                          property dataArray

                                                                                                                                                                          dataArray: any;

                                                                                                                                                                            property dataRecords

                                                                                                                                                                            dataRecords: any[];

                                                                                                                                                                              property geomType

                                                                                                                                                                              geomType: GeometryType;

                                                                                                                                                                                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;
                                                                                                                                                                                                  style: { x: number; y: number; width: number; height: number };
                                                                                                                                                                                                  };

                                                                                                                                                                                                    method getDefaultCfg

                                                                                                                                                                                                    getDefaultCfg: () => {};

                                                                                                                                                                                                      method getLegendItems

                                                                                                                                                                                                      getLegendItems: () => any;

                                                                                                                                                                                                        method getRecords

                                                                                                                                                                                                        getRecords: (data: any, field?: string) => 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 Scale

                                                                                                                                                                                                                          abstract class Scale {}

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                            cfg: Partial<{
                                                                                                                                                                                                                            field: string;
                                                                                                                                                                                                                            values: any[];
                                                                                                                                                                                                                            min: any;
                                                                                                                                                                                                                            max: any;
                                                                                                                                                                                                                            minLimit?: any;
                                                                                                                                                                                                                            maxLimit?: any;
                                                                                                                                                                                                                            alias: string;
                                                                                                                                                                                                                            range: number[];
                                                                                                                                                                                                                            base: number;
                                                                                                                                                                                                                            exponent: number;
                                                                                                                                                                                                                            nice: boolean;
                                                                                                                                                                                                                            ticks: any[];
                                                                                                                                                                                                                            tickInterval: number;
                                                                                                                                                                                                                            minTickInterval: number;
                                                                                                                                                                                                                            tickCount: number;
                                                                                                                                                                                                                            maxTickCount: number;
                                                                                                                                                                                                                            formatter: (value: any, index?: number) => any;
                                                                                                                                                                                                                            tickMethod: string | TickMethod;
                                                                                                                                                                                                                            mask?: string;
                                                                                                                                                                                                                            showLast?: boolean;
                                                                                                                                                                                                                            }>
                                                                                                                                                                                                                            );

                                                                                                                                                                                                                              property alias

                                                                                                                                                                                                                              alias?: string;

                                                                                                                                                                                                                                property field

                                                                                                                                                                                                                                field?: string;

                                                                                                                                                                                                                                  property formatter

                                                                                                                                                                                                                                  formatter?: (value: any, index?: number) => any;

                                                                                                                                                                                                                                    property isCategory

                                                                                                                                                                                                                                    isCategory?: boolean;
                                                                                                                                                                                                                                    • 是否分类类型的度量

                                                                                                                                                                                                                                    property isContinuous

                                                                                                                                                                                                                                    isContinuous?: boolean;
                                                                                                                                                                                                                                    • 是否连续类型的度量,linear,time,log, pow, quantile, quantize 都支持

                                                                                                                                                                                                                                    property isIdentity

                                                                                                                                                                                                                                    isIdentity: boolean;
                                                                                                                                                                                                                                    • 是否是常量的度量,传入和传出一致

                                                                                                                                                                                                                                    property isLinear

                                                                                                                                                                                                                                    isLinear?: boolean;
                                                                                                                                                                                                                                    • 是否线性度量,有linear, time 度量

                                                                                                                                                                                                                                    property max

                                                                                                                                                                                                                                    max?: any;

                                                                                                                                                                                                                                      property maxLimit

                                                                                                                                                                                                                                      maxLimit?: any;

                                                                                                                                                                                                                                        property min

                                                                                                                                                                                                                                        min?: any;

                                                                                                                                                                                                                                          property minLimit

                                                                                                                                                                                                                                          minLimit?: any;

                                                                                                                                                                                                                                            property range

                                                                                                                                                                                                                                            range: number[];

                                                                                                                                                                                                                                              property tickCount

                                                                                                                                                                                                                                              tickCount: number;

                                                                                                                                                                                                                                                property tickInterval

                                                                                                                                                                                                                                                tickInterval: number;

                                                                                                                                                                                                                                                  property tickMethod

                                                                                                                                                                                                                                                  tickMethod?: string | TickMethod;

                                                                                                                                                                                                                                                    property ticks

                                                                                                                                                                                                                                                    ticks: any[];

                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                      • 度量的类型

                                                                                                                                                                                                                                                      property values

                                                                                                                                                                                                                                                      values: any[];

                                                                                                                                                                                                                                                        method calcPercent

                                                                                                                                                                                                                                                        protected calcPercent: (value: any, min: number, max: number) => number;
                                                                                                                                                                                                                                                        • 定义域转 0~1

                                                                                                                                                                                                                                                        method calculateTicks

                                                                                                                                                                                                                                                        protected calculateTicks: () => any[];

                                                                                                                                                                                                                                                          method calcValue

                                                                                                                                                                                                                                                          protected calcValue: (percent: number, min: number, max: number) => number;
                                                                                                                                                                                                                                                          • 0~1转定义域

                                                                                                                                                                                                                                                          method change

                                                                                                                                                                                                                                                          change: (cfg: ScaleConfig) => void;
                                                                                                                                                                                                                                                          • 重新初始化

                                                                                                                                                                                                                                                          method clone

                                                                                                                                                                                                                                                          clone: () => Scale;

                                                                                                                                                                                                                                                            method getConfig

                                                                                                                                                                                                                                                            protected getConfig: (key: any) => any;

                                                                                                                                                                                                                                                              method getText

                                                                                                                                                                                                                                                              getText: (value: any, key?: number) => string;
                                                                                                                                                                                                                                                              • 获取Tick的格式化结果

                                                                                                                                                                                                                                                              method getTicks

                                                                                                                                                                                                                                                              getTicks: () => Tick[];
                                                                                                                                                                                                                                                              • 获取坐标轴需要的ticks

                                                                                                                                                                                                                                                              method init

                                                                                                                                                                                                                                                              protected init: () => void;

                                                                                                                                                                                                                                                                method initCfg

                                                                                                                                                                                                                                                                protected initCfg: () => void;

                                                                                                                                                                                                                                                                  method invert

                                                                                                                                                                                                                                                                  abstract invert: (