@graphique/graphique/dist/index.d.cts

A data visualization system for React based on the Grammar of Graphics.

import React$1, { ReactNode, CSSProperties } from 'react';
import { scaleLinear, scaleLog, scaleSymlog, scaleSqrt, scalePow, scaleTime, scaleUtc, scaleBand, ScaleLinear, ScaleLogarithmic, ScaleSymLog, ScalePower, ScaleTime, ScaleBand, scaleOrdinal, scaleQuantile, scaleQuantize, scaleThreshold, scaleSequential, scaleSequentialSqrt, scaleDiverging, scaleSequentialLog, scaleSequentialSymlog, ScaleOrdinal, ScaleDiverging, ScaleSequential, ScaleQuantile, ScaleQuantize, ScaleThreshold } from 'd3-scale';
import * as jotai from 'jotai';
import { interpolateViridis } from 'd3-scale-chromatic';
export { interpolateViridis as defaultInterpolator } from 'd3-scale-chromatic';
export { usePageVisibility } from 'react-page-visibility';

type DataValue<Datum> = (d: Datum) => number | string | Date | null | undefined;
interface Aes<Datum> {
    /** functional mapping to `data` used to create an [x scale](https://graphique.dev/docs/graphique/scales/x) */
    x: DataValue<Datum>;
    /** functional mapping to `data` used to create a [y scale](https://graphique.dev/docs/graphique/scales/y) */
    y?: DataValue<Datum>;
    /** functional mapping to `data` used to create a [stroke scale](https://graphique.dev/docs/graphique/scales/stroke) */
    stroke?: DataValue<Datum>;
    /** functional mapping to `data` used to create a [strokeDasharray scale](https://graphique.dev/docs/graphique/scales/stroke-dasharray) */
    strokeDasharray?: DataValue<Datum>;
    /** functional mapping to `data` used to create a
     * continuous **size** scale
     *
     * Right now it's only used with `<GeomPoint>` to create a [radius scale](https://graphique.dev/docs/graphique/scales/radius) for points.
     */
    size?: (d: Datum) => number | null | undefined;
    /** functional mapping to `data` used to create a [fill scale](https://graphique.dev/docs/graphique/scales/fill) */
    fill?: DataValue<Datum>;
    /** functional mapping to `data` used to create
     * distinct groups explicitly (without an associated scale) */
    group?: DataValue<Datum>;
    /** functional mapping to `data` used to label tooltips and text values created with `GeomLabel` */
    label?: (d: Datum) => string;
    /** functional mapping to `data` used to distinguish individual data points */
    key?: (d: Datum) => string;
}

interface Margin {
    top?: number;
    right?: number;
    bottom?: number;
    left?: number;
}
interface RootGGProps<Datum> {
    /** the data used to create the base, an array of objects */
    data: Datum[];
    /** the functional mapping of data characteristics to visual characteristics */
    aes: Aes<Datum>;
    /** the width of the visualization area in pixels (_default_: `550`)
     *
     * Use `isContainerWidth` if you'd like it to be as wide as the parent container.
     */
    width?: number;
    /** the height of the visualization area in pixels (_default_: `450`) */
    height?: number;
    /** an object specifying the margins surrounding the visualization area */
    margin?: Margin;
    /** when true, the visualization will fill its parent container's width
     * (and respond to changes in its width)
     */
    isContainerWidth?: boolean;
    /** elements used to specify and configure the visualization
     * (e.g. Geoms, Scales, Labels, Theme, etc.)
     */
    children?: ReactNode;
}
interface GGProps<Datum> extends RootGGProps<Datum> {
    parentWidth?: number;
    id?: string;
}

/**
 * **The top-level component and starting point for creating Graphique visualizations**.
 *
 * Pass in data, map data properties to visual properties (`aes`), and fill with child Geoms
 * to start visualizing data. Configure and customize with a friendly, component-based API.
 *
 * @param data - the data used to create the base, an array of objects
 * @param aes - an object of accessor methods to map data characteristics to visual characteristics
 * @param width - the width of the visualization area in pixels
 * @param height - the height of the visualization area in pixels
 * @param margin - an object specifying the margins surrounding the visualization area
 * @param isContainerWidth - when true, the visualization will fill its parent container's width
 * @param children - elements used to specify and configure the visualization (e.g. Geoms, Scales, Labels, Theme, etc.)
 *
 * @returns {React.JSX.Element} A React element that renders your visualization!
 */
