flikkui 0.1.0-beta.2

package/dist/components/charts/hooks/useChartAccessibility.d.ts

@@ -0,0 +1,39 @@
+import { ChartDataPoint, ChartConfig } from '../types/chart.types';
+export interface UseChartAccessibilityOptions {
+    /** Chart type for ARIA descriptions */
+    chartType: 'bar' | 'line' | 'area' | 'heatmap';
+    /** Chart data for generating descriptions */
+    data: ChartDataPoint[];
+    /** Chart configuration */
+    config: ChartConfig;
+    /** Custom chart title */
+    title?: string;
+    /** Custom chart description */
+    description?: string;
+    /** Whether keyboard navigation is enabled */
+    enableKeyboardNavigation?: boolean;
+}
+export interface ChartAccessibilityProps {
+    /** ARIA role for the chart container */
+    role: string;
+    /** ARIA label for the chart */
+    'aria-label': string;
+    /** ARIA description ID */
+    'aria-describedby'?: string;
+    /** Tab index for keyboard navigation */
+    tabIndex: number;
+    /** Keyboard event handlers */
+    onKeyDown: (event: React.KeyboardEvent) => void;
+}
+export declare function useChartAccessibility({ chartType, data, config, title, description, enableKeyboardNavigation, }: UseChartAccessibilityOptions): {
+    chartAccessibilityProps: ChartAccessibilityProps;
+    descriptionProps: {
+        id: string;
+        className: string;
+        children: string;
+    } | null;
+    focusedElementIndex: number;
+    isKeyboardMode: boolean;
+    handleMouseInteraction: () => void;
+    generateChartSummary: () => string;
+};

package/dist/components/charts/hooks/useChartTheme.d.ts

@@ -0,0 +1,16 @@
+import { ChartConfig, ChartThemeConfig, ChartVariant, ChartThemeOverrides } from '../types/chart.types';
+interface UseChartThemeProps {
+    config: ChartConfig;
+    variant?: ChartVariant;
+    theme?: ChartThemeOverrides;
+}
+export declare function useChartTheme({ config, variant, theme }: UseChartThemeProps): {
+    getSeriesColor: (dataKey: string, index: number) => string;
+    getColorClass: (type: "grid" | "axis" | "text" | "background" | "hover" | "disabled") => string;
+    getOpacityClass: (type: "default" | "hover" | "disabled") => string;
+    getTransitionClass: (type: "default" | "hover") => string;
+    resolvedTheme: ChartThemeConfig;
+    chartColors: Record<string, string>;
+    getThemeValue: (key: string) => string;
+};
+export {};

package/dist/components/charts/hooks/useChartValidation.d.ts

@@ -0,0 +1,74 @@
+import { SafeMath, type ChartValidationResult, type ChartValidationError } from '../utils/chart-validation';
+import { ChartDataPoint } from '../types/chart.types';
+interface UseChartValidationOptions {
+    /**
+     * Whether to sanitize data automatically
+     */
+    autoSanitize?: boolean;
+    /**
+     * Whether to log validation warnings to console
+     */
+    logWarnings?: boolean;
+    /**
+     * Custom error handler for validation errors
+     */
+    onValidationError?: (errors: ChartValidationError[]) => void;
+    /**
+     * Custom warning handler for validation warnings
+     */
+    onValidationWarning?: (warnings: ChartValidationError[]) => void;
+}
+interface UseChartValidationReturn {
+    /**
+     * Validation result
+     */
+    validation: ChartValidationResult;
+    /**
+     * Sanitized data (if autoSanitize is true)
+     */
+    sanitizedData: ChartDataPoint[];
+    /**
+     * Whether the chart data is valid and safe to render
+     */
+    isValid: boolean;
+    /**
+     * Whether there are any validation warnings
+     */
+    hasWarnings: boolean;
+    /**
+     * Safe scale calculation utilities
+     */
+    safeScale: {
+        calculateRange: (options?: {
+            minValue?: number;
+            maxValue?: number;
+            includeZero?: boolean;
+            padding?: number;
+        }) => {
+            min: number;
+            max: number;
+            hasValidData: boolean;
+        };
+    };
+    /**
+     * Safe math utilities
+     */
+    safeMath: typeof SafeMath;
+    /**
+     * Manual validation trigger
+     */
+    revalidate: () => void;
+}
+/**
+ * Hook for comprehensive chart validation and error handling
+ */
+export declare function useChartValidation(data: unknown, config: unknown, options?: UseChartValidationOptions): UseChartValidationReturn;
+/**
+ * Simplified hook for basic chart validation
+ */
+export declare function useChartDataValidation(data: unknown, config: unknown): UseChartValidationReturn;
+/**
+ * Hook for production chart validation (no console warnings)
+ */
+export declare function useChartValidationProduction(data: unknown, config: unknown, onError?: (errors: ChartValidationError[]) => void): UseChartValidationReturn;
+export {};

