@neo4j-ndl/react 2.16.26 → 3.0.0-alpha-4904fb7

package/lib/types/banner/Banner.d.ts

@@ -19,7 +19,7 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import React from 'react';
-import { type ElementBase } from '../helpers';
+import { type HtmlAttributes, type PolymorphicComponentPropsWithRef } from '../_common/types';
 /**
  *
  *
@@ -27,19 +27,22 @@ import { type ElementBase } from '../helpers';
  *
  *
  */
-export interface BannerActionsProps extends React.HTMLProps<HTMLAnchorElement> {
+export type BannerActionsProps = {
     /** Label of the action item */
     label: string;
+    children?: React.ReactNode;
+} & ({
+    as: 'button';
     /** Event handler when the action button is clicked. If set, the element is rendered as `button` */
     onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
-    /** Link to redirect to when the action button is clicked. If set, the element is rendered as `a`. Ignored if `onClose` prop is passed */
+} | {
+    as?: 'a';
     href?: string;
-    /** Sets how to open the link. Only applicable when `href` is passed */
-    target?: '_blank' | '_self' | '_parent' | '_top';
-}
-export interface BannerCommonProps extends Omit<ElementBase, 'title'> {
-    /** Type of the banner   */
-    type?: BannerType;
+} | {
+    as: React.ElementType;
+});
+type BannerActionsComponent = <T extends React.ElementType = 'a'>(props: PolymorphicComponentPropsWithRef<T, BannerActionsProps>) => React.ReactNode | null;
+export interface BannerCommonProps {
     /** Title of the banner */
     title?: string | React.ReactNode;
     /**
@@ -49,30 +52,47 @@ export interface BannerCommonProps extends Omit<ElementBase, 'title'> {
     name?: string;
     /** Description of the banner. Will be ignored if `children` is passed */
     description?: string | React.ReactNode;
-    /** Alternative for `description` */
-    children?: React.ReactNode;
     /** Shows status icon. Icon is automatically picked based on `type` value   */
-    icon?: boolean;
+    hasIcon?: boolean;
     /** Shows Action buttons in the footer */
     actions?: BannerActionsProps[];
-    /** Adds shadow */
-    floating?: boolean;
+    htmlAttributes?: HtmlAttributes<'div'>;
+    children?: React.ReactNode;
+    className?: string;
 }
+type BannerInlineProps = {
+    /** How the banner is used */
+    usage?: 'inline';
+    /** Type of the banner */
+    type?: BannerType;
+};
+type BannerGlobalProps = {
+    /** How the banner is used */
+    usage: 'global';
+    /** Type of the banner */
+    type?: BannerType;
+};
+type BannerFullWidthProps = {
+    /** How the banner is used */
+    usage: 'full-width';
+    /** Type of the banner */
+    type?: Exclude<BannerType, 'success'>;
+};
+type BannerUsageProps = BannerInlineProps | BannerGlobalProps | BannerFullWidthProps;
 type CloseableBannerProps = {
     /** Shows close icon. Expects onClose to be passed */
-    closeable: true;
+    isCloseable: true;
     /** Event handler when close icon is clicked */
     onClose: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
 };
 type NonCloseableBannerProps = {
-    closeable?: false;
+    isCloseable?: false;
     onClose?: never;
 };
 type BannerCloseProps = CloseableBannerProps | NonCloseableBannerProps;
-export type BannerProps = BannerCommonProps & BannerCloseProps;
+export type BannerProps = BannerCommonProps & BannerCloseProps & BannerUsageProps;
 export type BannerType = 'info' | 'success' | 'warning' | 'danger' | 'neutral';
-export type BannerNonIconType = Exclude<BannerType, 'neutral'>;
 declare const BannerNamespace: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<HTMLDivElement>> & {
-    Actions: ({ label, ...restProps }: BannerActionsProps) => import("react/jsx-runtime").JSX.Element;
+    Actions: BannerActionsComponent;
 };
 export { BannerNamespace as Banner };

package/lib/types/breadcrumbs/Breadcrumbs.d.ts

@@ -20,16 +20,16 @@
  */
 import React from 'react';
 import { type ContextMenuProps } from '../context-menu';
+import { type PolymorphicComponentProps, type PolymorphicComponentPropsWithRef, type HtmlAttributes } from '../_common/types';
 export interface BreadcrumbsBaseItemProps extends Omit<React.HTMLProps<HTMLLIElement>, 'as' | 'onClick'> {
-    as?: string | React.ComponentType<any>;
     children?: React.ReactNode;
     className?: string;
     href: string;
     isCurrentPage?: boolean;
     onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, href: string) => void;
 }