declare const GG: <Datum>({ children, ...props }: RootGGProps<Datum>) => React$1.JSX.Element;

type XYScale = typeof scaleLinear | typeof scaleLog | typeof scaleSymlog | typeof scaleSqrt | typeof scalePow | typeof scaleTime | typeof scaleUtc | typeof scaleBand;
type XYScaleTypes = ScaleLinear<any, any> & ScaleLogarithmic<any, any> & ScaleSymLog<any, any> & ScalePower<any, any> & ScaleTime<any, any> & ScaleBand<any>;
type VisualEncoding = typeof scaleOrdinal | typeof scaleQuantile | typeof scaleQuantize | typeof scaleThreshold | typeof scaleSequential | typeof scaleSequentialSqrt | typeof scaleDiverging | typeof scaleSequentialLog | typeof scaleSequentialSymlog;
type VisualEncodingTypes = ScaleOrdinal<any, any> & ScaleLinear<any, any> & ScaleDiverging<any> & ScaleSequential<any> & ScaleQuantile<any> & ScaleQuantize<any> & ScaleThreshold<any, any> & ScaleLinear<any, any> & ScalePower<any, any>;

declare enum BrushAction {
    ZOOM = "zoom"
}

declare enum LegendOrientation {
    H = "horizontal",
    V = "vertical"
}

interface FormatOptions {
    value: any;
    index: number;
    width: number;
}
interface XYScaleProps {
    /** An explicit scale imported from [`d3-scale`](https://d3js.org/d3-scale) used to determine relationship between data inputs and visual outputs (_default_: inferred from `aes` mapping's initial return type) */
    type?: XYScale;
    /** For continuous scales, should the scale (and relevant axis) be reversed. _Note_: Categorical scales have their order controlled by `domain`. */
    reverse?: boolean;
    /** Function used to format axis tick labels */
    format?: ({ value, index, width }: FormatOptions) => string;
    /** Approximate number of ticks to use in axis (_default_: derived from parent container's width or height) */
    numTicks?: ((widthOrHeight: number) => number | undefined) | number;
    /** Used to create an explicit/fixed scale. Continuous scales should get `[min, max]` and categorical scales should get an ordered list of categories.  */
    domain?: unknown[];
    /** For categorical scales, should the focused data highlight the associated axis tick label */
    highlightOnFocus?: boolean;
    /** For categorical scales, the tick labels that should be explicitly/programmatically focused */
    focusedTicks?: string[];
    /** This is passed to the top-level axis element, and can be used to control styling */
    className?: string;
}

interface VisualEncodingProps {
    /** An explicit scale imported from [`d3-scale`](https://d3js.org/d3-scale) used to determine relationship between data inputs and visual outputs (_default_: inferred from `aes` mapping's initial return type) */
    type?: VisualEncoding;
    /** Used to create an explicit/fixed scale. Continuous scales should get `[min, max]` and categorical scales should get an ordered list of categories.  */
    domain?: any[];
    /** Used to create an explicit/fixed scale. Continuous scales should get a function that maps the input domain to the output range (e.g. a [d3 interpolator](https://d3js.org/d3-scale-chromatic/sequential#sequential-schemes)), and categorical scales should get an ordered list of categories (e.g. a [d3 scheme](https://d3js.org/d3-scale-chromatic/categorical#categorical-schemes)).  */
    values?: readonly string[] | ((t: number) => string);
    /** For continuous scales, should the scale be reversed. _Note_: Categorical scales have their order controlled by `domain`. */
    reverse?: boolean;
}
interface SizeEncodingProps {
    /** Used to create an explicit/fixed scale given a `[min, max]` for the input domain (mapped data property) */
    domain?: [number, number];
    /** Used to create an explicit/fixed scale given a `[min, max]` for the output range in pixels (_default_: `[3, 30]`) */
    range?: [number, number];
}