package/dist/components/charts/hooks/useTooltipPosition.d.ts

@@ -0,0 +1,98 @@
+export interface TooltipPosition {
+    x: number;
+    y: number;
+}
+export interface TooltipBounds {
+    width: number;
+    height: number;
+    containerRect: DOMRect;
+}
+export interface UseTooltipPositionOptions {
+    /** Container element ref for boundary detection */
+    containerRef: React.RefObject<HTMLElement | HTMLDivElement | null>;
+    /** Padding from container edges (default: 10px) */
+    padding?: number;
+    /** Offset from cursor/element (default: 15px) */
+    offset?: number;
+    /** Whether to use mobile-optimized positioning */
+    isMobile?: boolean;
+    /** Animation configuration for smooth movement */
+    animation?: {
+        /** Animation duration in seconds (default: 0.08) */
+        duration?: number;
+        /** Animation easing (default: "easeOut") */
+        ease?: string | number[];
+        /** Whether to enable smooth animation (default: true) */
+        enabled?: boolean;
+    };
+}
+export interface TooltipData<T = any> {
+    x: number;
+    y: number;
+    content: T;
+}
+export declare function useTooltipPosition({ containerRef, padding, offset, isMobile, animation, }: UseTooltipPositionOptions): {
+    tooltipData: TooltipData<any> | null;
+    tooltipRef: import("react").RefObject<HTMLDivElement | null>;
+    showTooltip: <T>(content: T, position: TooltipPosition) => void;
+    hideTooltip: () => void;
+    updateTooltipPosition: (position: TooltipPosition) => void;
+    handleMouseEnter: <T>(event: React.MouseEvent, content: T, svgCoordinates?: {
+        x: number;
+        y: number;
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    }) => void;
+    handleMouseMove: (event: React.MouseEvent, svgCoordinates?: {
+        x: number;
+        y: number;
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    }) => void;
+    handleMouseLeave: () => void;
+    getMouseTooltipPosition: (event: React.MouseEvent) => TooltipPosition;
+    getSVGTooltipPosition: (event: React.MouseEvent, svgX: number, svgY: number, actualDimensions: {
+        width: number;
+        height: number;
+    }) => TooltipPosition;
+    animationConfig: {
+        animate: {
+            x: number;
+            y: number;
+            opacity: number;
+        } | {
+            opacity: number;
+            x?: undefined;
+            y?: undefined;
+        };
+        transition: {
+            duration: number | undefined;
+            ease: string | number[] | undefined;
+            type: string;
+        } | {
+            duration: number;
+            ease?: undefined;
+            type?: undefined;
+        };
+        initial: {
+            opacity: number;
+        };
+        style: {
+            position: "fixed";
+            left: number;
+            top: number;
+            transform: string;
+            willChange: string;
+        } | {
+            position?: undefined;
+            left?: undefined;
+            top?: undefined;
+            transform?: undefined;
+            willChange?: undefined;
+        };
+    };
+};

package/dist/components/charts/index.d.ts