+type BreadcrumbsBaseItemComponent = <T extends React.ElementType = 'div'>(props: PolymorphicComponentPropsWithRef<T, BreadcrumbsBaseItemProps>) => React.ReactNode | null;
 export interface BreadcrumbsGroupItemProps extends Omit<React.HTMLProps<HTMLLIElement>, 'as'> {
-    as?: string | React.ComponentType<any>;
     children?: React.ReactNode;
     className?: string;
 }
@@ -42,19 +42,23 @@ export interface BreadcrumbsItemProps extends Omit<React.HTMLProps<HTMLLIElement
     isCurrentPage?: boolean;
     onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, href: string) => void;
 }
-export interface BreadcrumbsItemMenuProps extends Omit<ContextMenuProps, 'open'> {
+export interface BreadcrumbsItemMenuProps extends Omit<ContextMenuProps, 'isOpen' | 'onClick' | 'onClose'> {
     children: React.ReactNode;
     className?: string;
     isOpen?: boolean;
     onClick?: (event: React.MouseEvent<HTMLElement> | undefined) => void;
-    onClose?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    onClose?: (event?: Event) => void;
+    /** HTML attributes */
+    htmlAttributes?: HtmlAttributes<'button'>;
 }
-export interface BreadcrumbsEllipsisMenuProps extends Omit<ContextMenuProps, 'open'> {
+export interface BreadcrumbsEllipsisMenuProps extends Omit<ContextMenuProps, 'isOpen' | 'onClose'> {
     isOpen?: boolean;
-    onClose?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    onClose?: (event?: Event) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
 }
+type BreadcrumbsEllipsisMenuComponent = <T extends React.ElementType = 'span'>(props: PolymorphicComponentPropsWithRef<T, BreadcrumbsEllipsisMenuProps>) => React.ReactNode | null;
 export interface BreadcrumbsMenuItemProps extends Omit<React.HTMLProps<HTMLLIElement>, 'as' | 'onClick'> {
-    as?: string | React.ComponentType<any>;
     children: React.ReactNode;
     className?: string;
     href?: string;
@@ -62,36 +66,29 @@ export interface BreadcrumbsMenuItemProps extends Omit<React.HTMLProps<HTMLLIEle
     onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>, href?: string) => void;
 }
 export interface BreadcrumbsProps {
-    as?: string | React.ComponentType<any>;
     children?: React.ReactNode;
     className?: string;
 }
 declare const Breadcrumbs: {
-    ({ as, children, className, ...restProps }: BreadcrumbsProps): import("react/jsx-runtime").JSX.Element;
+    <T extends React.ElementType = "nav">({ as, children, className, htmlAttributes, }: PolymorphicComponentProps<T, BreadcrumbsMenuItemProps>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 } & {
-    BaseItem: {
-        ({ as, children, className, href, isCurrentPage, onClick, ...restProps }: BreadcrumbsBaseItemProps): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
+    BaseItem: BreadcrumbsBaseItemComponent;
     GroupItem: {
-        ({ as, children, className, ...restProps }: BreadcrumbsGroupItemProps): import("react/jsx-runtime").JSX.Element;
+        <T extends React.ElementType = "li">({ as, children, className, htmlAttributes, }: PolymorphicComponentProps<T, BreadcrumbsGroupItemProps>): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
     Item: {
-        ({ as, children, className, hasSeparator, href, isCurrentPage, onClick, ...restProps }: BreadcrumbsItemProps): import("react/jsx-runtime").JSX.Element;
+        <T extends React.ElementType = "a">({ as, children, className, hasSeparator, href, isCurrentPage, onClick, htmlAttributes, }: PolymorphicComponentProps<T, BreadcrumbsItemProps>): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
     ItemMenu: {
-        ({ children, className, isOpen, onClick, onClose, ...restProps }: BreadcrumbsItemMenuProps): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
-    EllipsisMenu: {
-        ({ as, children, className, isOpen, onClick, onClose, onKeyDown, ...restProps }: BreadcrumbsEllipsisMenuProps): import("react/jsx-runtime").JSX.Element;
+        ({ children, className, isOpen, onClick, onClose, htmlAttributes, }: BreadcrumbsItemMenuProps): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
+    EllipsisMenu: BreadcrumbsEllipsisMenuComponent;
     MenuItem: {
-        ({ as, children, className, href, isCurrentPage, onClick, ...restProps }: BreadcrumbsMenuItemProps): import("react/jsx-runtime").JSX.Element;
+        <T extends React.ElementType = "span">({ as, children, className, href, isCurrentPage, onClick, htmlAttributes, }: PolymorphicComponentProps<T, BreadcrumbsMenuItemProps>): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
 };

package/lib/types/button/Button.d.ts

@@ -18,9 +18,8 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import { type Neo4jColors } from '@neo4j-ndl/base';
 import React from 'react';
-import { type ElementBase } from '../helpers';
+import { type PolymorphicComponentPropsWithRef, type HtmlAttributes } from '../_common/types';
 /**
  *
  *
@@ -29,21 +28,44 @@ import { type ElementBase } from '../helpers';
  *
  */
 type ButtonTypes = 'submit' | 'button' | 'reset';
-export interface ButtonProps extends ElementBase<HTMLButtonElement> {
+export type ButtonSizes = 'small' | 'medium' | 'large';
+type BaseButtonProps = {
     children: string | React.ReactNode;
     /** If the button is doing something Async, it will display a loading spinner   */
-    loading?: boolean;
+    isLoading?: boolean;
     /** If the button is in disabled state */
-    disabled?: boolean;
-    /**  the base color of the button */
-    color?: Exclude<Neo4jColors, 'blueberry' | 'mint'>;
+    isDisabled?: boolean;
+    /** Type of button */
     type?: ButtonTypes;
-    /** Fill type of button */
-    fill?: 'filled' | 'outlined' | 'text';
     /** Size of button */
-    size?: 'small' | 'medium' | 'large';
+    size?: ButtonSizes;
     /** If the button is in floating state */
-    floating?: boolean;
-}
-export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<unknown>>;
+    isFloating?: boolean;
+    /** onClick callback*/
+    onClick?: (e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    /** OnKeyDown callback */
+    onKeyDown?: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    className?: string;
+} & ({
+    as: 'a';
+    href: HtmlAttributes<'a'>['href'];
+    target?: HtmlAttributes<'a'>['target'];
+} | {
+    as?: React.ElementType;
+});
+type OutlinedButtonProps = BaseButtonProps & {
+    fill: 'outlined';
+    color?: 'primary' | 'danger' | 'neutral';
+};
+type TextButtonProps = BaseButtonProps & {
+    fill: 'text';
+    color?: 'primary' | 'danger';
+};
+type FilledButtonProps = BaseButtonProps & {
+    fill?: 'filled';
+    color?: 'primary' | 'danger';
+};
+export type ButtonProps = OutlinedButtonProps | TextButtonProps | FilledButtonProps;
+type ButtonComponent = <C extends React.ElementType = 'button'>(props: PolymorphicComponentPropsWithRef<C, ButtonProps>) => React.ReactNode | null;
+export declare const Button: ButtonComponent;
 export {};

package/lib/types/button/IconButton.d.ts

@@ -19,7 +19,8 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import React from 'react';
-import { type ElementBase } from '../helpers';
+import { type ButtonSizes } from '../button';
+import { type PolymorphicComponentPropsWithRef } from '../_common/types';
 /**
  *
  *
@@ -27,23 +28,41 @@ import { type ElementBase } from '../helpers';
  *
  *
  */
-export interface IconButtonProps extends ElementBase<HTMLButtonElement> {
-    children: string | React.ReactNode;
+export interface IconButtonProps {
+    children: React.ReactNode;
     /** If the icon button is in disabled state */
-    disabled?: boolean;
+    isDisabled?: boolean;
     /** If the button is doing something Async, it will display a loading spinner   */
-    loading?: boolean;
+    isLoading?: boolean;
     /** If the button does not have a visible container */
-    clean?: boolean;
+    isClean?: boolean;
     /** Size of button */
-    size?: 'small' | 'medium' | 'large';
+    size?: ButtonSizes;
     /** If the button is in floating state */
-    floating?: boolean;
+    isFloating?: boolean;
     /** Turn the button red button */
-    danger?: boolean;
+    isDanger?: boolean;
     /** If the button is in a group, the icon's container is more compact */
-    grouped?: boolean;
+    isGrouped?: boolean;
     /** Active - used for open context menus for example */
-    active?: boolean;
+    isActive?: boolean;
+    /** aria-label - {@link https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label} */
+    ariaLabel: string;
+    /** classNames */
+    className?: string;
+    onClick?: (e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
 }
-export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<unknown>>;
+interface IconButtonAsButtonProps {
+    as?: 'button';
+    type?: 'button' | 'submit' | 'reset';
+}
+interface IconButtonAsAnchorProps {
+    as: 'a';
+    href: string;
+}
+type IconButtonComponent = <C extends React.ElementType = 'button'>(props: PolymorphicComponentPropsWithRef<C, IconButtonProps & (IconButtonAsButtonProps | IconButtonAsAnchorProps | {
+    as: React.ElementType;
+})>) => React.ReactNode | null;
+export declare const IconButton: IconButtonComponent;
+export {};

package/lib/types/button/IconButtonArray.d.ts

@@ -19,23 +19,28 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import React from 'react';
-import { type ElementBase } from '../helpers';
+import { type IconButtonProps } from './IconButton';
 /**
- *
- *
  * Types
- *
- *
  */
-export interface IconButtonArrayProps extends ElementBase<HTMLDivElement> {
-    children: string | React.ReactNode;
-    /** Orientation of the group */
+export interface IconButtonArrayProps {
+    children: React.ReactNode;
     orientation?: 'vertical' | 'horizontal';
-    /** If the button is in floating state */
-    floating?: boolean;
+    isFloating?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    className?: string;
 }
-/**
- * TODO: v3. Incorporate the `size` prop into the component, and pass it to IconButton children.
- * We need to use also the `size` prop to adjust padding in various sizes, now it has a fixed padding.
- */
-export declare const IconButtonArray: React.ForwardRefExoticComponent<IconButtonArrayProps & React.RefAttributes<unknown>>;
+export interface CollapsibleButtonWrapperProps {
+    children: React.ReactElement<IconButtonProps> | React.ReactElement<IconButtonProps>[];
+}
+export declare const IconButtonArrayComponent: React.ForwardRefExoticComponent<{
+    htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+    as?: React.ElementType<any> | undefined;
+} & IconButtonArrayProps & React.RefAttributes<unknown>>;
+declare const IconButtonArray: React.ForwardRefExoticComponent<{
+    htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+    as?: React.ElementType<any> | undefined;
+} & IconButtonArrayProps & React.RefAttributes<unknown>> & {
+    CollapsibleButtonWrapper: React.FC<CollapsibleButtonWrapperProps>;
+};
+export { IconButtonArray };

package/lib/types/callout/Callout.d.ts

@@ -19,7 +19,6 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import React from 'react';
-import { type ElementBase } from '../helpers';
 /**
  *
  *
@@ -27,7 +26,7 @@ import { type ElementBase } from '../helpers';
  *
  *
  */
-export interface CalloutProps extends ElementBase<HTMLDivElement> {
+export interface CalloutProps {
     /** Type of the callout */
     type?: CalloutType;
     /** Header of the callout */
@@ -36,6 +35,7 @@ export interface CalloutProps extends ElementBase<HTMLDivElement> {
     children?: React.ReactNode;
     /** Description of the callout. Will be ignored if `children` is passed */
     description?: string | React.ReactNode;
+    className?: string;
 }
 export type CalloutType = 'note' | 'important' | 'example' | 'tip';
 /**
@@ -45,4 +45,7 @@ export type CalloutType = 'note' | 'important' | 'example' | 'tip';
  *
  *
  */
-export declare const Callout: React.ForwardRefExoticComponent<CalloutProps & React.RefAttributes<unknown>>;
+export declare const Callout: React.ForwardRefExoticComponent<{
+    htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+    as?: React.ElementType<any> | undefined;
+} & CalloutProps & React.RefAttributes<unknown>>;

package/lib/types/charts/Axis.d.ts

@@ -0,0 +1,37 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+export type XAxisProps = {
+    position: 'top' | 'bottom';
+    labelFormat?: (dataPoint: unknown) => string;
+    ticks?: number;
+    title?: string;
+    scale: string;
+};
+export type YAxisProps = {
+    position: 'left' | 'right';
+    labelFormat?: (dataPoint: unknown) => string;
+    ticks?: number;
+    title?: string;
+    scale: string;
+};
+export declare const XAxis: import("react").ForwardRefExoticComponent<XAxisProps & import("react").RefAttributes<unknown>>;
+export declare const YAxis: import("react").ForwardRefExoticComponent<YAxisProps & import("react").RefAttributes<unknown>>;

package/lib/types/{tip/Tooltip.d.ts → charts/CartesianGrid.d.ts}

@@ -18,12 +18,13 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 import React from 'react';
-type ArrowPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right';
-export interface TooltipProps extends React.HTMLProps<HTMLDivElement> {
-    arrowPosition: ArrowPosition;
-    children: React.ReactNode | string;
+type CartesianGridProps = {
+    scaleXAxis?: string;
+    scaleYAxis?: string;
     className?: string;
-}
-export declare const Tooltip: React.ForwardRefExoticComponent<Omit<TooltipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    htmlAttributes?: React.HTMLAttributes<HTMLDivElement>;
+};
+export declare const CartesianGrid: ({ className, htmlAttributes, scaleXAxis: scaleXAxisId, scaleYAxis: scaleYAxisId, }: CartesianGridProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/lib/types/charts/Chart.d.ts

@@ -0,0 +1,105 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import React, { type ReactNode } from 'react';
+import * as d3 from 'd3';
+import { type LineProps } from './Line';
+export type ScaleTypes = 'linear' | 'log' | 'time' | 'utc';
+export type ScaleFunctionDates = d3.ScaleTime<number, number, never>;
+export type ScaleFunctionNumbers = d3.ScaleLinear<number, number, never> | d3.ScaleLogarithmic<number, number, never>;
+export type ScaleFunction = ScaleFunctionDates | ScaleFunctionNumbers;
+export type Grid = 'clean' | 'x-axis' | 'y-axis' | 'both' | 'x-axis-zebra' | 'y-axis-zebra' | 'both-zebra' | 'x-axis-filled' | 'y-axis-filled' | 'both-filled';
+export type LinePoint = {
+    dataId: string;
+    pointIndex: number;
+    accessorXAxis: string;
+    accessorYAxis: string;
+    pointPixelX?: number;
+    pointPixelY?: number;
+    scaleYAxisId: string;
+    scaleXAxisId: string;
+    [linePointAttribute: string]: unknown;
+};
+export type DataPointArray = unknown[];
+export type LinePointArray = LinePoint[];
+export type LinePointArrayMetadataHolder = {
+    [LinePointArrayMetadataDataId: string]: LinePointArrayMetadata;
+};
+export type LinePointArrayMetadata = {
+    x?: ScaleFunction;
+    y?: ScaleFunction;
+    xRange?: number[];
+    yRange?: number[];
+    points?: (string | number)[][];
+    [linePointArrayMetadataAttribute: string]: unknown;
+};
+export type ScaleProps = {
+    [scaleKey: string]: {
+        type: ScaleTypes;
+        domain?: [number, number] | [Date, Date];
+    };
+};
+export interface Scales {
+    [scale: string]: {
+        function: ScaleFunctionDates;
+        functionWithContentWidthAsRange: ScaleFunctionDates;
+        functionWithContentHeightAsRange: ScaleFunctionDates;
+        originalDomain: [Date, Date] | null;
+    } | {
+        function: ScaleFunctionNumbers;
+        functionWithContentWidthAsRange: ScaleFunctionNumbers;
+        functionWithContentHeightAsRange: ScaleFunctionNumbers;
+        originalDomain: [number, number] | null;
+    };
+}
+export interface ChartsChartContext {
+    chartRef: React.Ref<HTMLElement>;
+    contentRef: React.Ref<SVGElement>;
+    contentSize: ContentSize;
+    scales: Scales;
+    linePointArray: LinePointArray;
+    mousePositionRef?: React.MutableRefObject<{
+        x: number;
+        y: number;
+    }>;
+}
+export type ContentSize = {
+    width: number | undefined;
+    height: number | undefined;
+} | undefined;
+export interface ChartProps {
+    children?: ReactNode;
+    className?: string;
+    scales: ScaleProps;
+    gridType?: Grid;
+    pointSelectionType?: 'single' | 'x-axis';
+}
+export type Points = {
+    data?: LinePoint;
+    x?: number;
+    y?: number;
+}[];
+export declare const canvasLeftPadding = 8;
+export declare const canvasRightPadding = 8;
+export declare const ChartsChartContext: React.Context<ChartsChartContext>;
+declare const Chart: React.ForwardRefExoticComponent<ChartProps & React.RefAttributes<unknown>> & {
+    Line: React.MemoExoticComponent<React.ForwardRefExoticComponent<LineProps & React.RefAttributes<SVGPathElement>>>;
+};
+export { Chart };

package/lib/types/charts/ChartTooltip.d.ts

@@ -0,0 +1,59 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import React from 'react';
+export interface ChartTooltipProps {
+    children: React.ReactNode;
+    className?: string;
+    anchorRef: React.RefObject<HTMLElement>;
+    isOpen?: boolean;
+    style: React.CSSProperties;
+}
+export declare const ChartTooltipComponent: React.ForwardRefExoticComponent<{
+    htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+    as?: React.ElementType<any> | undefined;
+} & ChartTooltipProps & React.RefAttributes<unknown>>;
+export type ChartTooltipContentProps = {
+    leftElement?: React.ReactNode;
+    rightElement?: React.ReactNode;
+    indentSquareColor?: string;
+    notification?: {
+        leftElement: React.ReactNode;
+        rightElement: React.ReactNode;
+        type: 'warning' | 'danger';
+    };
+};
+declare const ChartTooltip: React.ForwardRefExoticComponent<{
+    htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+    as?: React.ElementType<any> | undefined;
+} & ChartTooltipProps & React.RefAttributes<unknown>> & {
+    Title: React.ForwardRefExoticComponent<{
+        children: React.ReactNode;
+    } & React.RefAttributes<unknown>>;
+    Content: React.ForwardRefExoticComponent<ChartTooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+    Link: React.ForwardRefExoticComponent<Omit<{
+        htmlAttributes?: import("../_common/types").HtmlAttributes<React.ElementType<any>> | undefined;
+        as?: React.ElementType<any> | undefined;
+    } & import("../text-link").TextLinkProps & {
+        ref?: any;
+    }, "ref"> & React.RefAttributes<unknown>>;
+};
+export { ChartTooltip };