@nivo/core

const BOX_ANCHORS: readonly BoxAnchor[];

const boxAlignments: readonly BoxAlign[];

const CartesianMarkers: CartesianMarkersType;

const ChartContext: React.Context<DefaultChartContext>;

const closedCurvePropKeys: readonly ClosedCurveFactoryId[];

const Container: ContainerType;

const defaultAnimate: boolean;

const defaultMargin: DefaultMargin;

const DotsItem: React.FunctionComponent<DotsItemProps<any>>;

const motionDefaultProps: MotionDefaultProps;

const ResponsiveWrapper: ResponsiveWrapperType;

const SvgWrapper: SvgWrapperType;

alignBox: (
    box: AlignBox,
    container: AlignBox,
    alignment: BoxAlign
) => [number, number];

clampArc: (
    startAngle: number,
    endAngle: number,
    length?: number
) => [number, number];

curveFromProp: (interpolation: CurveFactoryId) => CurveFactory;

Defs: (props: DefsProps) => JSX.Element;

degreesToRadians: (degrees: number) => number;

getAngle: (x1: number, y1: number, x2: number, y2: number) => number;

getDistance: (x1: number, y1: number, x2: number, y2: number) => number;

getPropertyAccessor: <Datum, Value>(
    accessor: PropertyAccessor<Datum, Value>
) => (datum: Datum) => Value;

getRelativeCursor: (
    element: Element,
    event: React.MouseEvent | React.TouchEvent
) => [number, number];

getValueFormatter: <Value, Context = void>(
    format?: ValueFormat<Value, Context>
) => Context extends void
    ? (value: Value) => string
    : (value: Value, context: Context) => string;

isCursorInRect: (
    x: number,
    y: number,
    width: number,
    height: number,
    cursorX: number,
    cursorY: number
) => boolean;

linearGradientDef: (
    id: string,
    colors: GradientColor[],
    options?: React.SVGProps<SVGLinearGradientElement>
) => {
    id: string;
    type: 'linearGradient';
    colors: GradientColor[];
} & React.SVGProps<SVGLinearGradientElement>;

mergeRefs: <T>(...refs: any[]) => (value: T) => void;

midAngle: (arc: { startAngle: number; endAngle: number }) => number;

normalizeAngleDegrees: (degrees: number) => number;

PatternDots: (props: Omit<PatternDotsDef, 'type'>) => JSX.Element;

patternDotsDef: (
    id: string,
    options?: Omit<PatternDotsDef, 'id' | 'type'>
) => PatternDotsDef;

PatternLines: (props: Omit<PatternLinesDef, 'type'>) => JSX.Element;

patternLinesDef: (
    id: string,
    options?: Omit<PatternLinesDef, 'id' | 'type'>
) => PatternLinesDef;

PatternSquares: (props: Omit<PatternSquaresDef, 'type'>) => JSX.Element;

patternSquaresDef: (
    id: string,
    options?: Omit<PatternSquaresDef, 'id' | 'type'>
) => PatternSquaresDef;

positionFromAngle: (angle: number, distance: number) => { x: number; y: number };

radiansToDegrees: (radians: number) => number;

useAnimatedPath: (path: string) => Interpolation<string>;

useCurveInterpolation: (interpolation: CurveFactoryId) => CurveFactory;

useDimensions: (
    width: number,
    height: number,
    margin?: Box
) => {
    margin: Margin;
    innerWidth: number;
    innerHeight: number;
    outerWidth: number;
    outerHeight: number;
};

useMeasure: () => [
    React.RefObject<HTMLDivElement>,
    { left: number; top: number; width: number; height: number }
];

useMotionConfig: () => { animate: boolean; config: SpringConfig };

usePropertyAccessor: <Datum, Value>(
    accessor: PropertyAccessor<Datum, Value>
) => (datum: Datum) => Value;