@@ -0,0 +1,35 @@
+export { ChartContainer } from './ChartContainer';
+export { BarChart } from './BarChart';
+export { LineChart } from './LineChart';
+export { AreaChart } from './AreaChart';
+export { Heatmap } from './Heatmap';
+export { ChartTooltip } from './shared/ChartTooltip';
+export { XAxis, YAxis } from './shared/ChartAxis';
+export { ChartText } from './shared/ChartText';
+export { ChartMarker } from './shared/ChartMarker';
+export { ChartCrosshair } from './shared/ChartCrosshair';
+export { HorizontalGrid } from './shared/ChartGrid';
+export { useChartTheme } from './hooks/useChartTheme';
+export { useTooltipPosition } from './hooks/useTooltipPosition';
+export { useChartAccessibility } from './hooks/useChartAccessibility';
+export { useChartValidation } from './hooks/useChartValidation';
+export { generateColorPalette, getContrastColor } from './utils/color-utils';
+export { processHeatmapData, calculateIntensity, createGridMatrix, getDefaultTooltipContent, formatAxisLabel, generateSampleData } from './Heatmap/utils/heatmapUtils';
+export type { ChartDataPoint, ChartConfig, ChartVariant, CurveType, BaseChartProps, StandardChartDisplayProps, StandardVisualProps, BarChartSpecificProps, StandardAxisConfig, ChartThemeOverrides, CHART_DEFAULTS, } from './types/chart.types';
+export type { ChartTooltipProps, ChartTooltipContentProps, } from './shared/ChartTooltip/ChartTooltip.types';
+export type { BaseAxisProps, XAxisProps, YAxisProps, AxisTickProps, } from './shared/ChartAxis/ChartAxis.types';
+export type { ChartTextProps, ChartTextTheme, } from './shared/ChartText/ChartText.types';
+export type { ChartMarkerProps, ChartMarkerTheme, } from './shared/ChartMarker/ChartMarker.types';
+export type { ChartCrosshairProps, ChartCrosshairTheme, } from './shared/ChartCrosshair/ChartCrosshair.types';
+export type { HorizontalGridProps, } from './shared/ChartGrid';
+export type { BarChartProps } from './BarChart/BarChart.types';
+export type { LineChartProps } from './LineChart/LineChart.types';
+export type { AreaChartProps } from './AreaChart/AreaChart.types';
+export type { HeatmapProps } from './Heatmap/Heatmap.types';
+export { chartTheme } from './theme/chart.theme';
+export { extractFillClass, extractStrokeClass, colorClassToVariable, combineClasses, createColorClass, generateSeriesColors, DEFAULT_CHART_COLORS, EXTENDED_CHART_COLORS, MINIMAL_CHART_COLORS, } from './utils/color-utils';
+export { validateChart, validateChartData, validateChartConfig, sanitizeChartData, calculateSafeScaleRange, SafeMath } from './utils/chart-validation';
+export { BAR_CHART_DEFAULTS } from './BarChart/BarChart.types';
+export { LINE_CHART_DEFAULTS } from './LineChart/LineChart.types';
+export { AREA_CHART_DEFAULTS } from './AreaChart/AreaChart.types';
+export { ChartErrorBoundary } from './shared/ChartErrorBoundary';

package/dist/components/charts/shared/ChartAxis/ChartAxis.types.d.ts