interface IScale<Datum> {
    xScale: XYScaleTypes;
    yScale: XYScaleTypes;
    fillScale?: VisualEncodingTypes;
    strokeScale?: VisualEncodingTypes;
    strokeDasharrayScale?: VisualEncodingTypes;
    groupAccessor: DataValue<Datum> | undefined;
    groups?: string[];
}
interface AutoScale<Datum> extends GGProps<Datum> {
    scalesState: {
        x: XYScaleProps;
        y: XYScaleProps;
        hasZeroXBaseLine: boolean;
        hasZeroYBaseLine: boolean;
        geomGroupAccessors: DataValue<Datum>[];
        y0Aes?: DataValue<Datum>;
        y1Aes?: DataValue<Datum>;
        geomAesYs: DataValue<Datum>[];
        geomAesStrokes: DataValue<Datum>[];
        geomAesStrokeDasharrays: DataValue<Datum>[];
        geomAesFills: DataValue<Datum>[];
        fill?: VisualEncodingProps;
        stroke?: VisualEncodingProps;
        strokeDasharray?: VisualEncodingProps;
    };
    copiedData: Datum[];
    shouldExcludeMissingXYFromDomains?: boolean;
}
declare const autoScale: <Datum>({ scalesState, data, copiedData, aes, width, height, margin: suppliedMargin, shouldExcludeMissingXYFromDomains, }: AutoScale<Datum>) => IScale<Datum>;

interface ContextProps<Datum> {
    ggState: {
        id?: string;
        width: number;
        height: number;
        margin: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
        data: Datum[];
        copiedData: Datum[];
        aes: Aes<Datum>;
        copiedScales: IScale<Datum>;
        scales: IScale<Datum>;
    };
    updateData: (newData: Datum[]) => void;
}
declare const useGG: <Datum>() => ContextProps<Datum>;

interface LabelsProps {
    /** An element or string placed above the visualization area — a great place for a title or anything else you'd like */
    header?: React.ReactNode;
    /** Used to label the x axis */
    x?: string;
    /** An element or string used to label the y axis */
    y?: React.ReactNode;
}
declare const labelsState: jotai.PrimitiveAtom<LabelsProps> & {
    init: LabelsProps;
};

interface PointThemeProps<Datum> {
    fillOpacity?: number | string;
    stroke?: string;
    strokeWidth?: number | string;
    strokeOpacity?: number | string;
    strokeDasharray?: number | string;
    unfocusedStyles?: CSSProperties;
    fill?: string;
    hasFill?: boolean;
    fillScale?: VisualEncodingTypes;
    strokeScale?: VisualEncodingTypes;
    strokeDasharrayScale?: VisualEncodingTypes;
    usableGroups?: string[];
    groupAccessor?: DataValue<Datum>;
    aes?: Aes<Datum>;
    size?: (d: any) => number | null | undefined;
}
interface AreaProps<Datum> extends PointThemeProps<Datum> {
    /** a functional mapping to `data` representing an initial **y** value */
    y0?: (d: Datum) => number | undefined;
    /** a functional mapping to `data` representing a secondary **y** value */
    y1?: (d: Datum) => number | undefined;
}
interface HistProps {
    binWidth?: number;
}
interface GeomsTheme<Datum> {
    point?: PointThemeProps<Datum>;
    line?: PointThemeProps<Datum>;
    vline?: PointThemeProps<Datum>;
    hline?: PointThemeProps<Datum>;
    smooth?: PointThemeProps<Datum>;
    tile?: PointThemeProps<Datum>;
    bar?: PointThemeProps<Datum>;
    col?: PointThemeProps<Datum>;
    histogram?: HistProps;
    area?: AreaProps<Datum>;
    label?: PointThemeProps<Datum>;
}
interface AxisTheme {
    stroke?: string;
    label?: {
        fontSize?: number | string;
        fontFamily?: string;
        color?: string;
    };
    tickLabel?: {
        fontSize?: number | string;
        fontFamily?: string;
        color?: string;
    };
    tickStroke?: string;
    showAxisLine?: boolean;
}
interface LegendTheme {
    labelColor?: string;
    tickColor?: string;
}
interface TooltipTheme {
    font?: {
        family?: string;
        size?: number;
    };
    xLabel?: {
        fontSize?: number | string;
        fontFamily?: string;
        color?: string;
    };
    yLabel?: {
        fontSize?: number | string;
        fontFamily?: string;
        color?: string;
    };
    groupLabel?: {
        fontSize?: number | string;
        fontFamily?: string;
        color?: string;
    };
}
interface FontTheme {
    family?: string;
}
interface GridTheme {
    stroke?: string | null;
}
interface ThemeProps<Datum> {
    /** font color for header */
    headerColor?: string;
    /** stroke color for marker (_default_: `"#ffffff"`) */
    markerStroke?: string;
    /** stroke color used for geoms with a default stroke attribute (_default_: `"#777777ee"`) */
    defaultStroke?: string;
    /** fill color used for geoms with a default fill attribute (_default_: `"#777777ee"`) */
    defaultFill?: string;
    /** internal state that is set automatically and can be retrieved for each used Geom. _Note: you shouldn't ever need to modify this directly._ */
    geoms?: GeomsTheme<Datum>;
    /** sets the default font used throughout a visualization */
    font?: FontTheme;
    /** sets appearance properties for grid lines */
    grid?: GridTheme;
    /** theme properties applied to x and y axes (ticks, labels, etc.)  */
    axis?: AxisTheme | null;
    /** theme properties applied to x axis (ticks, labels, etc.)  */
    axisX?: AxisTheme | null;
    /** theme properties applied to y axis (ticks, labels, etc.)  */
    axisY?: AxisTheme | null;
    /** theme properties applied to legends */
    legend?: LegendTheme;
    /** theme properties applied to tooltip */
    tooltip?: TooltipTheme;
    /** duration in milliseconds for animated transitions (_default_: `1000`) */
    animationDuration?: number;
}
declare const themeState: jotai.PrimitiveAtom<ThemeProps<any>> & {
    init: ThemeProps<any>;
};