useValueFormatter: <Value, Context = void>(
    format?: ValueFormat<Value, Context>
) => Context extends void
    ? (value: Value) => string
    : (value: Value, context: Context) => string;

type Accessor<T extends keyof U, U> = T extends string ? U[T] : never;

type AreaCurve =
    | 'basis'
    | 'cardinal'
    | 'catmullRom'
    | 'linear'
    | 'monotoneX'
    | 'monotoneY'
    | 'natural'
    | 'step'
    | 'stepAfter'
    | 'stepBefore';

type AreaCurveFactoryId =
    | 'basis'
    | 'cardinal'
    | 'catmullRom'
    | 'linear'
    | 'monotoneX'
    | 'monotoneY'
    | 'natural'
    | 'step'
    | 'stepAfter'
    | 'stepBefore';

type Box = Partial<Margin>;

type BoxAlign =
    | 'center'
    | 'top-left'
    | 'top'
    | 'top-right'
    | 'right'
    | 'bottom-right'
    | 'bottom'
    | 'bottom-left'
    | 'left';

type BoxAnchor =
    | 'center'
    | 'top-left'
    | 'top'
    | 'top-right'
    | 'right'
    | 'bottom-right'
    | 'bottom'
    | 'bottom-left'
    | 'left';

type CartesianMarkersType = <
    X extends DatumValue = DatumValue,
    Y extends DatumValue = DatumValue
>(
    props: CartesianMarkersProps<X, Y>
) => JSX.Element;

type ClosedCurveFactoryId =
    | 'basisClosed'
    | 'cardinalClosed'
    | 'catmullRomClosed'
    | 'linearClosed';

type Colors = readonly string[] | string;

type ContainerType = (props: React.PropsWithChildren<ContainerProps>) => JSX.Element;

type CssMixBlendMode =
    | 'normal'
    | 'multiply'
    | 'screen'
    | 'overlay'
    | 'darken'
    | 'lighten'
    | 'color-dodge'
    | 'color-burn'
    | 'hard-light'
    | 'soft-light'
    | 'difference'
    | 'exclusion'
    | 'hue'
    | 'saturation'
    | 'color'
    | 'luminosity';

type CurveFactoryId =
    | 'basis'
    | 'basisClosed'
    | 'basisOpen'
    | 'bundle'
    | 'cardinal'
    | 'cardinalClosed'
    | 'cardinalOpen'
    | 'catmullRom'
    | 'catmullRomClosed'
    | 'catmullRomOpen'
    | 'linear'
    | 'linearClosed'
    | 'monotoneX'
    | 'monotoneY'
    | 'natural'
    | 'step'
    | 'stepAfter'
    | 'stepBefore';

type DatumPropertyAccessor<RawDatum, T> = (datum: RawDatum) => T;

type DatumValue = string | number | Date;

type Def = LinearGradientDef | PatternDotsDef | PatternSquaresDef | PatternLinesDef;

type DefaultChartContext = Record<string, unknown>;

type DefaultMargin = {
    top: 0;
    right: 0;
    bottom: 0;
    left: 0;
};

type DefsProps = {
    defs: readonly Def[];
};

type DotsItemSymbolComponent<D = any> = React.FunctionComponent<
    DotsItemSymbolProps<D>
>;

type EventMap = {
    onMouseEnter: MouseEvent;
    onMouseMove: MouseEvent;
    onMouseLeave: MouseEvent;
    onClick: MouseEvent;
    onDoubleClick: MouseEvent;
    onFocus: FocusEvent;
    onBlur: FocusEvent;
    onKeyDown: KeyboardEvent;
    onWheel: WheelEvent;
    onContextMenu: MouseEvent;
};

type ExtractProps<TComponent> = TComponent extends ComponentType<infer TProps>
    ? TProps
    : never;

type GetColor<T> = (datum: T) => string;

type GradientColor = {
    offset: number;
    color: string;
    opacity?: number;
};