@@ -0,0 +1,90 @@
+export interface BaseAxisProps {
+    /** Whether to show the axis */
+    show?: boolean;
+    /** Custom className for styling */
+    className?: string;
+    /** Color of the axis line and text */
+    color?: string;
+    /** Font size for axis labels */
+    fontSize?: number;
+    /** Whether to show tick marks */
+    showTicks?: boolean;
+    /** Length of tick marks */
+    tickLength?: number;
+    /** Spacing between ticks and labels */
+    tickPadding?: number;
+}
+export interface XAxisProps extends BaseAxisProps {
+    /** Data points for the x-axis */
+    data: Array<{
+        name?: string;
+        label?: string;
+        [key: string]: any;
+    }>;
+    /** X position of the axis */
+    x: number;
+    /** Y position of the axis */
+    y: number;
+    /** Width of the axis */
+    width: number;
+    /** Width of each category/bar group */
+    categoryWidth: number;
+    /** Gap between categories */
+    categoryGap?: number;
+    /** Text anchor for labels */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /** Rotation angle for labels */
+    labelRotation?: number;
+    /** Custom label formatter */
+    labelFormatter?: (value: any, index: number) => string;
+    /** Maximum width for labels before truncation */
+    maxLabelWidth?: number;
+}
+export interface YAxisProps extends BaseAxisProps {
+    /** Minimum value for the y-axis */
+    min: number;
+    /** Maximum value for the y-axis */
+    max: number;
+    /** Number of ticks on the y-axis */
+    tickCount?: number;
+    /** X position of the axis */
+    x: number;
+    /** Y position of the axis */
+    y: number;
+    /** Height of the axis */
+    height: number;
+    /** Text anchor for labels */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /** Custom tick formatter */
+    tickFormatter?: (value: number) => string;
+    /** Whether to show grid lines */
+    showGrid?: boolean;
+    /** Width of the chart area for grid lines */
+    gridWidth?: number;
+    /** Custom tick values */
+    ticks?: number[];
+}
+export interface AxisTickProps {
+    /** Value of the tick */
+    value: number | string;
+    /** X position */
+    x: number;
+    /** Y position */
+    y: number;
+    /** Whether to show the tick mark */
+    showTick?: boolean;
+    /** Length of the tick mark */
+    tickLength?: number;
+    /** Text anchor */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /** Custom formatter */
+    formatter?: (value: any) => string;
+    /** Font size */
+    fontSize?: number;
+    /** Color */
+    color?: string;
+    /** Rotation angle */
+    rotation?: number;
+    /** Maximum width before truncation */
+    maxWidth?: number;
+}

package/dist/components/charts/shared/ChartAxis/XAxis.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { XAxisProps } from './ChartAxis.types';
+/**
+ * XAxis component for charts
+ * Renders horizontal axis with labels and optional tick marks
+ */
+export declare const XAxis: React.FC<XAxisProps>;

package/dist/components/charts/shared/ChartAxis/YAxis.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { YAxisProps } from './ChartAxis.types';
+/**
+ * YAxis component for charts
+ * Renders vertical axis with labels, optional tick marks, and grid lines
+ */
+export declare const YAxis: React.FC<YAxisProps>;

package/dist/components/charts/shared/ChartAxis/index.d.ts

@@ -0,0 +1,3 @@
+export { XAxis } from './XAxis';
+export { YAxis } from './YAxis';
+export type { BaseAxisProps, XAxisProps, YAxisProps, AxisTickProps, } from './ChartAxis.types';

package/dist/components/charts/shared/ChartCrosshair/ChartCrosshair.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { ChartCrosshairProps } from "./ChartCrosshair.types";
+/**
+ * ChartCrosshair component for rendering crosshair lines in charts
+ * Supports both vertical and horizontal lines with smooth Framer Motion transitions
+ */
+export declare const ChartCrosshair: React.FC<ChartCrosshairProps>;

package/dist/components/charts/shared/ChartCrosshair/ChartCrosshair.theme.d.ts

@@ -0,0 +1,6 @@
+import type { ChartCrosshairTheme } from './ChartCrosshair.types';
+/**
+ * Default theme for ChartCrosshair component
+ * Provides consistent styling for chart crosshair lines with Framer Motion animations
+ */
+export declare const chartCrosshairTheme: ChartCrosshairTheme;

package/dist/components/charts/shared/ChartCrosshair/ChartCrosshair.types.d.ts

