recharts

const Area: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

const AreaChart: React.ForwardRefExoticComponent<any>;

const Bar: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

const BarChart: React.ForwardRefExoticComponent<any>;

const CartesianAxis: React.ForwardRefExoticComponent<any>;

const Cell: FunctionComponent<SVGProps<SVGElement>>;

const ComposedChart: React.ForwardRefExoticComponent<any>;

const Cross: React.FC<any>;

const Curve: React.FC<Props>;

const Dot: React.FC<any>;

const FunnelChart: React.ForwardRefExoticComponent<any>;

const getNiceTickValues: (
    [min, max]: [number, number],
    tickCount?: number,
    allowDecimals?: boolean
) => number[];

const Global: { devToolsEnabled: boolean; isSsr: boolean };

const Layer: React.ForwardRefExoticComponent<any>;

const Line: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

const LineChart: React.ForwardRefExoticComponent<any>;

const PieChart: React.ForwardRefExoticComponent<any>;

const PolarGrid: {
    ({
        gridType,
        radialLines,
        angleAxisId,
        radiusAxisId,
        cx: cxFromOutside,
        cy: cyFromOutside,
        innerRadius: innerRadiusFromOutside,
        outerRadius: outerRadiusFromOutside,
        ...inputs
    }: Props): React.JSX.Element;
    displayName: string;
};

const Polygon: React.FC<Props>;

const RadarChart: React.ForwardRefExoticComponent<any>;

const RadialBarChart: React.ForwardRefExoticComponent<any>;

const Rectangle: React.FC<Props>;

const ResponsiveContainer: React.ForwardRefExoticComponent<any>;

const Scatter: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

const ScatterChart: React.ForwardRefExoticComponent<any>;

const Sector: React.FC<Props>;

const Surface: React.ForwardRefExoticComponent<any>;

const Symbols: {
    ({ type, size, sizeType, ...rest }: SymbolsProps): React.JSX.Element;
    registerSymbol: (key: string, factory: D3SymbolType) => void;
};

const Text: React.ForwardRefExoticComponent<any>;

const Trapezoid: React.FC<any>;

const XAxis: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

const YAxis: React.MemoExoticComponent<(outsideProps: Props) => React.JSX.Element>;

Brush: typeof Brush;

CartesianGrid: typeof CartesianGrid;

Customized: typeof Customized;

DefaultTooltipContent: <TValue extends ValueType, TName extends NameType>(
    props: Props<TValue, TName>
) => React.JSX.Element;

Label: typeof Label;

LabelList: typeof LabelList;

Pie: typeof Pie;

SunburstChart: (props: SunburstChartProps) => React.JSX.Element;

Tooltip: <TValue extends ValueType, TName extends NameType>(
    outsideProps: TooltipProps<TValue, TName>
) => React.JSX.Element;

Treemap: (props: Props) => React.JSX.Element;

useActiveTooltipDataPoints: <T = unknown>() => readonly T[];

useActiveTooltipLabel: () => string | undefined;

useChartHeight: () => number | undefined;

useChartWidth: () => number | undefined;

useMargin: () => Margin | undefined;

useOffset: () => ChartOffset | undefined;

usePlotArea: () => PlotArea | undefined;

useXAxisDomain: (
    xAxisId?: AxisId
) => NumberDomain | CategoricalDomain | undefined;

useYAxisDomain: (
    yAxisId?: AxisId
) => NumberDomain | CategoricalDomain | undefined;

type Props = AreaSvgProps & AreaProps;

type Props = Partial<BarEvents> & BarProps & Omit<BarSvgProps, keyof BarEvents>;

type Props = Omit<SVGProps<SVGElement>, 'onChange' | 'onDragEnd' | 'ref'> &
    BrushProps;

type Props = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'viewBox' | 'scale' | 'ref'
> &
    CartesianAxisProps;

type Props = AcceptedSvgProps & CartesianGridProps;

type Props = SVGProps<SVGElement>;

type ChartOffset = {
    /**
     * Distance from the top edge of the chart to the top edge of the plot area.
     */
    readonly top: number;
    /**
     * Distance from the bottom edge of the chart to the bottom edge of the plot area.
     * Note that this is not a coordinate, this is a distance.
     * Meaning, `offset.bottom` could be 0 in a perfectly fine big chart.
     */
    readonly bottom: number;
    /**
     * Distance from the left edge of the chart to the left edge of the plot area.
     */
    readonly left: number;
    /**
     * Distance from the right edge of the chart to the right edge of the plot area.
     * Note that this is not a coordinate, this is a distance.
     * Meaning, `offset.right` could be 0 in a perfectly fine big chart.
     */
    readonly right: number;
};

type Props = SVGProps<SVGPathElement> & CrossProps;

type Props = Omit<
    PresentationAttributesWithProps<CurveProps, SVGPathElement>,
    'type' | 'points'
> &
    CurveProps;

type Props<P, C extends Comp<P>> = P & {
    component: C;
};

