recharts

  • Version 2.1.8
  • Published
  • 5.1 MB
  • 14 dependencies
  • MIT license

Install

npm i recharts
yarn add recharts
pnpm add recharts

Overview

React charts

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable AreaChart

const AreaChart: {
new (props: import('./generateCategoricalChart').CategoricalChartProps): {
uniqueChartId: any;
clipPathId: any;
legendInstance: any;
deferId: any;
container?: any;
componentDidMount(): void;
componentDidUpdate(
prevProps: import('./generateCategoricalChart').CategoricalChartProps
): void;
componentWillUnmount(): void;
cancelThrottledTriggerAfterMouseMove(): void;
getTooltipEventType(): string;
getMouseInfo(
event: any
):
| { xValue: any; yValue: any; chartX: number; chartY: number }
| {
activeTooltipIndex: number;
activeLabel: any;
activePayload: any[];
activeCoordinate: import('../util/types').ChartCoordinate;
chartX: number;
chartY: number;
};
getCursorRectangle(): any;
getCursorPoints(): any;
inRange(x: number, y: number): any;
parseEventsOfWrapper(): any;
addListener(): void;
removeListener(): void;
clearDeferId: () => void;
handleLegendBBoxUpdate: (box: any) => void;
handleReceiveSyncEvent: (
cId: string | number,
chartId: string,
data: import('./generateCategoricalChart').CategoricalChartState
) => void;
handleBrushChange: ({ startIndex, endIndex }: any) => void;
handleMouseEnter: (e: any) => void;
triggeredAfterMouseMove: (e: any) => any;
handleItemMouseEnter: (el: any) => void;
handleItemMouseLeave: () => void;
handleMouseMove: (e: any) => void;
handleMouseLeave: (e: any) => void;
handleOuterEvent: (e: any) => void;
handleClick: (e: any) => void;
handleMouseDown: (e: any) => void;
handleMouseUp: (e: any) => void;
handleTouchMove: (e: any) => void;
handleTouchStart: (e: any) => void;
handleTouchEnd: (e: any) => void;
triggerSyncEvent(
data: import('./generateCategoricalChart').CategoricalChartState
): void;
applySyncEvent(
data: import('./generateCategoricalChart').CategoricalChartState
): void;
verticalCoordinatesGenerator: ({
xAxis,
width,
height,
offset,
}: import('../util/types').ChartCoordinate) => number[];
horizontalCoordinatesGenerator: ({
yAxis,
width,
height,
offset,
}: import('../util/types').ChartCoordinate) => number[];
axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
filterFormatItem(item: any, displayName: any, childIndex: any): any;
renderCursor: (
element: any
) =>
| import('react').DetailedReactHTMLElement<any, HTMLElement>
| import('react').CElement<
any,
import('react').Component<any, any, any>
>;
renderPolarAxis: (element: any, displayName: string, index: number) => any;
renderXAxis: (element: any, displayName: string, index: number) => any;
renderYAxis: (element: any, displayName: string, index: number) => any;
renderAxis(
axisOptions: import('../util/types').BaseAxisProps,
element: any,
displayName: string,
index: number
): any;
renderGrid: (element: any) => any;
renderPolarGrid: (element: any) => any;
renderLegend: () => import('react').ReactElement<
any,
string | import('react').JSXElementConstructor<any>
>;
renderTooltip: () => import('react').ReactElement<
any,
string | import('react').JSXElementConstructor<any>
>;
renderBrush: (element: any) => any;
renderReferenceElement: (
element: any,
displayName: string,
index: number
) => any;
renderActivePoints: ({
item,
activePoint,
basePoint,
childIndex,
isRange,
}: any) => import('react').ReactElement<
any,
string | import('react').JSXElementConstructor<any>
>[];
renderGraphicChild: (
element: any,
displayName: string,
index: number
) => any[];
renderCustomized: (element: any, displayName: string, index: number) => any;
renderClipPath(): JSX.Element;
getXScales(): { [x: string]: Function | ScaleType };
getYScales(): { [x: string]: Function | ScaleType };
getXScaleByAxisId(
axisId: string
): Function | import('../util/types').ScaleType;
getYScaleByAxisId(
axisId: string
): Function | import('../util/types').ScaleType;
getItemByXY(chartXY: { x: number; y: number }): {
graphicalItem: any;
payload: any;
};
render(): JSX.Element;
context: any;
setState<K extends keyof CategoricalChartState>(
state:
| CategoricalChartState
| ((
prevState: Readonly<
import('./generateCategoricalChart').CategoricalChartState
>,
props: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>
) => CategoricalChartState | Pick<CategoricalChartState, K>)
| Pick<CategoricalChartState, K>,
callback?: () => void
): void;
forceUpdate(callback?: () => void): void;
readonly props: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
> &
Readonly<{ children?: import('react').ReactNode }>;
state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
refs: { [key: string]: any };
shouldComponentUpdate?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextState: Readonly<
import('./generateCategoricalChart').CategoricalChartState
>,
nextContext: any
): boolean;
componentDidCatch?(error: Error, errorInfo: any): void;
getSnapshotBeforeUpdate?(
prevProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
prevState: Readonly<
import('./generateCategoricalChart').CategoricalChartState
>
): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextContext: any
): void;
UNSAFE_componentWillReceiveProps?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextContext: any
): void;
componentWillUpdate?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextState: Readonly<
import('./generateCategoricalChart').CategoricalChartState
>,
nextContext: any
): void;
UNSAFE_componentWillUpdate?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextState: Readonly<
import('./generateCategoricalChart').CategoricalChartState
>,
nextContext: any
): void;
};
displayName: string;
defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
getDerivedStateFromProps: (
nextProps: import('./generateCategoricalChart').CategoricalChartProps,
prevState: import('./generateCategoricalChart').CategoricalChartState
) => import('./generateCategoricalChart').CategoricalChartState;
renderActiveDot: (option: any, props: any) => any;
contextType?: any;
};

    variable BarChart

    const BarChart: {
    new (props: import('./generateCategoricalChart').CategoricalChartProps): {
    uniqueChartId: any;
    clipPathId: any;
    legendInstance: any;
    deferId: any;
    container?: any;
    componentDidMount(): void;
    componentDidUpdate(
    prevProps: import('./generateCategoricalChart').CategoricalChartProps
    ): void;
    componentWillUnmount(): void;
    cancelThrottledTriggerAfterMouseMove(): void;
    getTooltipEventType(): string;
    getMouseInfo(
    event: any
    ):
    | { xValue: any; yValue: any; chartX: number; chartY: number }
    | {
    activeTooltipIndex: number;
    activeLabel: any;
    activePayload: any[];
    activeCoordinate: import('../util/types').ChartCoordinate;
    chartX: number;
    chartY: number;
    };
    getCursorRectangle(): any;
    getCursorPoints(): any;
    inRange(x: number, y: number): any;
    parseEventsOfWrapper(): any;
    addListener(): void;
    removeListener(): void;
    clearDeferId: () => void;
    handleLegendBBoxUpdate: (box: any) => void;
    handleReceiveSyncEvent: (
    cId: string | number,
    chartId: string,
    data: import('./generateCategoricalChart').CategoricalChartState
    ) => void;
    handleBrushChange: ({ startIndex, endIndex }: any) => void;
    handleMouseEnter: (e: any) => void;
    triggeredAfterMouseMove: (e: any) => any;
    handleItemMouseEnter: (el: any) => void;
    handleItemMouseLeave: () => void;
    handleMouseMove: (e: any) => void;
    handleMouseLeave: (e: any) => void;
    handleOuterEvent: (e: any) => void;
    handleClick: (e: any) => void;
    handleMouseDown: (e: any) => void;
    handleMouseUp: (e: any) => void;
    handleTouchMove: (e: any) => void;
    handleTouchStart: (e: any) => void;
    handleTouchEnd: (e: any) => void;
    triggerSyncEvent(
    data: import('./generateCategoricalChart').CategoricalChartState
    ): void;
    applySyncEvent(
    data: import('./generateCategoricalChart').CategoricalChartState
    ): void;
    verticalCoordinatesGenerator: ({
    xAxis,
    width,
    height,
    offset,
    }: import('../util/types').ChartCoordinate) => number[];
    horizontalCoordinatesGenerator: ({
    yAxis,
    width,
    height,
    offset,
    }: import('../util/types').ChartCoordinate) => number[];
    axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
    filterFormatItem(item: any, displayName: any, childIndex: any): any;
    renderCursor: (
    element: any
    ) =>
    | import('react').DetailedReactHTMLElement<any, HTMLElement>
    | import('react').CElement<
    any,
    import('react').Component<any, any, any>
    >;
    renderPolarAxis: (element: any, displayName: string, index: number) => any;
    renderXAxis: (element: any, displayName: string, index: number) => any;
    renderYAxis: (element: any, displayName: string, index: number) => any;
    renderAxis(
    axisOptions: import('../util/types').BaseAxisProps,
    element: any,
    displayName: string,
    index: number
    ): any;
    renderGrid: (element: any) => any;
    renderPolarGrid: (element: any) => any;
    renderLegend: () => import('react').ReactElement<
    any,
    string | import('react').JSXElementConstructor<any>
    >;
    renderTooltip: () => import('react').ReactElement<
    any,
    string | import('react').JSXElementConstructor<any>
    >;
    renderBrush: (element: any) => any;
    renderReferenceElement: (
    element: any,
    displayName: string,
    index: number
    ) => any;
    renderActivePoints: ({
    item,
    activePoint,
    basePoint,
    childIndex,
    isRange,
    }: any) => import('react').ReactElement<
    any,
    string | import('react').JSXElementConstructor<any>
    >[];
    renderGraphicChild: (
    element: any,
    displayName: string,
    index: number
    ) => any[];
    renderCustomized: (element: any, displayName: string, index: number) => any;
    renderClipPath(): JSX.Element;
    getXScales(): { [x: string]: Function | ScaleType };
    getYScales(): { [x: string]: Function | ScaleType };
    getXScaleByAxisId(
    axisId: string
    ): Function | import('../util/types').ScaleType;
    getYScaleByAxisId(
    axisId: string
    ): Function | import('../util/types').ScaleType;
    getItemByXY(chartXY: { x: number; y: number }): {
    graphicalItem: any;
    payload: any;
    };
    render(): JSX.Element;
    context: any;
    setState<K extends keyof CategoricalChartState>(
    state:
    | CategoricalChartState
    | ((
    prevState: Readonly<
    import('./generateCategoricalChart').CategoricalChartState
    >,
    props: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >
    ) => CategoricalChartState | Pick<CategoricalChartState, K>)
    | Pick<CategoricalChartState, K>,
    callback?: () => void
    ): void;
    forceUpdate(callback?: () => void): void;
    readonly props: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    > &
    Readonly<{ children?: import('react').ReactNode }>;
    state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
    refs: { [key: string]: any };
    shouldComponentUpdate?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextState: Readonly<
    import('./generateCategoricalChart').CategoricalChartState
    >,
    nextContext: any
    ): boolean;
    componentDidCatch?(error: Error, errorInfo: any): void;
    getSnapshotBeforeUpdate?(
    prevProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    prevState: Readonly<
    import('./generateCategoricalChart').CategoricalChartState
    >
    ): any;
    componentWillMount?(): void;
    UNSAFE_componentWillMount?(): void;
    componentWillReceiveProps?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextContext: any
    ): void;
    UNSAFE_componentWillReceiveProps?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextContext: any
    ): void;
    componentWillUpdate?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextState: Readonly<
    import('./generateCategoricalChart').CategoricalChartState
    >,
    nextContext: any
    ): void;
    UNSAFE_componentWillUpdate?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextState: Readonly<
    import('./generateCategoricalChart').CategoricalChartState
    >,
    nextContext: any
    ): void;
    };
    displayName: string;
    defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
    getDerivedStateFromProps: (
    nextProps: import('./generateCategoricalChart').CategoricalChartProps,
    prevState: import('./generateCategoricalChart').CategoricalChartState
    ) => import('./generateCategoricalChart').CategoricalChartState;
    renderActiveDot: (option: any, props: any) => any;
    contextType?: any;
    };

      variable Cell

      const Cell: FunctionComponent<SVGProps<SVGElement>>;

        variable ComposedChart

        const ComposedChart: {
        new (props: import('./generateCategoricalChart').CategoricalChartProps): {
        uniqueChartId: any;
        clipPathId: any;
        legendInstance: any;
        deferId: any;
        container?: any;
        componentDidMount(): void;
        componentDidUpdate(
        prevProps: import('./generateCategoricalChart').CategoricalChartProps
        ): void;
        componentWillUnmount(): void;
        cancelThrottledTriggerAfterMouseMove(): void;
        getTooltipEventType(): string;
        getMouseInfo(
        event: any
        ):
        | { xValue: any; yValue: any; chartX: number; chartY: number }
        | {
        activeTooltipIndex: number;
        activeLabel: any;
        activePayload: any[];
        activeCoordinate: import('../util/types').ChartCoordinate;
        chartX: number;
        chartY: number;
        };
        getCursorRectangle(): any;
        getCursorPoints(): any;
        inRange(x: number, y: number): any;
        parseEventsOfWrapper(): any;
        addListener(): void;
        removeListener(): void;
        clearDeferId: () => void;
        handleLegendBBoxUpdate: (box: any) => void;
        handleReceiveSyncEvent: (
        cId: string | number,
        chartId: string,
        data: import('./generateCategoricalChart').CategoricalChartState
        ) => void;
        handleBrushChange: ({ startIndex, endIndex }: any) => void;
        handleMouseEnter: (e: any) => void;
        triggeredAfterMouseMove: (e: any) => any;
        handleItemMouseEnter: (el: any) => void;
        handleItemMouseLeave: () => void;
        handleMouseMove: (e: any) => void;
        handleMouseLeave: (e: any) => void;
        handleOuterEvent: (e: any) => void;
        handleClick: (e: any) => void;
        handleMouseDown: (e: any) => void;
        handleMouseUp: (e: any) => void;
        handleTouchMove: (e: any) => void;
        handleTouchStart: (e: any) => void;
        handleTouchEnd: (e: any) => void;
        triggerSyncEvent(
        data: import('./generateCategoricalChart').CategoricalChartState
        ): void;
        applySyncEvent(
        data: import('./generateCategoricalChart').CategoricalChartState
        ): void;
        verticalCoordinatesGenerator: ({
        xAxis,
        width,
        height,
        offset,
        }: import('../util/types').ChartCoordinate) => number[];
        horizontalCoordinatesGenerator: ({
        yAxis,
        width,
        height,
        offset,
        }: import('../util/types').ChartCoordinate) => number[];
        axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
        filterFormatItem(item: any, displayName: any, childIndex: any): any;
        renderCursor: (
        element: any
        ) =>
        | import('react').DetailedReactHTMLElement<any, HTMLElement>
        | import('react').CElement<
        any,
        import('react').Component<any, any, any>
        >;
        renderPolarAxis: (element: any, displayName: string, index: number) => any;
        renderXAxis: (element: any, displayName: string, index: number) => any;
        renderYAxis: (element: any, displayName: string, index: number) => any;
        renderAxis(
        axisOptions: import('../util/types').BaseAxisProps,
        element: any,
        displayName: string,
        index: number
        ): any;
        renderGrid: (element: any) => any;
        renderPolarGrid: (element: any) => any;
        renderLegend: () => import('react').ReactElement<
        any,
        string | import('react').JSXElementConstructor<any>
        >;
        renderTooltip: () => import('react').ReactElement<
        any,
        string | import('react').JSXElementConstructor<any>
        >;
        renderBrush: (element: any) => any;
        renderReferenceElement: (
        element: any,
        displayName: string,
        index: number
        ) => any;
        renderActivePoints: ({
        item,
        activePoint,
        basePoint,
        childIndex,
        isRange,
        }: any) => import('react').ReactElement<
        any,
        string | import('react').JSXElementConstructor<any>
        >[];
        renderGraphicChild: (
        element: any,
        displayName: string,
        index: number
        ) => any[];
        renderCustomized: (element: any, displayName: string, index: number) => any;
        renderClipPath(): JSX.Element;
        getXScales(): { [x: string]: Function | ScaleType };
        getYScales(): { [x: string]: Function | ScaleType };
        getXScaleByAxisId(
        axisId: string
        ): Function | import('../util/types').ScaleType;
        getYScaleByAxisId(
        axisId: string
        ): Function | import('../util/types').ScaleType;
        getItemByXY(chartXY: { x: number; y: number }): {
        graphicalItem: any;
        payload: any;
        };
        render(): JSX.Element;
        context: any;
        setState<K extends keyof CategoricalChartState>(
        state:
        | CategoricalChartState
        | ((
        prevState: Readonly<
        import('./generateCategoricalChart').CategoricalChartState
        >,
        props: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >
        ) => CategoricalChartState | Pick<CategoricalChartState, K>)
        | Pick<CategoricalChartState, K>,
        callback?: () => void
        ): void;
        forceUpdate(callback?: () => void): void;
        readonly props: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        > &
        Readonly<{ children?: import('react').ReactNode }>;
        state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
        refs: { [key: string]: any };
        shouldComponentUpdate?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextState: Readonly<
        import('./generateCategoricalChart').CategoricalChartState
        >,
        nextContext: any
        ): boolean;
        componentDidCatch?(error: Error, errorInfo: any): void;
        getSnapshotBeforeUpdate?(
        prevProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        prevState: Readonly<
        import('./generateCategoricalChart').CategoricalChartState
        >
        ): any;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextContext: any
        ): void;
        UNSAFE_componentWillReceiveProps?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextContext: any
        ): void;
        componentWillUpdate?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextState: Readonly<
        import('./generateCategoricalChart').CategoricalChartState
        >,
        nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextState: Readonly<
        import('./generateCategoricalChart').CategoricalChartState
        >,
        nextContext: any
        ): void;
        };
        displayName: string;
        defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
        getDerivedStateFromProps: (
        nextProps: import('./generateCategoricalChart').CategoricalChartProps,
        prevState: import('./generateCategoricalChart').CategoricalChartState
        ) => import('./generateCategoricalChart').CategoricalChartState;
        renderActiveDot: (option: any, props: any) => any;
        contextType?: any;
        };

          variable FunnelChart

          const FunnelChart: {
          new (props: import('./generateCategoricalChart').CategoricalChartProps): {
          uniqueChartId: any;
          clipPathId: any;
          legendInstance: any;
          deferId: any;
          container?: any;
          componentDidMount(): void;
          componentDidUpdate(
          prevProps: import('./generateCategoricalChart').CategoricalChartProps
          ): void;
          componentWillUnmount(): void;
          cancelThrottledTriggerAfterMouseMove(): void;
          getTooltipEventType(): string;
          getMouseInfo(
          event: any
          ):
          | { xValue: any; yValue: any; chartX: number; chartY: number }
          | {
          activeTooltipIndex: number;
          activeLabel: any;
          activePayload: any[];
          activeCoordinate: import('../util/types').ChartCoordinate;
          chartX: number;
          chartY: number;
          };
          getCursorRectangle(): any;
          getCursorPoints(): any;
          inRange(x: number, y: number): any;
          parseEventsOfWrapper(): any;
          addListener(): void;
          removeListener(): void;
          clearDeferId: () => void;
          handleLegendBBoxUpdate: (box: any) => void;
          handleReceiveSyncEvent: (
          cId: string | number,
          chartId: string,
          data: import('./generateCategoricalChart').CategoricalChartState
          ) => void;
          handleBrushChange: ({ startIndex, endIndex }: any) => void;
          handleMouseEnter: (e: any) => void;
          triggeredAfterMouseMove: (e: any) => any;
          handleItemMouseEnter: (el: any) => void;
          handleItemMouseLeave: () => void;
          handleMouseMove: (e: any) => void;
          handleMouseLeave: (e: any) => void;
          handleOuterEvent: (e: any) => void;
          handleClick: (e: any) => void;
          handleMouseDown: (e: any) => void;
          handleMouseUp: (e: any) => void;
          handleTouchMove: (e: any) => void;
          handleTouchStart: (e: any) => void;
          handleTouchEnd: (e: any) => void;
          triggerSyncEvent(
          data: import('./generateCategoricalChart').CategoricalChartState
          ): void;
          applySyncEvent(
          data: import('./generateCategoricalChart').CategoricalChartState
          ): void;
          verticalCoordinatesGenerator: ({
          xAxis,
          width,
          height,
          offset,
          }: import('../util/types').ChartCoordinate) => number[];
          horizontalCoordinatesGenerator: ({
          yAxis,
          width,
          height,
          offset,
          }: import('../util/types').ChartCoordinate) => number[];
          axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
          filterFormatItem(item: any, displayName: any, childIndex: any): any;
          renderCursor: (
          element: any
          ) =>
          | import('react').DetailedReactHTMLElement<any, HTMLElement>
          | import('react').CElement<
          any,
          import('react').Component<any, any, any>
          >;
          renderPolarAxis: (element: any, displayName: string, index: number) => any;
          renderXAxis: (element: any, displayName: string, index: number) => any;
          renderYAxis: (element: any, displayName: string, index: number) => any;
          renderAxis(
          axisOptions: import('../util/types').BaseAxisProps,
          element: any,
          displayName: string,
          index: number
          ): any;
          renderGrid: (element: any) => any;
          renderPolarGrid: (element: any) => any;
          renderLegend: () => import('react').ReactElement<
          any,
          string | import('react').JSXElementConstructor<any>
          >;
          renderTooltip: () => import('react').ReactElement<
          any,
          string | import('react').JSXElementConstructor<any>
          >;
          renderBrush: (element: any) => any;
          renderReferenceElement: (
          element: any,
          displayName: string,
          index: number
          ) => any;
          renderActivePoints: ({
          item,
          activePoint,
          basePoint,
          childIndex,
          isRange,
          }: any) => import('react').ReactElement<
          any,
          string | import('react').JSXElementConstructor<any>
          >[];
          renderGraphicChild: (
          element: any,
          displayName: string,
          index: number
          ) => any[];
          renderCustomized: (element: any, displayName: string, index: number) => any;
          renderClipPath(): JSX.Element;
          getXScales(): { [x: string]: Function | ScaleType };
          getYScales(): { [x: string]: Function | ScaleType };
          getXScaleByAxisId(
          axisId: string
          ): Function | import('../util/types').ScaleType;
          getYScaleByAxisId(
          axisId: string
          ): Function | import('../util/types').ScaleType;
          getItemByXY(chartXY: { x: number; y: number }): {
          graphicalItem: any;
          payload: any;
          };
          render(): JSX.Element;
          context: any;
          setState<K extends keyof CategoricalChartState>(
          state:
          | CategoricalChartState
          | ((
          prevState: Readonly<
          import('./generateCategoricalChart').CategoricalChartState
          >,
          props: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >
          ) => CategoricalChartState | Pick<CategoricalChartState, K>)
          | Pick<CategoricalChartState, K>,
          callback?: () => void
          ): void;
          forceUpdate(callback?: () => void): void;
          readonly props: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          > &
          Readonly<{ children?: import('react').ReactNode }>;
          state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
          refs: { [key: string]: any };
          shouldComponentUpdate?(
          nextProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          nextState: Readonly<
          import('./generateCategoricalChart').CategoricalChartState
          >,
          nextContext: any
          ): boolean;
          componentDidCatch?(error: Error, errorInfo: any): void;
          getSnapshotBeforeUpdate?(
          prevProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          prevState: Readonly<
          import('./generateCategoricalChart').CategoricalChartState
          >
          ): any;
          componentWillMount?(): void;
          UNSAFE_componentWillMount?(): void;
          componentWillReceiveProps?(
          nextProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          nextContext: any
          ): void;
          UNSAFE_componentWillReceiveProps?(
          nextProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          nextContext: any
          ): void;
          componentWillUpdate?(
          nextProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          nextState: Readonly<
          import('./generateCategoricalChart').CategoricalChartState
          >,
          nextContext: any
          ): void;
          UNSAFE_componentWillUpdate?(
          nextProps: Readonly<
          import('./generateCategoricalChart').CategoricalChartProps
          >,
          nextState: Readonly<
          import('./generateCategoricalChart').CategoricalChartState
          >,
          nextContext: any
          ): void;
          };
          displayName: string;
          defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
          getDerivedStateFromProps: (
          nextProps: import('./generateCategoricalChart').CategoricalChartProps,
          prevState: import('./generateCategoricalChart').CategoricalChartState
          ) => import('./generateCategoricalChart').CategoricalChartState;
          renderActiveDot: (option: any, props: any) => any;
          contextType?: any;
          };

            variable Global

            const Global: {
            isSsr: boolean;
            get: (key: 'isSsr') => boolean;
            set: (key: GlobalConfigKeys | GlobalConfig, value?: any) => void;
            };

              variable LineChart

              const LineChart: {
              new (props: import('./generateCategoricalChart').CategoricalChartProps): {
              uniqueChartId: any;
              clipPathId: any;
              legendInstance: any;
              deferId: any;
              container?: any;
              componentDidMount(): void;
              componentDidUpdate(
              prevProps: import('./generateCategoricalChart').CategoricalChartProps
              ): void;
              componentWillUnmount(): void;
              cancelThrottledTriggerAfterMouseMove(): void;
              getTooltipEventType(): string;
              getMouseInfo(
              event: any
              ):
              | { xValue: any; yValue: any; chartX: number; chartY: number }
              | {
              activeTooltipIndex: number;
              activeLabel: any;
              activePayload: any[];
              activeCoordinate: import('../util/types').ChartCoordinate;
              chartX: number;
              chartY: number;
              };
              getCursorRectangle(): any;
              getCursorPoints(): any;
              inRange(x: number, y: number): any;
              parseEventsOfWrapper(): any;
              addListener(): void;
              removeListener(): void;
              clearDeferId: () => void;
              handleLegendBBoxUpdate: (box: any) => void;
              handleReceiveSyncEvent: (
              cId: string | number,
              chartId: string,
              data: import('./generateCategoricalChart').CategoricalChartState
              ) => void;
              handleBrushChange: ({ startIndex, endIndex }: any) => void;
              handleMouseEnter: (e: any) => void;
              triggeredAfterMouseMove: (e: any) => any;
              handleItemMouseEnter: (el: any) => void;
              handleItemMouseLeave: () => void;
              handleMouseMove: (e: any) => void;
              handleMouseLeave: (e: any) => void;
              handleOuterEvent: (e: any) => void;
              handleClick: (e: any) => void;
              handleMouseDown: (e: any) => void;
              handleMouseUp: (e: any) => void;
              handleTouchMove: (e: any) => void;
              handleTouchStart: (e: any) => void;
              handleTouchEnd: (e: any) => void;
              triggerSyncEvent(
              data: import('./generateCategoricalChart').CategoricalChartState
              ): void;
              applySyncEvent(
              data: import('./generateCategoricalChart').CategoricalChartState
              ): void;
              verticalCoordinatesGenerator: ({
              xAxis,
              width,
              height,
              offset,
              }: import('../util/types').ChartCoordinate) => number[];
              horizontalCoordinatesGenerator: ({
              yAxis,
              width,
              height,
              offset,
              }: import('../util/types').ChartCoordinate) => number[];
              axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
              filterFormatItem(item: any, displayName: any, childIndex: any): any;
              renderCursor: (
              element: any
              ) =>
              | import('react').DetailedReactHTMLElement<any, HTMLElement>
              | import('react').CElement<
              any,
              import('react').Component<any, any, any>
              >;
              renderPolarAxis: (element: any, displayName: string, index: number) => any;
              renderXAxis: (element: any, displayName: string, index: number) => any;
              renderYAxis: (element: any, displayName: string, index: number) => any;
              renderAxis(
              axisOptions: import('../util/types').BaseAxisProps,
              element: any,
              displayName: string,
              index: number
              ): any;
              renderGrid: (element: any) => any;
              renderPolarGrid: (element: any) => any;
              renderLegend: () => import('react').ReactElement<
              any,
              string | import('react').JSXElementConstructor<any>
              >;
              renderTooltip: () => import('react').ReactElement<
              any,
              string | import('react').JSXElementConstructor<any>
              >;
              renderBrush: (element: any) => any;
              renderReferenceElement: (
              element: any,
              displayName: string,
              index: number
              ) => any;
              renderActivePoints: ({
              item,
              activePoint,
              basePoint,
              childIndex,
              isRange,
              }: any) => import('react').ReactElement<
              any,
              string | import('react').JSXElementConstructor<any>
              >[];
              renderGraphicChild: (
              element: any,
              displayName: string,
              index: number
              ) => any[];
              renderCustomized: (element: any, displayName: string, index: number) => any;
              renderClipPath(): JSX.Element;
              getXScales(): { [x: string]: Function | ScaleType };
              getYScales(): { [x: string]: Function | ScaleType };
              getXScaleByAxisId(
              axisId: string
              ): Function | import('../util/types').ScaleType;
              getYScaleByAxisId(
              axisId: string
              ): Function | import('../util/types').ScaleType;
              getItemByXY(chartXY: { x: number; y: number }): {
              graphicalItem: any;
              payload: any;
              };
              render(): JSX.Element;
              context: any;
              setState<K extends keyof CategoricalChartState>(
              state:
              | CategoricalChartState
              | ((
              prevState: Readonly<
              import('./generateCategoricalChart').CategoricalChartState
              >,
              props: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >
              ) => CategoricalChartState | Pick<CategoricalChartState, K>)
              | Pick<CategoricalChartState, K>,
              callback?: () => void
              ): void;
              forceUpdate(callback?: () => void): void;
              readonly props: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              > &
              Readonly<{ children?: import('react').ReactNode }>;
              state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
              refs: { [key: string]: any };
              shouldComponentUpdate?(
              nextProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              nextState: Readonly<
              import('./generateCategoricalChart').CategoricalChartState
              >,
              nextContext: any
              ): boolean;
              componentDidCatch?(error: Error, errorInfo: any): void;
              getSnapshotBeforeUpdate?(
              prevProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              prevState: Readonly<
              import('./generateCategoricalChart').CategoricalChartState
              >
              ): any;
              componentWillMount?(): void;
              UNSAFE_componentWillMount?(): void;
              componentWillReceiveProps?(
              nextProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              nextContext: any
              ): void;
              UNSAFE_componentWillReceiveProps?(
              nextProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              nextContext: any
              ): void;
              componentWillUpdate?(
              nextProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              nextState: Readonly<
              import('./generateCategoricalChart').CategoricalChartState
              >,
              nextContext: any
              ): void;
              UNSAFE_componentWillUpdate?(
              nextProps: Readonly<
              import('./generateCategoricalChart').CategoricalChartProps
              >,
              nextState: Readonly<
              import('./generateCategoricalChart').CategoricalChartState
              >,
              nextContext: any
              ): void;
              };
              displayName: string;
              defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
              getDerivedStateFromProps: (
              nextProps: import('./generateCategoricalChart').CategoricalChartProps,
              prevState: import('./generateCategoricalChart').CategoricalChartState
              ) => import('./generateCategoricalChart').CategoricalChartState;
              renderActiveDot: (option: any, props: any) => any;
              contextType?: any;
              };

                variable PieChart

                const PieChart: {
                new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                uniqueChartId: any;
                clipPathId: any;
                legendInstance: any;
                deferId: any;
                container?: any;
                componentDidMount(): void;
                componentDidUpdate(
                prevProps: import('./generateCategoricalChart').CategoricalChartProps
                ): void;
                componentWillUnmount(): void;
                cancelThrottledTriggerAfterMouseMove(): void;
                getTooltipEventType(): string;
                getMouseInfo(
                event: any
                ):
                | { xValue: any; yValue: any; chartX: number; chartY: number }
                | {
                activeTooltipIndex: number;
                activeLabel: any;
                activePayload: any[];
                activeCoordinate: import('../util/types').ChartCoordinate;
                chartX: number;
                chartY: number;
                };
                getCursorRectangle(): any;
                getCursorPoints(): any;
                inRange(x: number, y: number): any;
                parseEventsOfWrapper(): any;
                addListener(): void;
                removeListener(): void;
                clearDeferId: () => void;
                handleLegendBBoxUpdate: (box: any) => void;
                handleReceiveSyncEvent: (
                cId: string | number,
                chartId: string,
                data: import('./generateCategoricalChart').CategoricalChartState
                ) => void;
                handleBrushChange: ({ startIndex, endIndex }: any) => void;
                handleMouseEnter: (e: any) => void;
                triggeredAfterMouseMove: (e: any) => any;
                handleItemMouseEnter: (el: any) => void;
                handleItemMouseLeave: () => void;
                handleMouseMove: (e: any) => void;
                handleMouseLeave: (e: any) => void;
                handleOuterEvent: (e: any) => void;
                handleClick: (e: any) => void;
                handleMouseDown: (e: any) => void;
                handleMouseUp: (e: any) => void;
                handleTouchMove: (e: any) => void;
                handleTouchStart: (e: any) => void;
                handleTouchEnd: (e: any) => void;
                triggerSyncEvent(
                data: import('./generateCategoricalChart').CategoricalChartState
                ): void;
                applySyncEvent(
                data: import('./generateCategoricalChart').CategoricalChartState
                ): void;
                verticalCoordinatesGenerator: ({
                xAxis,
                width,
                height,
                offset,
                }: import('../util/types').ChartCoordinate) => number[];
                horizontalCoordinatesGenerator: ({
                yAxis,
                width,
                height,
                offset,
                }: import('../util/types').ChartCoordinate) => number[];
                axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
                filterFormatItem(item: any, displayName: any, childIndex: any): any;
                renderCursor: (
                element: any
                ) =>
                | import('react').DetailedReactHTMLElement<any, HTMLElement>
                | import('react').CElement<
                any,
                import('react').Component<any, any, any>
                >;
                renderPolarAxis: (element: any, displayName: string, index: number) => any;
                renderXAxis: (element: any, displayName: string, index: number) => any;
                renderYAxis: (element: any, displayName: string, index: number) => any;
                renderAxis(
                axisOptions: import('../util/types').BaseAxisProps,
                element: any,
                displayName: string,
                index: number
                ): any;
                renderGrid: (element: any) => any;
                renderPolarGrid: (element: any) => any;
                renderLegend: () => import('react').ReactElement<
                any,
                string | import('react').JSXElementConstructor<any>
                >;
                renderTooltip: () => import('react').ReactElement<
                any,
                string | import('react').JSXElementConstructor<any>
                >;
                renderBrush: (element: any) => any;
                renderReferenceElement: (
                element: any,
                displayName: string,
                index: number
                ) => any;
                renderActivePoints: ({
                item,
                activePoint,
                basePoint,
                childIndex,
                isRange,
                }: any) => import('react').ReactElement<
                any,
                string | import('react').JSXElementConstructor<any>
                >[];
                renderGraphicChild: (
                element: any,
                displayName: string,
                index: number
                ) => any[];
                renderCustomized: (element: any, displayName: string, index: number) => any;
                renderClipPath(): JSX.Element;
                getXScales(): { [x: string]: Function | ScaleType };
                getYScales(): { [x: string]: Function | ScaleType };
                getXScaleByAxisId(
                axisId: string
                ): Function | import('../util/types').ScaleType;
                getYScaleByAxisId(
                axisId: string
                ): Function | import('../util/types').ScaleType;
                getItemByXY(chartXY: { x: number; y: number }): {
                graphicalItem: any;
                payload: any;
                };
                render(): JSX.Element;
                context: any;
                setState<K extends keyof CategoricalChartState>(
                state:
                | CategoricalChartState
                | ((
                prevState: Readonly<
                import('./generateCategoricalChart').CategoricalChartState
                >,
                props: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >
                ) => CategoricalChartState | Pick<CategoricalChartState, K>)
                | Pick<CategoricalChartState, K>,
                callback?: () => void
                ): void;
                forceUpdate(callback?: () => void): void;
                readonly props: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                > &
                Readonly<{ children?: import('react').ReactNode }>;
                state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
                refs: { [key: string]: any };
                shouldComponentUpdate?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextState: Readonly<
                import('./generateCategoricalChart').CategoricalChartState
                >,
                nextContext: any
                ): boolean;
                componentDidCatch?(error: Error, errorInfo: any): void;
                getSnapshotBeforeUpdate?(
                prevProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                prevState: Readonly<
                import('./generateCategoricalChart').CategoricalChartState
                >
                ): any;
                componentWillMount?(): void;
                UNSAFE_componentWillMount?(): void;
                componentWillReceiveProps?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextContext: any
                ): void;
                UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextContext: any
                ): void;
                componentWillUpdate?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextState: Readonly<
                import('./generateCategoricalChart').CategoricalChartState
                >,
                nextContext: any
                ): void;
                UNSAFE_componentWillUpdate?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextState: Readonly<
                import('./generateCategoricalChart').CategoricalChartState
                >,
                nextContext: any
                ): void;
                };
                displayName: string;
                defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                getDerivedStateFromProps: (
                nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                prevState: import('./generateCategoricalChart').CategoricalChartState
                ) => import('./generateCategoricalChart').CategoricalChartState;
                renderActiveDot: (option: any, props: any) => any;
                contextType?: any;
                };

                  variable RadarChart

                  const RadarChart: {
                  new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                  uniqueChartId: any;
                  clipPathId: any;
                  legendInstance: any;
                  deferId: any;
                  container?: any;
                  componentDidMount(): void;
                  componentDidUpdate(
                  prevProps: import('./generateCategoricalChart').CategoricalChartProps
                  ): void;
                  componentWillUnmount(): void;
                  cancelThrottledTriggerAfterMouseMove(): void;
                  getTooltipEventType(): string;
                  getMouseInfo(
                  event: any
                  ):
                  | { xValue: any; yValue: any; chartX: number; chartY: number }
                  | {
                  activeTooltipIndex: number;
                  activeLabel: any;
                  activePayload: any[];
                  activeCoordinate: import('../util/types').ChartCoordinate;
                  chartX: number;
                  chartY: number;
                  };
                  getCursorRectangle(): any;
                  getCursorPoints(): any;
                  inRange(x: number, y: number): any;
                  parseEventsOfWrapper(): any;
                  addListener(): void;
                  removeListener(): void;
                  clearDeferId: () => void;
                  handleLegendBBoxUpdate: (box: any) => void;
                  handleReceiveSyncEvent: (
                  cId: string | number,
                  chartId: string,
                  data: import('./generateCategoricalChart').CategoricalChartState
                  ) => void;
                  handleBrushChange: ({ startIndex, endIndex }: any) => void;
                  handleMouseEnter: (e: any) => void;
                  triggeredAfterMouseMove: (e: any) => any;
                  handleItemMouseEnter: (el: any) => void;
                  handleItemMouseLeave: () => void;
                  handleMouseMove: (e: any) => void;
                  handleMouseLeave: (e: any) => void;
                  handleOuterEvent: (e: any) => void;
                  handleClick: (e: any) => void;
                  handleMouseDown: (e: any) => void;
                  handleMouseUp: (e: any) => void;
                  handleTouchMove: (e: any) => void;
                  handleTouchStart: (e: any) => void;
                  handleTouchEnd: (e: any) => void;
                  triggerSyncEvent(
                  data: import('./generateCategoricalChart').CategoricalChartState
                  ): void;
                  applySyncEvent(
                  data: import('./generateCategoricalChart').CategoricalChartState
                  ): void;
                  verticalCoordinatesGenerator: ({
                  xAxis,
                  width,
                  height,
                  offset,
                  }: import('../util/types').ChartCoordinate) => number[];
                  horizontalCoordinatesGenerator: ({
                  yAxis,
                  width,
                  height,
                  offset,
                  }: import('../util/types').ChartCoordinate) => number[];
                  axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
                  filterFormatItem(item: any, displayName: any, childIndex: any): any;
                  renderCursor: (
                  element: any
                  ) =>
                  | import('react').DetailedReactHTMLElement<any, HTMLElement>
                  | import('react').CElement<
                  any,
                  import('react').Component<any, any, any>
                  >;
                  renderPolarAxis: (element: any, displayName: string, index: number) => any;
                  renderXAxis: (element: any, displayName: string, index: number) => any;
                  renderYAxis: (element: any, displayName: string, index: number) => any;
                  renderAxis(
                  axisOptions: import('../util/types').BaseAxisProps,
                  element: any,
                  displayName: string,
                  index: number
                  ): any;
                  renderGrid: (element: any) => any;
                  renderPolarGrid: (element: any) => any;
                  renderLegend: () => import('react').ReactElement<
                  any,
                  string | import('react').JSXElementConstructor<any>
                  >;
                  renderTooltip: () => import('react').ReactElement<
                  any,
                  string | import('react').JSXElementConstructor<any>
                  >;
                  renderBrush: (element: any) => any;
                  renderReferenceElement: (
                  element: any,
                  displayName: string,
                  index: number
                  ) => any;
                  renderActivePoints: ({
                  item,
                  activePoint,
                  basePoint,
                  childIndex,
                  isRange,
                  }: any) => import('react').ReactElement<
                  any,
                  string | import('react').JSXElementConstructor<any>
                  >[];
                  renderGraphicChild: (
                  element: any,
                  displayName: string,
                  index: number
                  ) => any[];
                  renderCustomized: (element: any, displayName: string, index: number) => any;
                  renderClipPath(): JSX.Element;
                  getXScales(): { [x: string]: Function | ScaleType };
                  getYScales(): { [x: string]: Function | ScaleType };
                  getXScaleByAxisId(
                  axisId: string
                  ): Function | import('../util/types').ScaleType;
                  getYScaleByAxisId(
                  axisId: string
                  ): Function | import('../util/types').ScaleType;
                  getItemByXY(chartXY: { x: number; y: number }): {
                  graphicalItem: any;
                  payload: any;
                  };
                  render(): JSX.Element;
                  context: any;
                  setState<K extends keyof CategoricalChartState>(
                  state:
                  | CategoricalChartState
                  | ((
                  prevState: Readonly<
                  import('./generateCategoricalChart').CategoricalChartState
                  >,
                  props: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >
                  ) => CategoricalChartState | Pick<CategoricalChartState, K>)
                  | Pick<CategoricalChartState, K>,
                  callback?: () => void
                  ): void;
                  forceUpdate(callback?: () => void): void;
                  readonly props: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  > &
                  Readonly<{ children?: import('react').ReactNode }>;
                  state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
                  refs: { [key: string]: any };
                  shouldComponentUpdate?(
                  nextProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  nextState: Readonly<
                  import('./generateCategoricalChart').CategoricalChartState
                  >,
                  nextContext: any
                  ): boolean;
                  componentDidCatch?(error: Error, errorInfo: any): void;
                  getSnapshotBeforeUpdate?(
                  prevProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  prevState: Readonly<
                  import('./generateCategoricalChart').CategoricalChartState
                  >
                  ): any;
                  componentWillMount?(): void;
                  UNSAFE_componentWillMount?(): void;
                  componentWillReceiveProps?(
                  nextProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  nextContext: any
                  ): void;
                  UNSAFE_componentWillReceiveProps?(
                  nextProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  nextContext: any
                  ): void;
                  componentWillUpdate?(
                  nextProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  nextState: Readonly<
                  import('./generateCategoricalChart').CategoricalChartState
                  >,
                  nextContext: any
                  ): void;
                  UNSAFE_componentWillUpdate?(
                  nextProps: Readonly<
                  import('./generateCategoricalChart').CategoricalChartProps
                  >,
                  nextState: Readonly<
                  import('./generateCategoricalChart').CategoricalChartState
                  >,
                  nextContext: any
                  ): void;
                  };
                  displayName: string;
                  defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                  getDerivedStateFromProps: (
                  nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                  prevState: import('./generateCategoricalChart').CategoricalChartState
                  ) => import('./generateCategoricalChart').CategoricalChartState;
                  renderActiveDot: (option: any, props: any) => any;
                  contextType?: any;
                  };

                    variable RadialBarChart

                    const RadialBarChart: {
                    new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                    uniqueChartId: any;
                    clipPathId: any;
                    legendInstance: any;
                    deferId: any;
                    container?: any;
                    componentDidMount(): void;
                    componentDidUpdate(
                    prevProps: import('./generateCategoricalChart').CategoricalChartProps
                    ): void;
                    componentWillUnmount(): void;
                    cancelThrottledTriggerAfterMouseMove(): void;
                    getTooltipEventType(): string;
                    getMouseInfo(
                    event: any
                    ):
                    | { xValue: any; yValue: any; chartX: number; chartY: number }
                    | {
                    activeTooltipIndex: number;
                    activeLabel: any;
                    activePayload: any[];
                    activeCoordinate: import('../util/types').ChartCoordinate;
                    chartX: number;
                    chartY: number;
                    };
                    getCursorRectangle(): any;
                    getCursorPoints(): any;
                    inRange(x: number, y: number): any;
                    parseEventsOfWrapper(): any;
                    addListener(): void;
                    removeListener(): void;
                    clearDeferId: () => void;
                    handleLegendBBoxUpdate: (box: any) => void;
                    handleReceiveSyncEvent: (
                    cId: string | number,
                    chartId: string,
                    data: import('./generateCategoricalChart').CategoricalChartState
                    ) => void;
                    handleBrushChange: ({ startIndex, endIndex }: any) => void;
                    handleMouseEnter: (e: any) => void;
                    triggeredAfterMouseMove: (e: any) => any;
                    handleItemMouseEnter: (el: any) => void;
                    handleItemMouseLeave: () => void;
                    handleMouseMove: (e: any) => void;
                    handleMouseLeave: (e: any) => void;
                    handleOuterEvent: (e: any) => void;
                    handleClick: (e: any) => void;
                    handleMouseDown: (e: any) => void;
                    handleMouseUp: (e: any) => void;
                    handleTouchMove: (e: any) => void;
                    handleTouchStart: (e: any) => void;
                    handleTouchEnd: (e: any) => void;
                    triggerSyncEvent(
                    data: import('./generateCategoricalChart').CategoricalChartState
                    ): void;
                    applySyncEvent(
                    data: import('./generateCategoricalChart').CategoricalChartState
                    ): void;
                    verticalCoordinatesGenerator: ({
                    xAxis,
                    width,
                    height,
                    offset,
                    }: import('../util/types').ChartCoordinate) => number[];
                    horizontalCoordinatesGenerator: ({
                    yAxis,
                    width,
                    height,
                    offset,
                    }: import('../util/types').ChartCoordinate) => number[];
                    axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
                    filterFormatItem(item: any, displayName: any, childIndex: any): any;
                    renderCursor: (
                    element: any
                    ) =>
                    | import('react').DetailedReactHTMLElement<any, HTMLElement>
                    | import('react').CElement<
                    any,
                    import('react').Component<any, any, any>
                    >;
                    renderPolarAxis: (element: any, displayName: string, index: number) => any;
                    renderXAxis: (element: any, displayName: string, index: number) => any;
                    renderYAxis: (element: any, displayName: string, index: number) => any;
                    renderAxis(
                    axisOptions: import('../util/types').BaseAxisProps,
                    element: any,
                    displayName: string,
                    index: number
                    ): any;
                    renderGrid: (element: any) => any;
                    renderPolarGrid: (element: any) => any;
                    renderLegend: () => import('react').ReactElement<
                    any,
                    string | import('react').JSXElementConstructor<any>
                    >;
                    renderTooltip: () => import('react').ReactElement<
                    any,
                    string | import('react').JSXElementConstructor<any>
                    >;
                    renderBrush: (element: any) => any;
                    renderReferenceElement: (
                    element: any,
                    displayName: string,
                    index: number
                    ) => any;
                    renderActivePoints: ({
                    item,
                    activePoint,
                    basePoint,
                    childIndex,
                    isRange,
                    }: any) => import('react').ReactElement<
                    any,
                    string | import('react').JSXElementConstructor<any>
                    >[];
                    renderGraphicChild: (
                    element: any,
                    displayName: string,
                    index: number
                    ) => any[];
                    renderCustomized: (element: any, displayName: string, index: number) => any;
                    renderClipPath(): JSX.Element;
                    getXScales(): { [x: string]: Function | ScaleType };
                    getYScales(): { [x: string]: Function | ScaleType };
                    getXScaleByAxisId(
                    axisId: string
                    ): Function | import('../util/types').ScaleType;
                    getYScaleByAxisId(
                    axisId: string
                    ): Function | import('../util/types').ScaleType;
                    getItemByXY(chartXY: { x: number; y: number }): {
                    graphicalItem: any;
                    payload: any;
                    };
                    render(): JSX.Element;
                    context: any;
                    setState<K extends keyof CategoricalChartState>(
                    state:
                    | CategoricalChartState
                    | ((
                    prevState: Readonly<
                    import('./generateCategoricalChart').CategoricalChartState
                    >,
                    props: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >
                    ) => CategoricalChartState | Pick<CategoricalChartState, K>)
                    | Pick<CategoricalChartState, K>,
                    callback?: () => void
                    ): void;
                    forceUpdate(callback?: () => void): void;
                    readonly props: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    > &
                    Readonly<{ children?: import('react').ReactNode }>;
                    state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
                    refs: { [key: string]: any };
                    shouldComponentUpdate?(
                    nextProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    nextState: Readonly<
                    import('./generateCategoricalChart').CategoricalChartState
                    >,
                    nextContext: any
                    ): boolean;
                    componentDidCatch?(error: Error, errorInfo: any): void;
                    getSnapshotBeforeUpdate?(
                    prevProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    prevState: Readonly<
                    import('./generateCategoricalChart').CategoricalChartState
                    >
                    ): any;
                    componentWillMount?(): void;
                    UNSAFE_componentWillMount?(): void;
                    componentWillReceiveProps?(
                    nextProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    nextContext: any
                    ): void;
                    UNSAFE_componentWillReceiveProps?(
                    nextProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    nextContext: any
                    ): void;
                    componentWillUpdate?(
                    nextProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    nextState: Readonly<
                    import('./generateCategoricalChart').CategoricalChartState
                    >,
                    nextContext: any
                    ): void;
                    UNSAFE_componentWillUpdate?(
                    nextProps: Readonly<
                    import('./generateCategoricalChart').CategoricalChartProps
                    >,
                    nextState: Readonly<
                    import('./generateCategoricalChart').CategoricalChartState
                    >,
                    nextContext: any
                    ): void;
                    };
                    displayName: string;
                    defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                    getDerivedStateFromProps: (
                    nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                    prevState: import('./generateCategoricalChart').CategoricalChartState
                    ) => import('./generateCategoricalChart').CategoricalChartState;
                    renderActiveDot: (option: any, props: any) => any;
                    contextType?: any;
                    };

                      variable ResponsiveContainer

                      const ResponsiveContainer: React.ForwardRefExoticComponent<any>;

                        variable ScatterChart

                        const ScatterChart: {
                        new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                        uniqueChartId: any;
                        clipPathId: any;
                        legendInstance: any;
                        deferId: any;
                        container?: any;
                        componentDidMount(): void;
                        componentDidUpdate(
                        prevProps: import('./generateCategoricalChart').CategoricalChartProps
                        ): void;
                        componentWillUnmount(): void;
                        cancelThrottledTriggerAfterMouseMove(): void;
                        getTooltipEventType(): string;
                        getMouseInfo(
                        event: any
                        ):
                        | { xValue: any; yValue: any; chartX: number; chartY: number }
                        | {
                        activeTooltipIndex: number;
                        activeLabel: any;
                        activePayload: any[];
                        activeCoordinate: import('../util/types').ChartCoordinate;
                        chartX: number;
                        chartY: number;
                        };
                        getCursorRectangle(): any;
                        getCursorPoints(): any;
                        inRange(x: number, y: number): any;
                        parseEventsOfWrapper(): any;
                        addListener(): void;
                        removeListener(): void;
                        clearDeferId: () => void;
                        handleLegendBBoxUpdate: (box: any) => void;
                        handleReceiveSyncEvent: (
                        cId: string | number,
                        chartId: string,
                        data: import('./generateCategoricalChart').CategoricalChartState
                        ) => void;
                        handleBrushChange: ({ startIndex, endIndex }: any) => void;
                        handleMouseEnter: (e: any) => void;
                        triggeredAfterMouseMove: (e: any) => any;
                        handleItemMouseEnter: (el: any) => void;
                        handleItemMouseLeave: () => void;
                        handleMouseMove: (e: any) => void;
                        handleMouseLeave: (e: any) => void;
                        handleOuterEvent: (e: any) => void;
                        handleClick: (e: any) => void;
                        handleMouseDown: (e: any) => void;
                        handleMouseUp: (e: any) => void;
                        handleTouchMove: (e: any) => void;
                        handleTouchStart: (e: any) => void;
                        handleTouchEnd: (e: any) => void;
                        triggerSyncEvent(
                        data: import('./generateCategoricalChart').CategoricalChartState
                        ): void;
                        applySyncEvent(
                        data: import('./generateCategoricalChart').CategoricalChartState
                        ): void;
                        verticalCoordinatesGenerator: ({
                        xAxis,
                        width,
                        height,
                        offset,
                        }: import('../util/types').ChartCoordinate) => number[];
                        horizontalCoordinatesGenerator: ({
                        yAxis,
                        width,
                        height,
                        offset,
                        }: import('../util/types').ChartCoordinate) => number[];
                        axesTicksGenerator: (axis?: any) => import('../util/types').TickItem[];
                        filterFormatItem(item: any, displayName: any, childIndex: any): any;
                        renderCursor: (
                        element: any
                        ) =>
                        | import('react').DetailedReactHTMLElement<any, HTMLElement>
                        | import('react').CElement<
                        any,
                        import('react').Component<any, any, any>
                        >;
                        renderPolarAxis: (element: any, displayName: string, index: number) => any;
                        renderXAxis: (element: any, displayName: string, index: number) => any;
                        renderYAxis: (element: any, displayName: string, index: number) => any;
                        renderAxis(
                        axisOptions: import('../util/types').BaseAxisProps,
                        element: any,
                        displayName: string,
                        index: number
                        ): any;
                        renderGrid: (element: any) => any;
                        renderPolarGrid: (element: any) => any;
                        renderLegend: () => import('react').ReactElement<
                        any,
                        string | import('react').JSXElementConstructor<any>
                        >;
                        renderTooltip: () => import('react').ReactElement<
                        any,
                        string | import('react').JSXElementConstructor<any>
                        >;
                        renderBrush: (element: any) => any;
                        renderReferenceElement: (
                        element: any,
                        displayName: string,
                        index: number
                        ) => any;
                        renderActivePoints: ({
                        item,
                        activePoint,
                        basePoint,
                        childIndex,
                        isRange,
                        }: any) => import('react').ReactElement<
                        any,
                        string | import('react').JSXElementConstructor<any>
                        >[];
                        renderGraphicChild: (
                        element: any,
                        displayName: string,
                        index: number
                        ) => any[];
                        renderCustomized: (element: any, displayName: string, index: number) => any;
                        renderClipPath(): JSX.Element;
                        getXScales(): { [x: string]: Function | ScaleType };
                        getYScales(): { [x: string]: Function | ScaleType };
                        getXScaleByAxisId(
                        axisId: string
                        ): Function | import('../util/types').ScaleType;
                        getYScaleByAxisId(
                        axisId: string
                        ): Function | import('../util/types').ScaleType;
                        getItemByXY(chartXY: { x: number; y: number }): {
                        graphicalItem: any;
                        payload: any;
                        };
                        render(): JSX.Element;
                        context: any;
                        setState<K extends keyof CategoricalChartState>(
                        state:
                        | CategoricalChartState
                        | ((
                        prevState: Readonly<
                        import('./generateCategoricalChart').CategoricalChartState
                        >,
                        props: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >
                        ) => CategoricalChartState | Pick<CategoricalChartState, K>)
                        | Pick<CategoricalChartState, K>,
                        callback?: () => void
                        ): void;
                        forceUpdate(callback?: () => void): void;
                        readonly props: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        > &
                        Readonly<{ children?: import('react').ReactNode }>;
                        state: Readonly<import('./generateCategoricalChart').CategoricalChartState>;
                        refs: { [key: string]: any };
                        shouldComponentUpdate?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextState: Readonly<
                        import('./generateCategoricalChart').CategoricalChartState
                        >,
                        nextContext: any
                        ): boolean;
                        componentDidCatch?(error: Error, errorInfo: any): void;
                        getSnapshotBeforeUpdate?(
                        prevProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        prevState: Readonly<
                        import('./generateCategoricalChart').CategoricalChartState
                        >
                        ): any;
                        componentWillMount?(): void;
                        UNSAFE_componentWillMount?(): void;
                        componentWillReceiveProps?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillReceiveProps?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextContext: any
                        ): void;
                        componentWillUpdate?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextState: Readonly<
                        import('./generateCategoricalChart').CategoricalChartState
                        >,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillUpdate?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextState: Readonly<
                        import('./generateCategoricalChart').CategoricalChartState
                        >,
                        nextContext: any
                        ): void;
                        };
                        displayName: string;
                        defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                        getDerivedStateFromProps: (
                        nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                        prevState: import('./generateCategoricalChart').CategoricalChartState
                        ) => import('./generateCategoricalChart').CategoricalChartState;
                        renderActiveDot: (option: any, props: any) => any;
                        contextType?: any;
                        };

                          variable XAxis

                          const XAxis: FunctionComponent<Props>;

                            variable YAxis

                            const YAxis: FunctionComponent<Props>;

                              variable ZAxis

                              const ZAxis: FunctionComponent<Props>;

                                Functions

                                function Customized

                                Customized: typeof Customized;

                                  function ErrorBar

                                  ErrorBar: typeof ErrorBar;

                                    function Label

                                    Label: typeof Label;

                                      function LabelList

                                      LabelList: typeof LabelList;

                                        function Layer

                                        Layer: (props: Props) => JSX.Element;

                                          function ReferenceArea

                                          ReferenceArea: typeof ReferenceArea;

                                            function ReferenceDot

                                            ReferenceDot: typeof ReferenceDot;

                                              function ReferenceLine

                                              ReferenceLine: typeof ReferenceLine;

                                                function Surface

                                                Surface: (props: Props) => JSX.Element;

                                                  Classes

                                                  class Area

                                                  class Area extends PureComponent<Props, State> {}

                                                    property defaultProps

                                                    static defaultProps: {
                                                    stroke: string;
                                                    fill: string;
                                                    fillOpacity: number;
                                                    xAxisId: number;
                                                    yAxisId: number;
                                                    legendType: string;
                                                    connectNulls: boolean;
                                                    points: AreaPointItem[];
                                                    dot: boolean;
                                                    activeDot: boolean;
                                                    hide: boolean;
                                                    isAnimationActive: boolean;
                                                    animationBegin: number;
                                                    animationDuration: number;
                                                    animationEasing: string;
                                                    };

                                                      property displayName

                                                      static displayName: string;

                                                        property getBaseValue

                                                        static getBaseValue: (
                                                        props: Props,
                                                        xAxis: Props['xAxis'],
                                                        yAxis: Props['yAxis']
                                                        ) => number;

                                                          property getComposedData

                                                          static getComposedData: ({
                                                          props,
                                                          xAxis,
                                                          yAxis,
                                                          xAxisTicks,
                                                          yAxisTicks,
                                                          bandSize,
                                                          dataKey,
                                                          stackedData,
                                                          dataStartIndex,
                                                          displayedData,
                                                          offset,
                                                          }: {
                                                          props: Props;
                                                          item: Area;
                                                          bandSize: number;
                                                          xAxis: InternalAreaProps['xAxis'];
                                                          yAxis: InternalAreaProps['yAxis'];
                                                          xAxisTicks: TickItem[];
                                                          yAxisTicks: TickItem[];
                                                          stackedData: number[][];
                                                          dataStartIndex: number;
                                                          offset: ChartOffset;
                                                          displayedData: any[];
                                                          dataKey: Props['dataKey'];
                                                          }) => {
                                                          top?: number;
                                                          bottom?: number;
                                                          left?: number;
                                                          right?: number;
                                                          width?: number;
                                                          height?: number;
                                                          brushBottom?: number;
                                                          points: (
                                                          | { x: any; y: number; value: any[]; payload: any }
                                                          | { x: number; y: any; value: any[]; payload: any }
                                                          )[];
                                                          baseLine: number | { x: number; y: number }[];
                                                          layout: 'horizontal' | 'vertical';
                                                          isRange: boolean;
                                                          };

                                                            property handleAnimationEnd

                                                            handleAnimationEnd: () => void;

                                                              property handleAnimationStart

                                                              handleAnimationStart: () => void;

                                                                property id

                                                                id: string;

                                                                  property renderDotItem

                                                                  static renderDotItem: (option: AreaDot, props: any) => JSX.Element;

                                                                    property state

                                                                    state: State;

                                                                      method getDerivedStateFromProps

                                                                      static getDerivedStateFromProps: (nextProps: Props, prevState: State) => State;

                                                                        method render

                                                                        render: () => JSX.Element;

                                                                          method renderArea

                                                                          renderArea: (needClip: boolean, clipPathId: string) => JSX.Element;

                                                                            method renderAreaStatically

                                                                            renderAreaStatically: (
                                                                            points: AreaPointItem[],
                                                                            baseLine: Props['baseLine'],
                                                                            needClip: boolean,
                                                                            clipPathId: string
                                                                            ) => JSX.Element;

                                                                              method renderAreaWithAnimation

                                                                              renderAreaWithAnimation: (needClip: boolean, clipPathId: string) => JSX.Element;

                                                                                method renderClipRect

                                                                                renderClipRect: (alpha: number) => JSX.Element;

                                                                                  method renderDots

                                                                                  renderDots: (needClip: boolean, clipPathId: string) => JSX.Element;

                                                                                    method renderHorizontalRect

                                                                                    renderHorizontalRect: (alpha: number) => JSX.Element;

                                                                                      method renderVerticalRect

                                                                                      renderVerticalRect: (alpha: number) => JSX.Element;

                                                                                        class Bar

                                                                                        class Bar extends PureComponent<Props, State> {}

                                                                                          property defaultProps

                                                                                          static defaultProps: {
                                                                                          xAxisId: number;
                                                                                          yAxisId: number;
                                                                                          legendType: string;
                                                                                          minPointSize: number;
                                                                                          hide: boolean;
                                                                                          data: BarRectangleItem[];
                                                                                          layout: string;
                                                                                          isAnimationActive: boolean;
                                                                                          animationBegin: number;
                                                                                          animationDuration: number;
                                                                                          animationEasing: string;
                                                                                          };

                                                                                            property displayName

                                                                                            static displayName: string;

                                                                                              property getComposedData

                                                                                              static getComposedData: ({
                                                                                              props,
                                                                                              item,
                                                                                              barPosition,
                                                                                              bandSize,
                                                                                              xAxis,
                                                                                              yAxis,
                                                                                              xAxisTicks,
                                                                                              yAxisTicks,
                                                                                              stackedData,
                                                                                              dataStartIndex,
                                                                                              displayedData,
                                                                                              offset,
                                                                                              }: {
                                                                                              props: Props;
                                                                                              item: Bar;
                                                                                              barPosition: any;
                                                                                              bandSize: number;
                                                                                              xAxis: InternalBarProps['xAxis'];
                                                                                              yAxis: InternalBarProps['yAxis'];
                                                                                              xAxisTicks: TickItem[];
                                                                                              yAxisTicks: TickItem[];
                                                                                              stackedData: number[][];
                                                                                              dataStartIndex: number;
                                                                                              offset: ChartOffset;
                                                                                              displayedData: any[];
                                                                                              }) => {
                                                                                              top?: number;
                                                                                              bottom?: number;
                                                                                              left?: number;
                                                                                              right?: number;
                                                                                              width?: number;
                                                                                              height?: number;
                                                                                              brushBottom?: number;
                                                                                              data: any[];
                                                                                              layout: 'horizontal' | 'vertical';
                                                                                              };

                                                                                                property handleAnimationEnd

                                                                                                handleAnimationEnd: () => void;

                                                                                                  property handleAnimationStart

                                                                                                  handleAnimationStart: () => void;

                                                                                                    property id

                                                                                                    id: string;

                                                                                                      property state

                                                                                                      state: State;

                                                                                                        method getDerivedStateFromProps

                                                                                                        static getDerivedStateFromProps: (nextProps: Props, prevState: State) => State;

                                                                                                          method render

                                                                                                          render: () => JSX.Element;

                                                                                                            method renderBackground

                                                                                                            renderBackground: () => JSX.Element[];

                                                                                                              method renderErrorBar

                                                                                                              renderErrorBar: () => React.ReactElement<
                                                                                                              ErrorBarProps,
                                                                                                              string | React.JSXElementConstructor<any>
                                                                                                              >[];

                                                                                                                method renderRectangle

                                                                                                                static renderRectangle: (option: RectangleShapeType, props: any) => JSX.Element;

                                                                                                                  method renderRectangles

                                                                                                                  renderRectangles: () => JSX.Element | JSX.Element[];

                                                                                                                    method renderRectanglesStatically

                                                                                                                    renderRectanglesStatically: (data: BarRectangleItem[]) => JSX.Element[];

                                                                                                                      method renderRectanglesWithAnimation

                                                                                                                      renderRectanglesWithAnimation: () => JSX.Element;

                                                                                                                        class Brush

                                                                                                                        class Brush extends PureComponent<Props, State> {}

                                                                                                                          constructor

                                                                                                                          constructor(props: any);

                                                                                                                            property defaultProps

                                                                                                                            static defaultProps: {
                                                                                                                            height: number;
                                                                                                                            travellerWidth: number;
                                                                                                                            gap: number;
                                                                                                                            fill: string;
                                                                                                                            stroke: string;
                                                                                                                            padding: { top: number; right: number; bottom: number; left: number };
                                                                                                                            leaveTimeOut: number;
                                                                                                                            alwaysShowText: boolean;
                                                                                                                            };

                                                                                                                              property displayName

                                                                                                                              static displayName: string;

                                                                                                                                property handleDrag

                                                                                                                                handleDrag: (e: React.Touch | MouseEvent<SVGGElement>) => void;

                                                                                                                                  property handleDragEnd

                                                                                                                                  handleDragEnd: () => void;

                                                                                                                                    property handleEnterSlideOrTraveller

                                                                                                                                    handleEnterSlideOrTraveller: () => void;

                                                                                                                                      property handleLeaveSlideOrTraveller

                                                                                                                                      handleLeaveSlideOrTraveller: () => void;

                                                                                                                                        property handleLeaveWrapper

                                                                                                                                        handleLeaveWrapper: () => void;

                                                                                                                                          property handleSlideDragStart

                                                                                                                                          handleSlideDragStart: (
                                                                                                                                          e: TouchEvent<SVGRectElement> | MouseEvent<SVGRectElement>
                                                                                                                                          ) => void;

                                                                                                                                            property handleTouchMove

                                                                                                                                            handleTouchMove: (e: TouchEvent<SVGGElement>) => void;

                                                                                                                                              property leaveTimer

                                                                                                                                              leaveTimer?: number;

                                                                                                                                                property travellerDragStartHandlers

                                                                                                                                                travellerDragStartHandlers?: Record<
                                                                                                                                                BrushTravellerId,
                                                                                                                                                (event: MouseEvent<SVGGElement> | TouchEvent<SVGGElement>) => void
                                                                                                                                                >;

                                                                                                                                                  method attachDragEndListener

                                                                                                                                                  attachDragEndListener: () => void;

                                                                                                                                                    method componentWillUnmount

                                                                                                                                                    componentWillUnmount: () => void;

                                                                                                                                                      method detachDragEndListener

                                                                                                                                                      detachDragEndListener: () => void;

                                                                                                                                                        method getDerivedStateFromProps

                                                                                                                                                        static getDerivedStateFromProps: (nextProps: Props, prevState: State) => State;

                                                                                                                                                          method getIndex

                                                                                                                                                          getIndex: ({ startX, endX }: { startX: number; endX: number }) => {
                                                                                                                                                          startIndex: number;
                                                                                                                                                          endIndex: number;
                                                                                                                                                          };

                                                                                                                                                            method getIndexInRange

                                                                                                                                                            static getIndexInRange: (range: number[], x: number) => number;

                                                                                                                                                              method getTextOfTick

                                                                                                                                                              getTextOfTick: (index: number) => any;

                                                                                                                                                                method handleSlideDrag

                                                                                                                                                                handleSlideDrag: (e: React.Touch | MouseEvent<SVGGElement>) => void;

                                                                                                                                                                  method handleTravellerDragStart

                                                                                                                                                                  handleTravellerDragStart: (
                                                                                                                                                                  id: BrushTravellerId,
                                                                                                                                                                  e: MouseEvent<SVGGElement> | TouchEvent<SVGGElement>
                                                                                                                                                                  ) => void;

                                                                                                                                                                    method handleTravellerMove

                                                                                                                                                                    handleTravellerMove: (e: React.Touch | MouseEvent<SVGGElement>) => void;

                                                                                                                                                                      method render

                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                        method renderBackground

                                                                                                                                                                        renderBackground: () => JSX.Element;

                                                                                                                                                                          method renderDefaultTraveller

                                                                                                                                                                          static renderDefaultTraveller: (props: any) => JSX.Element;

                                                                                                                                                                            method renderPanorama

                                                                                                                                                                            renderPanorama: () => React.ReactElement<any, any>;

                                                                                                                                                                              method renderSlide

                                                                                                                                                                              renderSlide: (startX: number, endX: number) => JSX.Element;

                                                                                                                                                                                method renderText

                                                                                                                                                                                renderText: () => JSX.Element;

                                                                                                                                                                                  method renderTraveller

                                                                                                                                                                                  static renderTraveller: (option: BrushTravellerType, props: any) => JSX.Element;

                                                                                                                                                                                    method renderTravellerLayer

                                                                                                                                                                                    renderTravellerLayer: (travellerX: number, id: BrushTravellerId) => JSX.Element;

                                                                                                                                                                                      class CartesianAxis

                                                                                                                                                                                      class CartesianAxis extends Component<Props> {}