@antv/f2

  • Version 5.0.39
  • Published
  • 3.99 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: new <IProps extends GuideProps = GuideProps>(
props: IProps & ChartChildProps<DataRecord>
) => {
chart: import('../../chart').default<
import('../../chart/Data').DataRecord,
import('../..').ChartProps<import('../../chart/Data').DataRecord>
>;
getGuideBBox(): any;
parseReplaceStr(value: any, scale: any): any;
parsePoint(record: any): { x: any; y: any };
convertPoints(records: any): any;
getGuideTheme(): 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;
willMount(): void;
didMount(): void;
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 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;
    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;
        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;
        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: new <IProps extends GuideProps = GuideProps>(
            props: IProps & ChartChildProps<DataRecord>
            ) => {
            chart: import('../../chart').default<
            import('../../chart/Data').DataRecord,
            import('../..').ChartProps<import('../../chart/Data').DataRecord>
            >;
            getGuideBBox(): any;
            parseReplaceStr(value: any, scale: any): any;
            parsePoint(record: any): { x: any; y: any };
            convertPoints(records: any): any;
            getGuideTheme(): 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;
            willMount(): void;
            didMount(): void;
            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 ImageGuide

              const ImageGuide: new <IProps extends GuideProps = GuideProps>(
              props: IProps & ChartChildProps<DataRecord>
              ) => {
              chart: import('../../chart').default<
              import('../../chart/Data').DataRecord,
              import('../..').ChartProps<import('../../chart/Data').DataRecord>
              >;
              getGuideBBox(): any;
              parseReplaceStr(value: any, scale: any): any;
              parsePoint(record: any): { x: any; y: any };
              convertPoints(records: any): any;
              getGuideTheme(): 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;
              willMount(): void;
              didMount(): void;
              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 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;
                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;
                    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: new <IProps extends GuideProps = GuideProps>(
                      props: IProps & ChartChildProps<DataRecord>
                      ) => {
                      chart: import('../../chart').default<
                      import('../../chart/Data').DataRecord,
                      import('../..').ChartProps<import('../../chart/Data').DataRecord>
                      >;
                      getGuideBBox(): any;
                      parseReplaceStr(value: any, scale: any): any;
                      parsePoint(record: any): { x: any; y: any };
                      convertPoints(records: any): any;
                      getGuideTheme(): 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;
                      willMount(): void;
                      didMount(): void;
                      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 LottieGuide

                        const LottieGuide: new <IProps extends GuideProps = GuideProps>(
                        props: IProps & ChartChildProps<DataRecord>
                        ) => {
                        chart: import('../../chart').default<
                        import('../../chart/Data').DataRecord,
                        import('../..').ChartProps<import('../../chart/Data').DataRecord>
                        >;
                        getGuideBBox(): any;
                        parseReplaceStr(value: any, scale: any): any;
                        parsePoint(record: any): { x: any; y: any };
                        convertPoints(records: any): any;
                        getGuideTheme(): 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;
                        willMount(): void;
                        didMount(): void;
                        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 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;
                            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: new <IProps extends GuideProps = GuideProps>(
                              props: IProps & ChartChildProps<DataRecord>
                              ) => {
                              chart: import('../../chart').default<
                              import('../../chart/Data').DataRecord,
                              import('../..').ChartProps<import('../../chart/Data').DataRecord>
                              >;
                              getGuideBBox(): any;
                              parseReplaceStr(value: any, scale: any): any;
                              parsePoint(record: any): { x: any; y: any };
                              convertPoints(records: any): any;
                              getGuideTheme(): 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;
                              willMount(): void;
                              didMount(): void;
                              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 RectGuide

                                const RectGuide: new <IProps extends GuideProps = GuideProps>(
                                props: IProps & ChartChildProps<DataRecord>
                                ) => {
                                chart: import('../../chart').default<
                                import('../../chart/Data').DataRecord,
                                import('../..').ChartProps<import('../../chart/Data').DataRecord>
                                >;
                                getGuideBBox(): any;
                                parseReplaceStr(value: any, scale: any): any;
                                parsePoint(record: any): { x: any; y: any };
                                convertPoints(records: any): any;
                                getGuideTheme(): 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;
                                willMount(): void;
                                didMount(): void;
                                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 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;
                                  _bindEvents(): void;
                                  onStart: () => void;
                                  onPan: (ev: any) => void;
                                  update(): void;
                                  animateSwipe(
                                  dim: string,
                                  dimRange: import('../zoom').ZoomRange,
                                  velocity: number
                                  ): void;
                                  onSwipe: (ev: any) => void;
                                  onPinch: (ev: any) => void;
                                  onEnd: () => void;
                                  _doXPan(ev: any): import('../zoom').ZoomRange;
                                  _doYPan(ev: any): import('../zoom').ZoomRange;
                                  _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                  _doXPinch(ev: any): any;
                                  _doYPinch(ev: any): any;
                                  _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                  updateRange(
                                  originalRange: import('../zoom').ZoomRange,
                                  dim: any
                                  ): import('../zoom').ZoomRange;
                                  updateFollow(
                                  scales: import('../..').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: new <IProps extends GuideProps = GuideProps>(
                                      props: IProps & ChartChildProps<DataRecord>
                                      ) => {
                                      chart: import('../../chart').default<
                                      import('../../chart/Data').DataRecord,
                                      import('../..').ChartProps<import('../../chart/Data').DataRecord>
                                      >;
                                      getGuideBBox(): any;
                                      parseReplaceStr(value: any, scale: any): any;
                                      parsePoint(record: any): { x: any; y: any };
                                      convertPoints(records: any): any;
                                      getGuideTheme(): 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;
                                      willMount(): void;
                                      didMount(): void;
                                      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 TextGuide

                                        const TextGuide: new <IProps extends GuideProps = GuideProps>(
                                        props: IProps & ChartChildProps<DataRecord>
                                        ) => {
                                        chart: import('../../chart').default<
                                        import('../../chart/Data').DataRecord,
                                        import('../..').ChartProps<import('../../chart/Data').DataRecord>
                                        >;
                                        getGuideBBox(): any;
                                        parseReplaceStr(value: any, scale: any): any;
                                        parsePoint(record: any): { x: any; y: any };
                                        convertPoints(records: any): any;
                                        getGuideTheme(): 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;
                                        willMount(): void;
                                        didMount(): void;
                                        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 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;
                                                                      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;
                                                                          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;
                                                                          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: (
                                                                              View: ComponentType
                                                                              ) => new <IProps extends GuideProps = GuideProps>(
                                                                              props: IProps & ChartChildProps<DataRecord>
                                                                              ) => {
                                                                              chart: Chart;
                                                                              getGuideBBox(): any;
                                                                              parseReplaceStr(value: any, scale: any): any;
                                                                              parsePoint(record: any): { x: any; y: any };
                                                                              convertPoints(records: any): any;
                                                                              getGuideTheme(): 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;
                                                                              willMount(): void;
                                                                              didMount(): void;
                                                                              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 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;
                                                                                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;
                                                                                    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;
                                                                                        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;
                                                                                          _bindEvents(): void;
                                                                                          onStart: () => void;
                                                                                          onPan: (ev: any) => void;
                                                                                          update(): void;
                                                                                          animateSwipe(
                                                                                          dim: string,
                                                                                          dimRange: import('../zoom').ZoomRange,
                                                                                          velocity: number
                                                                                          ): void;
                                                                                          onSwipe: (ev: any) => void;
                                                                                          onPinch: (ev: any) => void;
                                                                                          onEnd: () => void;
                                                                                          _doXPan(ev: any): import('../zoom').ZoomRange;
                                                                                          _doYPan(ev: any): import('../zoom').ZoomRange;
                                                                                          _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                                                                          _doXPinch(ev: any): any;
                                                                                          _doYPinch(ev: any): any;
                                                                                          _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                                                                          updateRange(
                                                                                          originalRange: import('../zoom').ZoomRange,
                                                                                          dim: any
                                                                                          ): import('../zoom').ZoomRange;
                                                                                          updateFollow(
                                                                                          scales: import('../..').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;
                                                                                                  _bindEvents(): void;
                                                                                                  onStart: () => void;
                                                                                                  onPan: (ev: any) => void;
                                                                                                  update(): void;
                                                                                                  animateSwipe(dim: string, dimRange: ZoomRange, velocity: number): void;
                                                                                                  onSwipe: (ev: any) => void;
                                                                                                  onPinch: (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