recharts

  • Version 2.12.7
  • Published
  • 4.65 MB
  • 8 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): {
readonly eventEmitterSymbol: Symbol;
clipPathId: string;
accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
throttleTriggeredAfterMouseMove: any;
container?: HTMLElement;
componentDidMount(): void;
displayDefaultTooltip(): void;
getSnapshotBeforeUpdate(
prevProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
prevState: Readonly<import('./types').CategoricalChartState>
): null;
componentDidUpdate(
prevProps: import('./generateCategoricalChart').CategoricalChartProps
): void;
componentWillUnmount(): void;
getTooltipEventType(): import('../util/types').TooltipEventType;
getMouseInfo(
event: import('./generateCategoricalChart').MousePointer
):
| { xValue: any; yValue: any; chartX: number; chartY: number }
| {
activeTooltipIndex: number;
activeLabel: any;
activePayload: any[];
activeCoordinate: import('../util/types').ChartCoordinate;
chartX: number;
chartY: number;
};
inRange(x: number, y: number, scale?: number): any;
parseEventsOfWrapper(): any;
addListener(): void;
removeListener(): void;
handleLegendBBoxUpdate: (box: DOMRect) => void;
handleReceiveSyncEvent: (
cId: string | number,
data: import('./types').CategoricalChartState,
emitter: Symbol
) => void;
handleBrushChange: ({
startIndex,
endIndex,
}: {
startIndex: number;
endIndex: number;
}) => void;
handleMouseEnter: (e: any) => void;
triggeredAfterMouseMove: (
e: import('./generateCategoricalChart').MousePointer
) => any;
handleItemMouseEnter: (el: any) => void;
handleItemMouseLeave: () => void;
handleMouseMove: (
e: import('./generateCategoricalChart').MousePointer &
Partial<
Omit<
import('react').MouseEvent<Element, MouseEvent>,
keyof import('./generateCategoricalChart').MousePointer
>
>
) => void;
handleMouseLeave: (e: any) => void;
handleOuterEvent: (
e:
| import('react').MouseEvent<Element, MouseEvent>
| import('react').TouchEvent<Element>
) => void;
handleClick: (e: any) => void;
handleMouseDown: (
e:
| import('react').MouseEvent<Element, MouseEvent>
| import('react').Touch
) => void;
handleMouseUp: (
e:
| import('react').MouseEvent<Element, MouseEvent>
| import('react').Touch
) => void;
handleTouchMove: (e: any) => void;
handleTouchStart: (e: any) => void;
handleTouchEnd: (e: any) => void;
triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
applySyncEvent: (data: import('./types').CategoricalChartState) => void;
filterFormatItem(item: any, displayName: any, childIndex: any): any;
renderCursor: (element: any) => any;
renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
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;
};
renderMap: {
CartesianGrid: { handler: (element: any) => any; once: boolean };
ReferenceArea: {
handler: (element: any, displayName: string, index: number) => any;
};
ReferenceLine: { handler: (element: any) => any };
ReferenceDot: {
handler: (element: any, displayName: string, index: number) => any;
};
XAxis: { handler: (element: any) => any };
YAxis: { handler: (element: any) => any };
Brush: { handler: (element: any) => any; once: boolean };
Bar: {
handler: (element: any, displayName: string, index: number) => any[];
};
Line: {
handler: (element: any, displayName: string, index: number) => any[];
};
Area: {
handler: (element: any, displayName: string, index: number) => any[];
};
Radar: {
handler: (element: any, displayName: string, index: number) => any[];
};
RadialBar: {
handler: (element: any, displayName: string, index: number) => any[];
};
Scatter: {
handler: (element: any, displayName: string, index: number) => any[];
};
Pie: {
handler: (element: any, displayName: string, index: number) => any[];
};
Funnel: {
handler: (element: any, displayName: string, index: number) => any[];
};
Tooltip: { handler: (element: any) => any; once: boolean };
PolarGrid: { handler: (element: any) => any; once: boolean };
PolarAngleAxis: {
handler: (element: any, displayName: string, index: number) => any;
};
PolarRadiusAxis: {
handler: (element: any, displayName: string, index: number) => any;
};
Customized: {
handler: (element: any, displayName: string, index: number) => any;
};
};
render(): any;
context: any;
setState<K extends keyof CategoricalChartState>(
state:
| CategoricalChartState
| ((
prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
refs: { [key: string]: any };
shouldComponentUpdate?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextState: Readonly<import('./types').CategoricalChartState>,
nextContext: any
): boolean;
componentDidCatch?(error: Error, errorInfo: any): void;
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('./types').CategoricalChartState>,
nextContext: any
): void;
UNSAFE_componentWillUpdate?(
nextProps: Readonly<
import('./generateCategoricalChart').CategoricalChartProps
>,
nextState: Readonly<import('./types').CategoricalChartState>,
nextContext: any
): void;
};
displayName: string;
defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
getDerivedStateFromProps: (
nextProps: import('./generateCategoricalChart').CategoricalChartProps,
prevState: import('./types').CategoricalChartState
) => import('./types').CategoricalChartState;
renderActiveDot: (option: any, props: any) => any;
contextType?: any;
};

    variable BarChart

    const BarChart: {
    new (props: import('./generateCategoricalChart').CategoricalChartProps): {
    readonly eventEmitterSymbol: Symbol;
    clipPathId: string;
    accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
    throttleTriggeredAfterMouseMove: any;
    container?: HTMLElement;
    componentDidMount(): void;
    displayDefaultTooltip(): void;
    getSnapshotBeforeUpdate(
    prevProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    prevState: Readonly<import('./types').CategoricalChartState>
    ): null;
    componentDidUpdate(
    prevProps: import('./generateCategoricalChart').CategoricalChartProps
    ): void;
    componentWillUnmount(): void;
    getTooltipEventType(): import('../util/types').TooltipEventType;
    getMouseInfo(
    event: import('./generateCategoricalChart').MousePointer
    ):
    | { xValue: any; yValue: any; chartX: number; chartY: number }
    | {
    activeTooltipIndex: number;
    activeLabel: any;
    activePayload: any[];
    activeCoordinate: import('../util/types').ChartCoordinate;
    chartX: number;
    chartY: number;
    };
    inRange(x: number, y: number, scale?: number): any;
    parseEventsOfWrapper(): any;
    addListener(): void;
    removeListener(): void;
    handleLegendBBoxUpdate: (box: DOMRect) => void;
    handleReceiveSyncEvent: (
    cId: string | number,
    data: import('./types').CategoricalChartState,
    emitter: Symbol
    ) => void;
    handleBrushChange: ({
    startIndex,
    endIndex,
    }: {
    startIndex: number;
    endIndex: number;
    }) => void;
    handleMouseEnter: (e: any) => void;
    triggeredAfterMouseMove: (
    e: import('./generateCategoricalChart').MousePointer
    ) => any;
    handleItemMouseEnter: (el: any) => void;
    handleItemMouseLeave: () => void;
    handleMouseMove: (
    e: import('./generateCategoricalChart').MousePointer &
    Partial<
    Omit<
    import('react').MouseEvent<Element, MouseEvent>,
    keyof import('./generateCategoricalChart').MousePointer
    >
    >
    ) => void;
    handleMouseLeave: (e: any) => void;
    handleOuterEvent: (
    e:
    | import('react').MouseEvent<Element, MouseEvent>
    | import('react').TouchEvent<Element>
    ) => void;
    handleClick: (e: any) => void;
    handleMouseDown: (
    e:
    | import('react').MouseEvent<Element, MouseEvent>
    | import('react').Touch
    ) => void;
    handleMouseUp: (
    e:
    | import('react').MouseEvent<Element, MouseEvent>
    | import('react').Touch
    ) => void;
    handleTouchMove: (e: any) => void;
    handleTouchStart: (e: any) => void;
    handleTouchEnd: (e: any) => void;
    triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
    applySyncEvent: (data: import('./types').CategoricalChartState) => void;
    filterFormatItem(item: any, displayName: any, childIndex: any): any;
    renderCursor: (element: any) => any;
    renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
    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;
    };
    renderMap: {
    CartesianGrid: { handler: (element: any) => any; once: boolean };
    ReferenceArea: {
    handler: (element: any, displayName: string, index: number) => any;
    };
    ReferenceLine: { handler: (element: any) => any };
    ReferenceDot: {
    handler: (element: any, displayName: string, index: number) => any;
    };
    XAxis: { handler: (element: any) => any };
    YAxis: { handler: (element: any) => any };
    Brush: { handler: (element: any) => any; once: boolean };
    Bar: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Line: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Area: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Radar: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    RadialBar: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Scatter: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Pie: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Funnel: {
    handler: (element: any, displayName: string, index: number) => any[];
    };
    Tooltip: { handler: (element: any) => any; once: boolean };
    PolarGrid: { handler: (element: any) => any; once: boolean };
    PolarAngleAxis: {
    handler: (element: any, displayName: string, index: number) => any;
    };
    PolarRadiusAxis: {
    handler: (element: any, displayName: string, index: number) => any;
    };
    Customized: {
    handler: (element: any, displayName: string, index: number) => any;
    };
    };
    render(): any;
    context: any;
    setState<K extends keyof CategoricalChartState>(
    state:
    | CategoricalChartState
    | ((
    prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
    refs: { [key: string]: any };
    shouldComponentUpdate?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextState: Readonly<import('./types').CategoricalChartState>,
    nextContext: any
    ): boolean;
    componentDidCatch?(error: Error, errorInfo: any): void;
    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('./types').CategoricalChartState>,
    nextContext: any
    ): void;
    UNSAFE_componentWillUpdate?(
    nextProps: Readonly<
    import('./generateCategoricalChart').CategoricalChartProps
    >,
    nextState: Readonly<import('./types').CategoricalChartState>,
    nextContext: any
    ): void;
    };
    displayName: string;
    defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
    getDerivedStateFromProps: (
    nextProps: import('./generateCategoricalChart').CategoricalChartProps,
    prevState: import('./types').CategoricalChartState
    ) => import('./types').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): {
        readonly eventEmitterSymbol: Symbol;
        clipPathId: string;
        accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
        throttleTriggeredAfterMouseMove: any;
        container?: HTMLElement;
        componentDidMount(): void;
        displayDefaultTooltip(): void;
        getSnapshotBeforeUpdate(
        prevProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        prevState: Readonly<import('./types').CategoricalChartState>
        ): null;
        componentDidUpdate(
        prevProps: import('./generateCategoricalChart').CategoricalChartProps
        ): void;
        componentWillUnmount(): void;
        getTooltipEventType(): import('../util/types').TooltipEventType;
        getMouseInfo(
        event: import('./generateCategoricalChart').MousePointer
        ):
        | { xValue: any; yValue: any; chartX: number; chartY: number }
        | {
        activeTooltipIndex: number;
        activeLabel: any;
        activePayload: any[];
        activeCoordinate: import('../util/types').ChartCoordinate;
        chartX: number;
        chartY: number;
        };
        inRange(x: number, y: number, scale?: number): any;
        parseEventsOfWrapper(): any;
        addListener(): void;
        removeListener(): void;
        handleLegendBBoxUpdate: (box: DOMRect) => void;
        handleReceiveSyncEvent: (
        cId: string | number,
        data: import('./types').CategoricalChartState,
        emitter: Symbol
        ) => void;
        handleBrushChange: ({
        startIndex,
        endIndex,
        }: {
        startIndex: number;
        endIndex: number;
        }) => void;
        handleMouseEnter: (e: any) => void;
        triggeredAfterMouseMove: (
        e: import('./generateCategoricalChart').MousePointer
        ) => any;
        handleItemMouseEnter: (el: any) => void;
        handleItemMouseLeave: () => void;
        handleMouseMove: (
        e: import('./generateCategoricalChart').MousePointer &
        Partial<
        Omit<
        import('react').MouseEvent<Element, MouseEvent>,
        keyof import('./generateCategoricalChart').MousePointer
        >
        >
        ) => void;
        handleMouseLeave: (e: any) => void;
        handleOuterEvent: (
        e:
        | import('react').MouseEvent<Element, MouseEvent>
        | import('react').TouchEvent<Element>
        ) => void;
        handleClick: (e: any) => void;
        handleMouseDown: (
        e:
        | import('react').MouseEvent<Element, MouseEvent>
        | import('react').Touch
        ) => void;
        handleMouseUp: (
        e:
        | import('react').MouseEvent<Element, MouseEvent>
        | import('react').Touch
        ) => void;
        handleTouchMove: (e: any) => void;
        handleTouchStart: (e: any) => void;
        handleTouchEnd: (e: any) => void;
        triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
        applySyncEvent: (data: import('./types').CategoricalChartState) => void;
        filterFormatItem(item: any, displayName: any, childIndex: any): any;
        renderCursor: (element: any) => any;
        renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
        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;
        };
        renderMap: {
        CartesianGrid: { handler: (element: any) => any; once: boolean };
        ReferenceArea: {
        handler: (element: any, displayName: string, index: number) => any;
        };
        ReferenceLine: { handler: (element: any) => any };
        ReferenceDot: {
        handler: (element: any, displayName: string, index: number) => any;
        };
        XAxis: { handler: (element: any) => any };
        YAxis: { handler: (element: any) => any };
        Brush: { handler: (element: any) => any; once: boolean };
        Bar: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Line: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Area: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Radar: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        RadialBar: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Scatter: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Pie: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Funnel: {
        handler: (element: any, displayName: string, index: number) => any[];
        };
        Tooltip: { handler: (element: any) => any; once: boolean };
        PolarGrid: { handler: (element: any) => any; once: boolean };
        PolarAngleAxis: {
        handler: (element: any, displayName: string, index: number) => any;
        };
        PolarRadiusAxis: {
        handler: (element: any, displayName: string, index: number) => any;
        };
        Customized: {
        handler: (element: any, displayName: string, index: number) => any;
        };
        };
        render(): any;
        context: any;
        setState<K extends keyof CategoricalChartState>(
        state:
        | CategoricalChartState
        | ((
        prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
        refs: { [key: string]: any };
        shouldComponentUpdate?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextState: Readonly<import('./types').CategoricalChartState>,
        nextContext: any
        ): boolean;
        componentDidCatch?(error: Error, errorInfo: any): void;
        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('./types').CategoricalChartState>,
        nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
        nextProps: Readonly<
        import('./generateCategoricalChart').CategoricalChartProps
        >,
        nextState: Readonly<import('./types').CategoricalChartState>,
        nextContext: any
        ): void;
        };
        displayName: string;
        defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
        getDerivedStateFromProps: (
        nextProps: import('./generateCategoricalChart').CategoricalChartProps,
        prevState: import('./types').CategoricalChartState
        ) => import('./types').CategoricalChartState;
        renderActiveDot: (option: any, props: any) => any;
        contextType?: any;
        };

          variable Cross

          const Cross: React.FC<any>;

            variable Curve

            const Curve: React.FC<Props>;

              variable Dot

              const Dot: React.FC<any>;

                variable FunnelChart

                const FunnelChart: {
                new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                readonly eventEmitterSymbol: Symbol;
                clipPathId: string;
                accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                throttleTriggeredAfterMouseMove: any;
                container?: HTMLElement;
                componentDidMount(): void;
                displayDefaultTooltip(): void;
                getSnapshotBeforeUpdate(
                prevProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                prevState: Readonly<import('./types').CategoricalChartState>
                ): null;
                componentDidUpdate(
                prevProps: import('./generateCategoricalChart').CategoricalChartProps
                ): void;
                componentWillUnmount(): void;
                getTooltipEventType(): import('../util/types').TooltipEventType;
                getMouseInfo(
                event: import('./generateCategoricalChart').MousePointer
                ):
                | { xValue: any; yValue: any; chartX: number; chartY: number }
                | {
                activeTooltipIndex: number;
                activeLabel: any;
                activePayload: any[];
                activeCoordinate: import('../util/types').ChartCoordinate;
                chartX: number;
                chartY: number;
                };
                inRange(x: number, y: number, scale?: number): any;
                parseEventsOfWrapper(): any;
                addListener(): void;
                removeListener(): void;
                handleLegendBBoxUpdate: (box: DOMRect) => void;
                handleReceiveSyncEvent: (
                cId: string | number,
                data: import('./types').CategoricalChartState,
                emitter: Symbol
                ) => void;
                handleBrushChange: ({
                startIndex,
                endIndex,
                }: {
                startIndex: number;
                endIndex: number;
                }) => void;
                handleMouseEnter: (e: any) => void;
                triggeredAfterMouseMove: (
                e: import('./generateCategoricalChart').MousePointer
                ) => any;
                handleItemMouseEnter: (el: any) => void;
                handleItemMouseLeave: () => void;
                handleMouseMove: (
                e: import('./generateCategoricalChart').MousePointer &
                Partial<
                Omit<
                import('react').MouseEvent<Element, MouseEvent>,
                keyof import('./generateCategoricalChart').MousePointer
                >
                >
                ) => void;
                handleMouseLeave: (e: any) => void;
                handleOuterEvent: (
                e:
                | import('react').MouseEvent<Element, MouseEvent>
                | import('react').TouchEvent<Element>
                ) => void;
                handleClick: (e: any) => void;
                handleMouseDown: (
                e:
                | import('react').MouseEvent<Element, MouseEvent>
                | import('react').Touch
                ) => void;
                handleMouseUp: (
                e:
                | import('react').MouseEvent<Element, MouseEvent>
                | import('react').Touch
                ) => void;
                handleTouchMove: (e: any) => void;
                handleTouchStart: (e: any) => void;
                handleTouchEnd: (e: any) => void;
                triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                filterFormatItem(item: any, displayName: any, childIndex: any): any;
                renderCursor: (element: any) => any;
                renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                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;
                };
                renderMap: {
                CartesianGrid: { handler: (element: any) => any; once: boolean };
                ReferenceArea: {
                handler: (element: any, displayName: string, index: number) => any;
                };
                ReferenceLine: { handler: (element: any) => any };
                ReferenceDot: {
                handler: (element: any, displayName: string, index: number) => any;
                };
                XAxis: { handler: (element: any) => any };
                YAxis: { handler: (element: any) => any };
                Brush: { handler: (element: any) => any; once: boolean };
                Bar: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Line: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Area: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Radar: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                RadialBar: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Scatter: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Pie: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Funnel: {
                handler: (element: any, displayName: string, index: number) => any[];
                };
                Tooltip: { handler: (element: any) => any; once: boolean };
                PolarGrid: { handler: (element: any) => any; once: boolean };
                PolarAngleAxis: {
                handler: (element: any, displayName: string, index: number) => any;
                };
                PolarRadiusAxis: {
                handler: (element: any, displayName: string, index: number) => any;
                };
                Customized: {
                handler: (element: any, displayName: string, index: number) => any;
                };
                };
                render(): any;
                context: any;
                setState<K extends keyof CategoricalChartState>(
                state:
                | CategoricalChartState
                | ((
                prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                refs: { [key: string]: any };
                shouldComponentUpdate?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextState: Readonly<import('./types').CategoricalChartState>,
                nextContext: any
                ): boolean;
                componentDidCatch?(error: Error, errorInfo: any): void;
                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('./types').CategoricalChartState>,
                nextContext: any
                ): void;
                UNSAFE_componentWillUpdate?(
                nextProps: Readonly<
                import('./generateCategoricalChart').CategoricalChartProps
                >,
                nextState: Readonly<import('./types').CategoricalChartState>,
                nextContext: any
                ): void;
                };
                displayName: string;
                defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                getDerivedStateFromProps: (
                nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                prevState: import('./types').CategoricalChartState
                ) => import('./types').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 Layer

                    const Layer: React.ForwardRefExoticComponent<any>;

                      variable LineChart

                      const LineChart: {
                      new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                      readonly eventEmitterSymbol: Symbol;
                      clipPathId: string;
                      accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                      throttleTriggeredAfterMouseMove: any;
                      container?: HTMLElement;
                      componentDidMount(): void;
                      displayDefaultTooltip(): void;
                      getSnapshotBeforeUpdate(
                      prevProps: Readonly<
                      import('./generateCategoricalChart').CategoricalChartProps
                      >,
                      prevState: Readonly<import('./types').CategoricalChartState>
                      ): null;
                      componentDidUpdate(
                      prevProps: import('./generateCategoricalChart').CategoricalChartProps
                      ): void;
                      componentWillUnmount(): void;
                      getTooltipEventType(): import('../util/types').TooltipEventType;
                      getMouseInfo(
                      event: import('./generateCategoricalChart').MousePointer
                      ):
                      | { xValue: any; yValue: any; chartX: number; chartY: number }
                      | {
                      activeTooltipIndex: number;
                      activeLabel: any;
                      activePayload: any[];
                      activeCoordinate: import('../util/types').ChartCoordinate;
                      chartX: number;
                      chartY: number;
                      };
                      inRange(x: number, y: number, scale?: number): any;
                      parseEventsOfWrapper(): any;
                      addListener(): void;
                      removeListener(): void;
                      handleLegendBBoxUpdate: (box: DOMRect) => void;
                      handleReceiveSyncEvent: (
                      cId: string | number,
                      data: import('./types').CategoricalChartState,
                      emitter: Symbol
                      ) => void;
                      handleBrushChange: ({
                      startIndex,
                      endIndex,
                      }: {
                      startIndex: number;
                      endIndex: number;
                      }) => void;
                      handleMouseEnter: (e: any) => void;
                      triggeredAfterMouseMove: (
                      e: import('./generateCategoricalChart').MousePointer
                      ) => any;
                      handleItemMouseEnter: (el: any) => void;
                      handleItemMouseLeave: () => void;
                      handleMouseMove: (
                      e: import('./generateCategoricalChart').MousePointer &
                      Partial<
                      Omit<
                      import('react').MouseEvent<Element, MouseEvent>,
                      keyof import('./generateCategoricalChart').MousePointer
                      >
                      >
                      ) => void;
                      handleMouseLeave: (e: any) => void;
                      handleOuterEvent: (
                      e:
                      | import('react').MouseEvent<Element, MouseEvent>
                      | import('react').TouchEvent<Element>
                      ) => void;
                      handleClick: (e: any) => void;
                      handleMouseDown: (
                      e:
                      | import('react').MouseEvent<Element, MouseEvent>
                      | import('react').Touch
                      ) => void;
                      handleMouseUp: (
                      e:
                      | import('react').MouseEvent<Element, MouseEvent>
                      | import('react').Touch
                      ) => void;
                      handleTouchMove: (e: any) => void;
                      handleTouchStart: (e: any) => void;
                      handleTouchEnd: (e: any) => void;
                      triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                      applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                      filterFormatItem(item: any, displayName: any, childIndex: any): any;
                      renderCursor: (element: any) => any;
                      renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                      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;
                      };
                      renderMap: {
                      CartesianGrid: { handler: (element: any) => any; once: boolean };
                      ReferenceArea: {
                      handler: (element: any, displayName: string, index: number) => any;
                      };
                      ReferenceLine: { handler: (element: any) => any };
                      ReferenceDot: {
                      handler: (element: any, displayName: string, index: number) => any;
                      };
                      XAxis: { handler: (element: any) => any };
                      YAxis: { handler: (element: any) => any };
                      Brush: { handler: (element: any) => any; once: boolean };
                      Bar: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Line: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Area: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Radar: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      RadialBar: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Scatter: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Pie: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Funnel: {
                      handler: (element: any, displayName: string, index: number) => any[];
                      };
                      Tooltip: { handler: (element: any) => any; once: boolean };
                      PolarGrid: { handler: (element: any) => any; once: boolean };
                      PolarAngleAxis: {
                      handler: (element: any, displayName: string, index: number) => any;
                      };
                      PolarRadiusAxis: {
                      handler: (element: any, displayName: string, index: number) => any;
                      };
                      Customized: {
                      handler: (element: any, displayName: string, index: number) => any;
                      };
                      };
                      render(): any;
                      context: any;
                      setState<K extends keyof CategoricalChartState>(
                      state:
                      | CategoricalChartState
                      | ((
                      prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                      refs: { [key: string]: any };
                      shouldComponentUpdate?(
                      nextProps: Readonly<
                      import('./generateCategoricalChart').CategoricalChartProps
                      >,
                      nextState: Readonly<import('./types').CategoricalChartState>,
                      nextContext: any
                      ): boolean;
                      componentDidCatch?(error: Error, errorInfo: any): void;
                      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('./types').CategoricalChartState>,
                      nextContext: any
                      ): void;
                      UNSAFE_componentWillUpdate?(
                      nextProps: Readonly<
                      import('./generateCategoricalChart').CategoricalChartProps
                      >,
                      nextState: Readonly<import('./types').CategoricalChartState>,
                      nextContext: any
                      ): void;
                      };
                      displayName: string;
                      defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                      getDerivedStateFromProps: (
                      nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                      prevState: import('./types').CategoricalChartState
                      ) => import('./types').CategoricalChartState;
                      renderActiveDot: (option: any, props: any) => any;
                      contextType?: any;
                      };

                        variable PieChart

                        const PieChart: {
                        new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                        readonly eventEmitterSymbol: Symbol;
                        clipPathId: string;
                        accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                        throttleTriggeredAfterMouseMove: any;
                        container?: HTMLElement;
                        componentDidMount(): void;
                        displayDefaultTooltip(): void;
                        getSnapshotBeforeUpdate(
                        prevProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        prevState: Readonly<import('./types').CategoricalChartState>
                        ): null;
                        componentDidUpdate(
                        prevProps: import('./generateCategoricalChart').CategoricalChartProps
                        ): void;
                        componentWillUnmount(): void;
                        getTooltipEventType(): import('../util/types').TooltipEventType;
                        getMouseInfo(
                        event: import('./generateCategoricalChart').MousePointer
                        ):
                        | { xValue: any; yValue: any; chartX: number; chartY: number }
                        | {
                        activeTooltipIndex: number;
                        activeLabel: any;
                        activePayload: any[];
                        activeCoordinate: import('../util/types').ChartCoordinate;
                        chartX: number;
                        chartY: number;
                        };
                        inRange(x: number, y: number, scale?: number): any;
                        parseEventsOfWrapper(): any;
                        addListener(): void;
                        removeListener(): void;
                        handleLegendBBoxUpdate: (box: DOMRect) => void;
                        handleReceiveSyncEvent: (
                        cId: string | number,
                        data: import('./types').CategoricalChartState,
                        emitter: Symbol
                        ) => void;
                        handleBrushChange: ({
                        startIndex,
                        endIndex,
                        }: {
                        startIndex: number;
                        endIndex: number;
                        }) => void;
                        handleMouseEnter: (e: any) => void;
                        triggeredAfterMouseMove: (
                        e: import('./generateCategoricalChart').MousePointer
                        ) => any;
                        handleItemMouseEnter: (el: any) => void;
                        handleItemMouseLeave: () => void;
                        handleMouseMove: (
                        e: import('./generateCategoricalChart').MousePointer &
                        Partial<
                        Omit<
                        import('react').MouseEvent<Element, MouseEvent>,
                        keyof import('./generateCategoricalChart').MousePointer
                        >
                        >
                        ) => void;
                        handleMouseLeave: (e: any) => void;
                        handleOuterEvent: (
                        e:
                        | import('react').MouseEvent<Element, MouseEvent>
                        | import('react').TouchEvent<Element>
                        ) => void;
                        handleClick: (e: any) => void;
                        handleMouseDown: (
                        e:
                        | import('react').MouseEvent<Element, MouseEvent>
                        | import('react').Touch
                        ) => void;
                        handleMouseUp: (
                        e:
                        | import('react').MouseEvent<Element, MouseEvent>
                        | import('react').Touch
                        ) => void;
                        handleTouchMove: (e: any) => void;
                        handleTouchStart: (e: any) => void;
                        handleTouchEnd: (e: any) => void;
                        triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                        applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                        filterFormatItem(item: any, displayName: any, childIndex: any): any;
                        renderCursor: (element: any) => any;
                        renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                        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;
                        };
                        renderMap: {
                        CartesianGrid: { handler: (element: any) => any; once: boolean };
                        ReferenceArea: {
                        handler: (element: any, displayName: string, index: number) => any;
                        };
                        ReferenceLine: { handler: (element: any) => any };
                        ReferenceDot: {
                        handler: (element: any, displayName: string, index: number) => any;
                        };
                        XAxis: { handler: (element: any) => any };
                        YAxis: { handler: (element: any) => any };
                        Brush: { handler: (element: any) => any; once: boolean };
                        Bar: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Line: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Area: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Radar: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        RadialBar: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Scatter: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Pie: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Funnel: {
                        handler: (element: any, displayName: string, index: number) => any[];
                        };
                        Tooltip: { handler: (element: any) => any; once: boolean };
                        PolarGrid: { handler: (element: any) => any; once: boolean };
                        PolarAngleAxis: {
                        handler: (element: any, displayName: string, index: number) => any;
                        };
                        PolarRadiusAxis: {
                        handler: (element: any, displayName: string, index: number) => any;
                        };
                        Customized: {
                        handler: (element: any, displayName: string, index: number) => any;
                        };
                        };
                        render(): any;
                        context: any;
                        setState<K extends keyof CategoricalChartState>(
                        state:
                        | CategoricalChartState
                        | ((
                        prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                        refs: { [key: string]: any };
                        shouldComponentUpdate?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextState: Readonly<import('./types').CategoricalChartState>,
                        nextContext: any
                        ): boolean;
                        componentDidCatch?(error: Error, errorInfo: any): void;
                        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('./types').CategoricalChartState>,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillUpdate?(
                        nextProps: Readonly<
                        import('./generateCategoricalChart').CategoricalChartProps
                        >,
                        nextState: Readonly<import('./types').CategoricalChartState>,
                        nextContext: any
                        ): void;
                        };
                        displayName: string;
                        defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                        getDerivedStateFromProps: (
                        nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                        prevState: import('./types').CategoricalChartState
                        ) => import('./types').CategoricalChartState;
                        renderActiveDot: (option: any, props: any) => any;
                        contextType?: any;
                        };

                          variable PolarGrid

                          const PolarGrid: {
                          ({
                          cx,
                          cy,
                          innerRadius,
                          outerRadius,
                          gridType,
                          radialLines,
                          ...props
                          }: Props): React.JSX.Element;
                          displayName: string;
                          };

                            variable Polygon

                            const Polygon: React.FC<Props>;

                              variable RadarChart

                              const RadarChart: {
                              new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                              readonly eventEmitterSymbol: Symbol;
                              clipPathId: string;
                              accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                              throttleTriggeredAfterMouseMove: any;
                              container?: HTMLElement;
                              componentDidMount(): void;
                              displayDefaultTooltip(): void;
                              getSnapshotBeforeUpdate(
                              prevProps: Readonly<
                              import('./generateCategoricalChart').CategoricalChartProps
                              >,
                              prevState: Readonly<import('./types').CategoricalChartState>
                              ): null;
                              componentDidUpdate(
                              prevProps: import('./generateCategoricalChart').CategoricalChartProps
                              ): void;
                              componentWillUnmount(): void;
                              getTooltipEventType(): import('../util/types').TooltipEventType;
                              getMouseInfo(
                              event: import('./generateCategoricalChart').MousePointer
                              ):
                              | { xValue: any; yValue: any; chartX: number; chartY: number }
                              | {
                              activeTooltipIndex: number;
                              activeLabel: any;
                              activePayload: any[];
                              activeCoordinate: import('../util/types').ChartCoordinate;
                              chartX: number;
                              chartY: number;
                              };
                              inRange(x: number, y: number, scale?: number): any;
                              parseEventsOfWrapper(): any;
                              addListener(): void;
                              removeListener(): void;
                              handleLegendBBoxUpdate: (box: DOMRect) => void;
                              handleReceiveSyncEvent: (
                              cId: string | number,
                              data: import('./types').CategoricalChartState,
                              emitter: Symbol
                              ) => void;
                              handleBrushChange: ({
                              startIndex,
                              endIndex,
                              }: {
                              startIndex: number;
                              endIndex: number;
                              }) => void;
                              handleMouseEnter: (e: any) => void;
                              triggeredAfterMouseMove: (
                              e: import('./generateCategoricalChart').MousePointer
                              ) => any;
                              handleItemMouseEnter: (el: any) => void;
                              handleItemMouseLeave: () => void;
                              handleMouseMove: (
                              e: import('./generateCategoricalChart').MousePointer &
                              Partial<
                              Omit<
                              import('react').MouseEvent<Element, MouseEvent>,
                              keyof import('./generateCategoricalChart').MousePointer
                              >
                              >
                              ) => void;
                              handleMouseLeave: (e: any) => void;
                              handleOuterEvent: (
                              e:
                              | import('react').MouseEvent<Element, MouseEvent>
                              | import('react').TouchEvent<Element>
                              ) => void;
                              handleClick: (e: any) => void;
                              handleMouseDown: (
                              e:
                              | import('react').MouseEvent<Element, MouseEvent>
                              | import('react').Touch
                              ) => void;
                              handleMouseUp: (
                              e:
                              | import('react').MouseEvent<Element, MouseEvent>
                              | import('react').Touch
                              ) => void;
                              handleTouchMove: (e: any) => void;
                              handleTouchStart: (e: any) => void;
                              handleTouchEnd: (e: any) => void;
                              triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                              applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                              filterFormatItem(item: any, displayName: any, childIndex: any): any;
                              renderCursor: (element: any) => any;
                              renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                              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;
                              };
                              renderMap: {
                              CartesianGrid: { handler: (element: any) => any; once: boolean };
                              ReferenceArea: {
                              handler: (element: any, displayName: string, index: number) => any;
                              };
                              ReferenceLine: { handler: (element: any) => any };
                              ReferenceDot: {
                              handler: (element: any, displayName: string, index: number) => any;
                              };
                              XAxis: { handler: (element: any) => any };
                              YAxis: { handler: (element: any) => any };
                              Brush: { handler: (element: any) => any; once: boolean };
                              Bar: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Line: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Area: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Radar: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              RadialBar: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Scatter: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Pie: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Funnel: {
                              handler: (element: any, displayName: string, index: number) => any[];
                              };
                              Tooltip: { handler: (element: any) => any; once: boolean };
                              PolarGrid: { handler: (element: any) => any; once: boolean };
                              PolarAngleAxis: {
                              handler: (element: any, displayName: string, index: number) => any;
                              };
                              PolarRadiusAxis: {
                              handler: (element: any, displayName: string, index: number) => any;
                              };
                              Customized: {
                              handler: (element: any, displayName: string, index: number) => any;
                              };
                              };
                              render(): any;
                              context: any;
                              setState<K extends keyof CategoricalChartState>(
                              state:
                              | CategoricalChartState
                              | ((
                              prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                              refs: { [key: string]: any };
                              shouldComponentUpdate?(
                              nextProps: Readonly<
                              import('./generateCategoricalChart').CategoricalChartProps
                              >,
                              nextState: Readonly<import('./types').CategoricalChartState>,
                              nextContext: any
                              ): boolean;
                              componentDidCatch?(error: Error, errorInfo: any): void;
                              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('./types').CategoricalChartState>,
                              nextContext: any
                              ): void;
                              UNSAFE_componentWillUpdate?(
                              nextProps: Readonly<
                              import('./generateCategoricalChart').CategoricalChartProps
                              >,
                              nextState: Readonly<import('./types').CategoricalChartState>,
                              nextContext: any
                              ): void;
                              };
                              displayName: string;
                              defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                              getDerivedStateFromProps: (
                              nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                              prevState: import('./types').CategoricalChartState
                              ) => import('./types').CategoricalChartState;
                              renderActiveDot: (option: any, props: any) => any;
                              contextType?: any;
                              };

                                variable RadialBarChart

                                const RadialBarChart: {
                                new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                                readonly eventEmitterSymbol: Symbol;
                                clipPathId: string;
                                accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                                throttleTriggeredAfterMouseMove: any;
                                container?: HTMLElement;
                                componentDidMount(): void;
                                displayDefaultTooltip(): void;
                                getSnapshotBeforeUpdate(
                                prevProps: Readonly<
                                import('./generateCategoricalChart').CategoricalChartProps
                                >,
                                prevState: Readonly<import('./types').CategoricalChartState>
                                ): null;
                                componentDidUpdate(
                                prevProps: import('./generateCategoricalChart').CategoricalChartProps
                                ): void;
                                componentWillUnmount(): void;
                                getTooltipEventType(): import('../util/types').TooltipEventType;
                                getMouseInfo(
                                event: import('./generateCategoricalChart').MousePointer
                                ):
                                | { xValue: any; yValue: any; chartX: number; chartY: number }
                                | {
                                activeTooltipIndex: number;
                                activeLabel: any;
                                activePayload: any[];
                                activeCoordinate: import('../util/types').ChartCoordinate;
                                chartX: number;
                                chartY: number;
                                };
                                inRange(x: number, y: number, scale?: number): any;
                                parseEventsOfWrapper(): any;
                                addListener(): void;
                                removeListener(): void;
                                handleLegendBBoxUpdate: (box: DOMRect) => void;
                                handleReceiveSyncEvent: (
                                cId: string | number,
                                data: import('./types').CategoricalChartState,
                                emitter: Symbol
                                ) => void;
                                handleBrushChange: ({
                                startIndex,
                                endIndex,
                                }: {
                                startIndex: number;
                                endIndex: number;
                                }) => void;
                                handleMouseEnter: (e: any) => void;
                                triggeredAfterMouseMove: (
                                e: import('./generateCategoricalChart').MousePointer
                                ) => any;
                                handleItemMouseEnter: (el: any) => void;
                                handleItemMouseLeave: () => void;
                                handleMouseMove: (
                                e: import('./generateCategoricalChart').MousePointer &
                                Partial<
                                Omit<
                                import('react').MouseEvent<Element, MouseEvent>,
                                keyof import('./generateCategoricalChart').MousePointer
                                >
                                >
                                ) => void;
                                handleMouseLeave: (e: any) => void;
                                handleOuterEvent: (
                                e:
                                | import('react').MouseEvent<Element, MouseEvent>
                                | import('react').TouchEvent<Element>
                                ) => void;
                                handleClick: (e: any) => void;
                                handleMouseDown: (
                                e:
                                | import('react').MouseEvent<Element, MouseEvent>
                                | import('react').Touch
                                ) => void;
                                handleMouseUp: (
                                e:
                                | import('react').MouseEvent<Element, MouseEvent>
                                | import('react').Touch
                                ) => void;
                                handleTouchMove: (e: any) => void;
                                handleTouchStart: (e: any) => void;
                                handleTouchEnd: (e: any) => void;
                                triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                                applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                                filterFormatItem(item: any, displayName: any, childIndex: any): any;
                                renderCursor: (element: any) => any;
                                renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                                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;
                                };
                                renderMap: {
                                CartesianGrid: { handler: (element: any) => any; once: boolean };
                                ReferenceArea: {
                                handler: (element: any, displayName: string, index: number) => any;
                                };
                                ReferenceLine: { handler: (element: any) => any };
                                ReferenceDot: {
                                handler: (element: any, displayName: string, index: number) => any;
                                };
                                XAxis: { handler: (element: any) => any };
                                YAxis: { handler: (element: any) => any };
                                Brush: { handler: (element: any) => any; once: boolean };
                                Bar: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Line: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Area: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Radar: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                RadialBar: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Scatter: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Pie: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Funnel: {
                                handler: (element: any, displayName: string, index: number) => any[];
                                };
                                Tooltip: { handler: (element: any) => any; once: boolean };
                                PolarGrid: { handler: (element: any) => any; once: boolean };
                                PolarAngleAxis: {
                                handler: (element: any, displayName: string, index: number) => any;
                                };
                                PolarRadiusAxis: {
                                handler: (element: any, displayName: string, index: number) => any;
                                };
                                Customized: {
                                handler: (element: any, displayName: string, index: number) => any;
                                };
                                };
                                render(): any;
                                context: any;
                                setState<K extends keyof CategoricalChartState>(
                                state:
                                | CategoricalChartState
                                | ((
                                prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                                refs: { [key: string]: any };
                                shouldComponentUpdate?(
                                nextProps: Readonly<
                                import('./generateCategoricalChart').CategoricalChartProps
                                >,
                                nextState: Readonly<import('./types').CategoricalChartState>,
                                nextContext: any
                                ): boolean;
                                componentDidCatch?(error: Error, errorInfo: any): void;
                                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('./types').CategoricalChartState>,
                                nextContext: any
                                ): void;
                                UNSAFE_componentWillUpdate?(
                                nextProps: Readonly<
                                import('./generateCategoricalChart').CategoricalChartProps
                                >,
                                nextState: Readonly<import('./types').CategoricalChartState>,
                                nextContext: any
                                ): void;
                                };
                                displayName: string;
                                defaultProps: import('./generateCategoricalChart').CategoricalChartProps;
                                getDerivedStateFromProps: (
                                nextProps: import('./generateCategoricalChart').CategoricalChartProps,
                                prevState: import('./types').CategoricalChartState
                                ) => import('./types').CategoricalChartState;
                                renderActiveDot: (option: any, props: any) => any;
                                contextType?: any;
                                };

                                  variable Rectangle

                                  const Rectangle: React.FC<Props>;

                                    variable ResponsiveContainer

                                    const ResponsiveContainer: React.ForwardRefExoticComponent<any>;

                                      variable ScatterChart

                                      const ScatterChart: {
                                      new (props: import('./generateCategoricalChart').CategoricalChartProps): {
                                      readonly eventEmitterSymbol: Symbol;
                                      clipPathId: string;
                                      accessibilityManager: import('./AccessibilityManager').AccessibilityManager;
                                      throttleTriggeredAfterMouseMove: any;
                                      container?: HTMLElement;
                                      componentDidMount(): void;
                                      displayDefaultTooltip(): void;
                                      getSnapshotBeforeUpdate(
                                      prevProps: Readonly<
                                      import('./generateCategoricalChart').CategoricalChartProps
                                      >,
                                      prevState: Readonly<import('./types').CategoricalChartState>
                                      ): null;
                                      componentDidUpdate(
                                      prevProps: import('./generateCategoricalChart').CategoricalChartProps
                                      ): void;
                                      componentWillUnmount(): void;
                                      getTooltipEventType(): import('../util/types').TooltipEventType;
                                      getMouseInfo(
                                      event: import('./generateCategoricalChart').MousePointer
                                      ):
                                      | { xValue: any; yValue: any; chartX: number; chartY: number }
                                      | {
                                      activeTooltipIndex: number;
                                      activeLabel: any;
                                      activePayload: any[];
                                      activeCoordinate: import('../util/types').ChartCoordinate;
                                      chartX: number;
                                      chartY: number;
                                      };
                                      inRange(x: number, y: number, scale?: number): any;
                                      parseEventsOfWrapper(): any;
                                      addListener(): void;
                                      removeListener(): void;
                                      handleLegendBBoxUpdate: (box: DOMRect) => void;
                                      handleReceiveSyncEvent: (
                                      cId: string | number,
                                      data: import('./types').CategoricalChartState,
                                      emitter: Symbol
                                      ) => void;
                                      handleBrushChange: ({
                                      startIndex,
                                      endIndex,
                                      }: {
                                      startIndex: number;
                                      endIndex: number;
                                      }) => void;
                                      handleMouseEnter: (e: any) => void;
                                      triggeredAfterMouseMove: (
                                      e: import('./generateCategoricalChart').MousePointer
                                      ) => any;
                                      handleItemMouseEnter: (el: any) => void;
                                      handleItemMouseLeave: () => void;
                                      handleMouseMove: (
                                      e: import('./generateCategoricalChart').MousePointer &
                                      Partial<
                                      Omit<
                                      import('react').MouseEvent<Element, MouseEvent>,
                                      keyof import('./generateCategoricalChart').MousePointer
                                      >
                                      >
                                      ) => void;
                                      handleMouseLeave: (e: any) => void;
                                      handleOuterEvent: (
                                      e:
                                      | import('react').MouseEvent<Element, MouseEvent>
                                      | import('react').TouchEvent<Element>
                                      ) => void;
                                      handleClick: (e: any) => void;
                                      handleMouseDown: (
                                      e:
                                      | import('react').MouseEvent<Element, MouseEvent>
                                      | import('react').Touch
                                      ) => void;
                                      handleMouseUp: (
                                      e:
                                      | import('react').MouseEvent<Element, MouseEvent>
                                      | import('react').Touch
                                      ) => void;
                                      handleTouchMove: (e: any) => void;
                                      handleTouchStart: (e: any) => void;
                                      handleTouchEnd: (e: any) => void;
                                      triggerSyncEvent: (data: import('./types').CategoricalChartState) => void;
                                      applySyncEvent: (data: import('./types').CategoricalChartState) => void;
                                      filterFormatItem(item: any, displayName: any, childIndex: any): any;
                                      renderCursor: (element: any) => any;
                                      renderPolarAxis: (element: any, displayName: string, index: number) => 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(): any;
                                      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;
                                      };
                                      renderMap: {
                                      CartesianGrid: { handler: (element: any) => any; once: boolean };
                                      ReferenceArea: {
                                      handler: (element: any, displayName: string, index: number) => any;
                                      };
                                      ReferenceLine: { handler: (element: any) => any };
                                      ReferenceDot: {
                                      handler: (element: any, displayName: string, index: number) => any;
                                      };
                                      XAxis: { handler: (element: any) => any };
                                      YAxis: { handler: (element: any) => any };
                                      Brush: { handler: (element: any) => any; once: boolean };
                                      Bar: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Line: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Area: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Radar: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      RadialBar: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Scatter: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Pie: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Funnel: {
                                      handler: (element: any, displayName: string, index: number) => any[];
                                      };
                                      Tooltip: { handler: (element: any) => any; once: boolean };
                                      PolarGrid: { handler: (element: any) => any; once: boolean };
                                      PolarAngleAxis: {
                                      handler: (element: any, displayName: string, index: number) => any;
                                      };
                                      PolarRadiusAxis: {
                                      handler: (element: any, displayName: string, index: number) => any;
                                      };
                                      Customized: {
                                      handler: (element: any, displayName: string, index: number) => any;
                                      };
                                      };
                                      render(): any;
                                      context: any;
                                      setState<K extends keyof CategoricalChartState>(
                                      state:
                                      | CategoricalChartState
                                      | ((
                                      prevState: Readonly<import('./types').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('./types').CategoricalChartState>;
                                      refs: { [key: string]: any };
                                      shouldComponentUpdate?(
                                      nextProps: Readonly<
                                      import('./generateCategoricalChart').CategoricalChartProps
                                      >,
                                      nextState: Readonly<import('./types').CategoricalChartState>,
                                      nextContext: any
                                      ): boolean;
                                      componentDidCatch?(error: Error, errorInfo: any): void;
                                      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('./types').CategoricalChartState>,
                                      nextContext: any
                                      ): void;
                                      UNSAFE_componentWillUpdate?(
                                      nextProps: Readonly<
                                      import('./generateCategoricalChart').CategoricalChartProps