interface TooltipContent<Datum> {
    label?: string;
    group?: string | number | Date | null;
    mark?: JSX.Element;
    x?: number;
    y?: number;
    formattedX?: string;
    formattedY?: string;
    formattedMeasure?: string;
    datum?: Datum[];
    containerWidth: number;
    xLab?: string;
    yLab?: React$1.ReactNode;
}
declare enum TooltipPosition {
    TOP = "top",
    DATA = "data"
}
interface HorizontalProps {
    width?: number;
    x?: number;
}
interface VerticalProps {
    height?: number;
    y?: number;
}
interface TooltipProps<Datum> {
    /** horizontal adjustment in pixels for tooltip's position relative to focused datum */
    dx?: (({ width, x }: HorizontalProps) => number) | number;
    /** vertical adjustment in pixels for tooltip's position relative to focused datum */
    dy?: (({ height, y }: VerticalProps) => number) | number;
    /** should the tooltip be contained within the visualization area (_default_: `true`)  */
    keepInParent?: (({ width, x }: HorizontalProps) => boolean) | boolean;
    /** tooltip's position relative to focused datum (_default_: `TooltipPosition.DATA`) */
    position?: TooltipPosition;
    /** formatting function for tooltip x values */
    xFormat?: (d: any) => string;
    /** formatting function for tooltip y values */
    yFormat?: (d: any) => string;
    /** formatting function for tooltip measure labels created with an [`aes.label`](https://graphique.dev/docs/graphique/gg#Aes) mapping */
    measureFormat?: (d: any) => string;
    /** function that can be used to render a completely custom tooltip component based on the focused datum's individual parts */
    content?: (value?: TooltipContent<Datum>[]) => React$1.ReactNode | undefined;
    /** should the tooltip x value be rendered as an independent tooltip along the x axis */
    xAxis?: ((x?: string | number | Date | null) => React$1.ReactNode) | boolean;
    /** used for programmatically focusing Geom elements/displaying tooltip when given a meaningful subset of `data` */
    datum?: Datum[];
}
declare const tooltipState: jotai.PrimitiveAtom<TooltipProps<any>> & {
    init: TooltipProps<any>;
};

interface XScaleProps extends XYScaleProps {
    isFixed?: boolean;
}
declare const xScaleState: jotai.PrimitiveAtom<XScaleProps> & {
    init: XScaleProps;
};

interface YScaleProps extends XYScaleProps {
    isFixed?: boolean;
}
declare const yScaleState: jotai.PrimitiveAtom<YScaleProps> & {
    init: YScaleProps;
};

declare const fillScaleState: jotai.PrimitiveAtom<VisualEncodingProps> & {
    init: VisualEncodingProps;
};

declare const strokeScaleState: jotai.PrimitiveAtom<VisualEncodingProps> & {
    init: VisualEncodingProps;
};

declare const strokeDasharrayState: jotai.PrimitiveAtom<VisualEncodingProps> & {
    init: VisualEncodingProps;
};

declare const radiusScaleState: jotai.PrimitiveAtom<SizeEncodingProps> & {
    init: SizeEncodingProps;
};

interface XYDomain {
    original?: any[];
    current?: any[];
}
type ZoomDomain = {
    x?: any[];
    y?: any[];
};
interface ZoomProps {
    xDomain?: XYDomain;
    yDomain?: XYDomain;
    onZoom?: (domain: ZoomDomain) => void;
    onUnzoom?: () => void;
}
interface ZoomSettings {
    xDomain?: any[];
    yDomain?: any[];
    onZoom?: (domain?: ZoomDomain) => void;
    onUnzoom?: () => void;
}
declare const zoomState: jotai.PrimitiveAtom<ZoomProps> & {
    init: ZoomProps;
};