type HtmlElementTag = {
    [K in keyof JSX.IntrinsicElements]: JSX.IntrinsicElements[K] extends React.HTMLAttributes<HTMLElement>
        ? K
        : never;
}[keyof JSX.IntrinsicElements];

type InteractionHandlers<Node, EM extends Record<string, SyntheticEvent>> = {
    [K in keyof EM]?: NodeEventHandler<Node, EM[K]>;
};

type LinearGradientDef = {
    id: string;
    type: 'linearGradient';
    colors: {
        offset: number;
        color: string;
        opacity?: number;
    }[];
    gradientTransform?: string;
};

type LineCurveFactoryId =
    | 'basis'
    | 'cardinal'
    | 'catmullRom'
    | 'linear'
    | 'monotoneX'
    | 'monotoneY'
    | 'natural'
    | 'step'
    | 'stepAfter'
    | 'stepBefore';

type Margin = {
    bottom: number;
    left: number;
    right: number;
    top: number;
};

type MotionDefaultProps = {
    animate: true;
    config: 'default';
};

type MotionProps = Partial<{
    animate: boolean;
    motionConfig: string | SpringConfig;
}>;

type NodeEventHandler<NodeType, E extends SyntheticEvent> = (
    node: NodeType,
    event: E
) => void;

type Padding = Margin;

type PatternDotsDef = {
    id: string;
    type: 'patternDots';
    color?: string;
    background?: string;
    size?: number;
    padding?: number;
    stagger?: boolean;
};

type PatternLinesDef = {
    id: string;
    type: 'patternLines';
    spacing?: number;
    rotation?: number;
    background?: string;
    color?: string;
    lineWidth?: number;
};

type PatternSquaresDef = Omit<PatternDotsDef, 'type'> & {
    type: 'patternSquares';
};

type PropertyAccessor<Datum, Value> =
    // path to use with `lodash.get()`
    | string
    // explicit accessor function
    | ((datum: Datum) => Value);

type ResponsiveProps<Props> = Omit<Props, 'width' | 'height'> & {
    defaultWidth?: number;
    defaultHeight?: number;
    onResize?: (dimensions: { width: number; height: number }) => void;
    debounceResize?: number;
};

type ResponsiveWrapperType = (props: {
    children: (dimensions: { width: number; height: number }) => JSX.Element;
    defaultWidth?: number;
    defaultHeight?: number;
    onResize?: (dimensions: { width: number; height: number }) => void;
    debounceResize?: number;
}) => JSX.Element;

type StackOffset = 'expand' | 'diverging' | 'none' | 'silhouette' | 'wiggle';

type StackOrder = 'ascending' | 'descending' | 'insideOut' | 'none' | 'reverse';

type SvgElementTag = Exclude<
    {
        [K in keyof JSX.IntrinsicElements]: JSX.IntrinsicElements[K] extends React.SVGProps<SVGElement>
            ? K
            : never;
    }[keyof JSX.IntrinsicElements],
    'svg'
>;

type SvgFillMatcher<T> = (datum: T) => boolean;

type SvgWrapperType = (
    props: React.PropsWithChildren<{
        width: number;
        height: number;
        margin: Margin;
        defs?: any;
        role?: string;
        ariaLabel?: React.AriaAttributes['aria-label'];
        ariaLabelledBy?: React.AriaAttributes['aria-labelledby'];
        ariaDescribedBy?: React.AriaAttributes['aria-describedby'];
        isFocusable?: boolean;
        ref?: React.Ref<SVGSVGElement>;
    }>
) => JSX.Element;

type ValueFormat<Value, Context = void> =
    | string // d3 formatter
    // explicit formatting function
    | (Context extends void
          ? (value: Value) => string
          : (value: Value, context: Context) => string);

type WithChartRef<
    Props,
    T extends SVGSVGElement | HTMLCanvasElement | HTMLDivElement
> = Props & { ref?: Ref<T> };