@@ -0,0 +1,35 @@
+export interface ChartCrosshairProps {
+    /** Whether to show the crosshair */
+    show: boolean;
+    /** X coordinate for the vertical line */
+    x: number;
+    /** Y coordinate for the horizontal line (optional) */
+    y?: number;
+    /** Chart margins */
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Inner chart dimensions */
+    innerWidth: number;
+    innerHeight: number;
+    /** Whether to show the horizontal line */
+    showHorizontal?: boolean;
+    /** Custom stroke color */
+    strokeColor?: string;
+    /** Custom stroke width */
+    strokeWidth?: number;
+    /** Custom stroke dash array */
+    strokeDasharray?: string;
+    /** Custom opacity */
+    opacity?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface ChartCrosshairTheme {
+    baseStyle?: string;
+    verticalLine?: string;
+    horizontalLine?: string;
+}

package/dist/components/charts/shared/ChartCrosshair/index.d.ts

@@ -0,0 +1,3 @@
+export { ChartCrosshair } from './ChartCrosshair';
+export type { ChartCrosshairProps, ChartCrosshairTheme } from './ChartCrosshair.types';
+export { chartCrosshairTheme } from './ChartCrosshair.theme';

package/dist/components/charts/shared/ChartErrorBoundary/ChartErrorBoundary.d.ts

@@ -0,0 +1,34 @@
+import React, { Component, ErrorInfo, ReactNode } from 'react';
+interface ChartErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    className?: string;
+    showErrorDetails?: boolean;
+}
+interface ChartErrorBoundaryState {
+    hasError: boolean;
+    error?: Error;
+    errorInfo?: ErrorInfo;
+}
+/**
+ * Error boundary specifically designed for chart components
+ * Provides graceful error handling and fallback UI
+ */
+export declare class ChartErrorBoundary extends Component<ChartErrorBoundaryProps, ChartErrorBoundaryState> {
+    constructor(props: ChartErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ChartErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+/**
+ * Hook version of error boundary for functional components
+ * Note: This is a simplified version - full error boundaries require class components
+ */
+export declare function useChartErrorHandler(): {
+    error: Error | null;
+    resetError: () => void;
+    handleError: (error: Error) => void;
+    hasError: boolean;
+};
+export {};

package/dist/components/charts/shared/ChartErrorBoundary/index.d.ts

@@ -0,0 +1 @@
+export { ChartErrorBoundary, useChartErrorHandler } from './ChartErrorBoundary';

package/dist/components/charts/shared/ChartGrid/HorizontalGrid.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+export interface HorizontalGridProps {
+    /** X position to start the grid */
+    x: number;
+    /** Y position to start the grid */
+    y: number;
+    /** Width of the grid area */
+    width: number;
+    /** Height of the grid area */
+    height: number;
+    /** Number of grid lines */
+    lineCount?: number;
+    /** Whether to show the grid */
+    show?: boolean;
+    /** Grid line color */
+    color?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom tick positions (overrides lineCount) */
+    tickPositions?: number[];
+}
+/**
+ * HorizontalGrid component for charts
+ * Renders horizontal grid lines at specified intervals
+ */
+export declare const HorizontalGrid: React.FC<HorizontalGridProps>;

package/dist/components/charts/shared/ChartGrid/index.d.ts

@@ -0,0 +1,2 @@
+export { HorizontalGrid } from './HorizontalGrid';
+export type { HorizontalGridProps } from './HorizontalGrid';

package/dist/components/charts/shared/ChartLegend/ChartLegend.types.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface ChartLegendProps {
+    content?: ReactNode;
+    wrapperStyle?: React.CSSProperties;
+    iconType?: 'line' | 'rect' | 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
+    layout?: 'horizontal' | 'vertical';
+    align?: 'left' | 'center' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    className?: string;
+}
+export interface ChartLegendContentProps {
+    payload?: any[];
+    nameKey?: string;
+    className?: string;
+}

package/dist/components/charts/shared/ChartLegend/index.d.ts

@@ -0,0 +1 @@
+export type { ChartLegendProps, ChartLegendContentProps } from './ChartLegend.types';

package/dist/components/charts/shared/ChartMarker/ChartMarker.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { ChartMarkerProps } from "./ChartMarker.types";
+/**
+ * ChartMarker component for rendering circular data point markers in charts
+ * Supports hover scaling with React state for reliable SVG interactions
+ */
+export declare const ChartMarker: React.FC<ChartMarkerProps>;

package/dist/components/charts/shared/ChartMarker/ChartMarker.theme.d.ts

@@ -0,0 +1,6 @@
+import type { ChartMarkerTheme } from './ChartMarker.types';
+/**
+ * Default theme for ChartMarker component
+ * Provides consistent styling for chart data point markers
+ */
+export declare const chartMarkerTheme: ChartMarkerTheme;

package/dist/components/charts/shared/ChartMarker/ChartMarker.types.d.ts

@@ -0,0 +1,21 @@
+export interface ChartMarkerProps {
+    /** X coordinate of the marker center */
+    cx: number;
+    /** Y coordinate of the marker center */
+    cy: number;
+    /** Radius of the marker */
+    radius: number;
+    /** Color class for the marker stroke */
+    colorClass: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom stroke width */
+    strokeWidth?: number;
+    /** Fill color override */
+    fillColor?: string;
+    /** Stroke color override */
+    strokeColor?: string;
+}
+export interface ChartMarkerTheme {
+    baseStyle?: string;
+}

package/dist/components/charts/shared/ChartMarker/index.d.ts

@@ -0,0 +1,3 @@
+export { ChartMarker } from './ChartMarker';
+export type { ChartMarkerProps, ChartMarkerTheme } from './ChartMarker.types';
+export { chartMarkerTheme } from './ChartMarker.theme';

package/dist/components/charts/shared/ChartText/ChartText.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { ChartTextProps } from "./ChartText.types";
+/**
+ * ChartText component for consistent typography in charts
+ * Uses fixed Tailwind styling for consistency
+ */
+export declare const ChartText: React.FC<ChartTextProps>;

package/dist/components/charts/shared/ChartText/ChartText.theme.d.ts

@@ -0,0 +1,6 @@
+import type { ChartTextTheme } from './ChartText.types';
+/**
+ * Default theme for ChartText component
+ * Uses fixed Tailwind styling for consistency across charts
+ */
+export declare const chartTextTheme: ChartTextTheme;

package/dist/components/charts/shared/ChartText/ChartText.types.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+export interface ChartTextProps extends React.SVGProps<SVGTextElement> {
+    /** Text content to display */
+    children: React.ReactNode;
+    /** Text anchor alignment */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /** Dominant baseline alignment */
+    dominantBaseline?: 'auto' | 'middle' | 'hanging' | 'central' | 'text-before-edge' | 'text-after-edge';
+    /** Maximum width before truncation */
+    maxWidth?: number;
+    /** Whether to truncate text with ellipsis */
+    truncate?: boolean;
+    /** Rotation angle in degrees */
+    rotation?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface ChartTextTheme {
+    /** Base styles for chart text (includes default size, weight, color) */
+    baseStyle: string;
+}

package/dist/components/charts/shared/ChartText/index.d.ts

@@ -0,0 +1,2 @@
+export { ChartText } from './ChartText';
+export type { ChartTextProps, ChartTextTheme } from './ChartText.types';

package/dist/components/charts/shared/ChartTooltip/ChartTooltip.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import { ChartTooltipProps, MultiSeriesChartTooltipProps } from "./ChartTooltip.types";
+export declare function ChartTooltip({ content, className, active, position, children, chartType, containerClassName, categoryClassName, seriesContainerClassName, seriesRowClassName, dotClassName, labelClassName, valueClassName, tooltipRef, ...props }: (ChartTooltipProps | MultiSeriesChartTooltipProps) & {
+    active?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+    children?: React.ReactNode;
+    chartType?: 'line' | 'bar' | 'area';
+    containerClassName?: string;
+    categoryClassName?: string;
+    seriesContainerClassName?: string;
+    seriesRowClassName?: string;
+    dotClassName?: string;
+    labelClassName?: string;
+    valueClassName?: string;
+    tooltipRef?: React.RefObject<HTMLDivElement | null>;
+}): React.JSX.Element;