/** A headless component used to give your visualization a header and/or axis labels. */
declare const Labels: ({ header, x, y }: LabelsProps) => null;

/** A headless component used to customize the look and feel of a visualization. */
declare const Theme: <Datum>({ headerColor, markerStroke, defaultStroke, defaultFill, font, grid, axis, axisX, axisY, legend, tooltip, animationDuration, }: ThemeProps<Datum>) => null;

declare const Zoom: ({ onZoom, onUnzoom, xDomain, yDomain }: ZoomSettings) => null;

type CustomExtent = (number | undefined)[];
interface CustomExtents {
    customXExtent?: CustomExtent;
    customYExtent?: CustomExtent;
}
declare const useUnZoom: () => ({ customXExtent, customYExtent }: CustomExtents) => void;

/** A headless component used to customize a visualization's tooltip content and/or appearance. */
declare const Tooltip: <Datum>({ keepInParent, position, xAxis, content, xFormat, yFormat, measureFormat, datum, dx, dy, }: TooltipProps<Datum>) => null;

interface YTooltipProps {
    id: string;
    left: number;
    top: number;
    value: React$1.ReactNode;
    wait?: boolean;
}
declare const YTooltip: ({ id, left, top, value, wait }: YTooltipProps) => React$1.JSX.Element;

interface XTooltipProps {
    id: string;
    left: number;
    top: number;
    yPosition?: 'above' | 'below';
    value: React$1.ReactNode;
    align?: 'left' | 'center' | 'right';
}
declare const XTooltip: ({ id, left, top, value, yPosition, align, }: XTooltipProps) => React$1.JSX.Element;

interface TooltipContainerProps {
    children?: React$1.ReactNode;
    style?: CSSProperties;
}
declare const TooltipContainer: ({ children, style, }: TooltipContainerProps) => React$1.JSX.Element;

/**
 * A headless component used to configure a visualization's **x axis** and the **horizontal** position of geometry elements in 2D space.
 *
 * Available configuration options determined by an [`aes.x`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping and the type of data it returns (e.g. continuous vs. categorical).
 *
 * */
declare const ScaleX: ({ type, format, numTicks, domain, reverse, highlightOnFocus, focusedTicks, className, }: XYScaleProps) => null;

/**
 * A headless component used to configure a visualization's **y axis** and the **vertical** position of geometry elements in 2D space.
 *
 * Available configuration options determined by an [`aes.y`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping and the type of data it returns (e.g. continuous vs. categorical).
 *
 * */
declare const ScaleY: ({ type, format, numTicks, domain, reverse, highlightOnFocus, focusedTicks, className, }: XYScaleProps) => null;

/**
 * A headless component used to configure the **fill color** encoding for a visualization's geometry elements.
 *
 * Available configuration options determined by an [`aes.fill`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping and the type of data it returns (e.g. continuous vs. categorical).
 *
 * */
declare const ScaleFill: ({ type, domain, values, reverse, }: VisualEncodingProps) => null;

/**
 * A headless component used to configure the **stroke color** encoding for a visualization's geometry elements.
 *
 * Available configuration options determined by an [`aes.stroke`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping.
 *
 * */
declare const ScaleStroke: ({ type, domain, values, reverse, }: VisualEncodingProps) => null;

/**
 * A headless component used to configure the **stroke pattern** encoding for a visualization's geometry elements.
 *
 * Available configuration options determined by an [`aes.strokeDasharray`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping.
 *
 * */
declare const ScaleStrokeDasharray: ({ domain, values, }: VisualEncodingProps) => null;

/**
 * A headless component used to configure the **radius size** encoding for a visualization's GeomPoint elements.
 *
 * Available configuration options determined by an [`aes.size`](https://graphique.dev/docs/graphique/gg#Aes) functional mapping.
 *
 * */
declare const ScaleRadius: ({ domain, range }: SizeEncodingProps) => null;

declare const parseDate: (dateString: string, specifier?: string) => Date | null;
declare const isDate: (date: any) => boolean;
declare const formatMonth: (v: Date, monthOnly?: boolean) => string;
declare const formatDate: (v: Date, format?: string) => string;

declare const debounce: (delay: number, fn: (...args: any[]) => void) => (...args: any[]) => void;