type Props = InternalProps &
    Omit<
        PresentationAttributesAdaptChildEvent<any, ReactElement>,
        keyof InternalProps
    >;

type Props = PresentationAttributesWithProps<DotProps, SVGCircleElement> & DotProps;

type Props = SVGProps<SVGLineElement> & ErrorBarProps;

type Props = FunnelSvgProps & FunnelProps;

type Props = SvgTextProps & LabelListProps;

type Props = Omit<SVGProps<SVGTextElement>, 'viewBox'> & LabelProps;

type Props = SVGAttributes<SVGGElement> & LayerProps;

type Props = Omit<DefaultProps, 'payload' | 'ref'> & {
    wrapperStyle?: CSSProperties;
    width?: number;
    height?: number;
    payloadUniqBy?: UniqueOption<LegendPayload>;
    onBBoxUpdate?: (box: ElementOffset | null) => void;
    /**
     * If portal is defined, then Legend will use this element as a target
     * for rendering using React Portal: https://react.dev/reference/react-dom/createPortal
     *
     * If this is undefined then Legend renders inside the recharts-wrapper element.
     */
    portal?: HTMLElement | null;
    itemSorter?: LegendItemSorter;
};

type LegendType =
    | 'circle'
    | 'cross'
    | 'diamond'
    | 'line'
    | 'plainline'
    | 'rect'
    | 'square'
    | 'star'
    | 'triangle'
    | 'wye'
    | 'none';

type Props = LineSvgProps & LineProps;

type MouseHandlerDataParam = {
    /**
     * Index of the active tick in the current chart. Only works with number-indexed one-dimensional data charts,
     * like Line, Area, Bar, Pie, etc.
     *
     * Doesn't work with two-dimensional data charts like Treemap, Sankey. But one day it will which is why the TooltipIndex type is here.
     */
    activeTooltipIndex: number | TooltipIndex | undefined;
    isTooltipActive: boolean;
    /**
     * Exactly the same as activeTooltipIndex - this was also duplicated in recharts@2 so let's keep both properties for better backwards compatibility.
     */
    activeIndex: number | TooltipIndex | undefined;
    activeLabel: string | undefined;
    activeDataKey: DataKey<any> | undefined;
    activeCoordinate: Coordinate | undefined;
};

type PieLabel =
    | boolean
    | LabelListPropsWithPosition
    | Partial<PieLabelRenderProps>
    | ((props: PieLabelRenderProps) => ReactNode | ReactElement<SVGElement>)
    | ReactElement<SVGElement>;

type PieLabelRenderProps = Omit<SVGPropsNoEvents<PieSvgAttributes>, 'offset'> &
    Omit<PieSectorDataItem, 'offset'> &
    PieLabelExtraProps &
    Coordinate;

type Props = PieSvgAttributes & PieProps;

type PlotArea = {
    /**
     * The width of the plot area.
     * This will be the same as `chartWidth - offset.left - offset.right`
     */
    readonly width: number;
    /**
     * The height of the plot area.
     * This will be the same as `chartHeight - offset.top - offset.bottom`
     */
    readonly height: number;
    /**
     * The x coordinate of the top-left corner of the plot area.
     * This will be the same as `offset.left`
     */
    readonly x: number;
    /**
     * The y coordinate of the top-left corner of the plot area.
     * This will be the same as `offset.top`
     */
    readonly y: number;
};

type Props = AxisSvgProps & PolarAngleAxisProps;

type Props = SVGProps<SVGLineElement> & PolarGridProps;

type Props = AxisSvgProps & PolarRadiusAxisProps;

type Props = Omit<SVGProps<SVGPolygonElement>, 'points'> & PolygonProps;

type Props = Omit<
    SVGProps<SVGElement>,
    'onMouseEnter' | 'onMouseLeave' | 'points' | 'ref'
> &
    RadarProps;

type RadialBarProps = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'ref'
> &
    InternalRadialBarProps;

type Props = Omit<SVGProps<SVGPathElement>, 'radius'> & RectangleProps;

type Props = RectangleProps & ReferenceAreaProps;

type Props = DotProps & ReferenceDotProps;

type Props = Omit<SVGProps<SVGLineElement>, 'viewBox'> & ReferenceLineProps;

type Props = BaseScatterSvgProps & ScatterProps;

type Props = Omit<
    SVGProps<SVGPathElement>,
    'cx' | 'cy' | 'dangerouslySetInnerHTML'
> &
    Partial<SectorProps>;

type Props = Omit<SVGProps<SVGSVGElement>, 'viewBox'> & SurfaceProps;

type SymbolsProps = SVGProps<SVGPathElement> & InnerSymbolsProp;

type Props = Omit<SVGProps<SVGTextElement>, 'textAnchor' | 'verticalAnchor'> &
    TextProps;

type TooltipContentProps<
    TValue extends ValueType,
    TName extends NameType
> = TooltipProps<TValue, TName> & {
    label?: string | number;
    payload: any[];
    coordinate: ChartCoordinate;
    active: boolean;
    accessibilityLayer: boolean;
};