interface FocusProps {
    nodes: HTMLCollectionOf<SVGElement>;
    focusedIndex: number | number[];
    focusedStyles: CSSProperties;
    unfocusedStyles: CSSProperties;
}
interface UnfocusProps {
    nodes: HTMLCollectionOf<SVGElement>;
    baseStyles: CSSProperties;
}
declare const focusNodes: ({ nodes, focusedIndex, focusedStyles, unfocusedStyles, }: FocusProps) => void;
declare const unfocusNodes: ({ nodes, baseStyles }: UnfocusProps) => void;

declare const getYAlongPath: (x: number, path: SVGPathElement, error?: number) => number;

declare const elongate: (data: {
    [key: string]: any;
}[], keyName: string, valName: string, exclude: string[]) => any[];

declare const widen: <Datum>(data: Datum[], pivot: (d: Datum) => any, getGroup: (d: Datum) => any, count: (d: Datum) => any) => any[];

declare const defaultScheme: string[];
declare const defaultDasharrays: string[];

declare const createSequentialScheme: (interpolator?: typeof interpolateViridis, n?: number) => string[];

interface StackMidpoint<X, Y> {
    groupVal: string;
    xVal: X;
    yVal: Y;
}
interface EventAreaProps<Datum> {
    x: (d: Datum) => number | undefined;
    y: (d: Datum) => number | undefined;
    group?: 'x' | 'y';
    xAdj?: number;
    yAdj?: number;
    onMouseOver?: ({ d, i }: {
        d: Datum[];
        i: number[];
    }) => void;
    onClick?: ({ d, i }: {
        d: Datum[];
        i: number[];
    }) => void;
    onMouseLeave: () => void;
    onDatumFocus?: (data: Datum[], index: number[]) => void;
    data?: Datum[];
    stackXMidpoints?: StackMidpoint<string | number, string | number>[];
    stackYMidpoints?: StackMidpoint<string | number, string | number>[];
    xBandScale?: ScaleBand<string>;
    yBandScale?: ScaleBand<string>;
    aes?: Omit<Aes<Datum>, 'x'> & {
        x?: DataValue<Datum>;
        y0?: DataValue<Datum>;
        y1?: DataValue<Datum>;
    };
    customXExtent?: (number | undefined)[];
    customYExtent?: (number | undefined)[];
    getYValExtent?: (data: Datum[]) => (number | undefined)[];
    positionKeys?: string;
    disabled?: boolean;
    fill?: 'x' | 'y';
    showTooltip?: boolean;
    brushAction?: BrushAction;
    isZoomedOut?: boolean;
}
declare const EventArea: <Datum>({ x, y, group, xAdj, yAdj, onMouseOver, onClick, onMouseLeave, onDatumFocus, data, aes, customXExtent, customYExtent, getYValExtent, positionKeys, disabled, showTooltip, brushAction, isZoomedOut, stackXMidpoints, stackYMidpoints, xBandScale, yBandScale, fill, }: EventAreaProps<Datum>) => React$1.JSX.Element;

declare const generateID: () => string;

declare const formatMissing: (v: any) => any;

declare const defineGroupAccessor: <Datum>(aes: Aes<Datum>, allowUndefined?: boolean) => DataValue<Datum> | undefined;

declare const nodeToString: (node: React$1.ReactNode) => string;

export { type Aes, BrushAction, type DataValue, EventArea, GG, type GGProps, type IScale, Labels, type LabelsProps, LegendOrientation, type RootGGProps, ScaleFill, ScaleRadius, ScaleStroke, ScaleStrokeDasharray, ScaleX, ScaleY, type SizeEncodingProps, Theme, type ThemeProps, Tooltip, TooltipContainer, type TooltipContent, TooltipPosition, type TooltipProps, type VisualEncoding, type VisualEncodingProps, type VisualEncodingTypes, XTooltip, type XYScale, type XYScaleProps, type XYScaleTypes, YTooltip, Zoom, type ZoomProps, type ZoomSettings, autoScale, createSequentialScheme, debounce, defaultDasharrays, defaultScheme, defineGroupAccessor, elongate, fillScaleState, focusNodes, formatDate, formatMissing, formatMonth, generateID, getYAlongPath, isDate, labelsState, nodeToString, parseDate, radiusScaleState, strokeDasharrayState, strokeScaleState, themeState, tooltipState, unfocusNodes, useGG, useUnZoom, widen, xScaleState, yScaleState, zoomState };