## API Report File for "@fluentui/react-charting"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { FocusZoneDirection } from '@fluentui/react-focus';
import { ICalloutContentStyleProps } from '@fluentui/react/lib/Callout';
import { ICalloutContentStyles } from '@fluentui/react/lib/Callout';
import { ICalloutProps } from '@fluentui/react/lib/Callout';
import { IFocusZoneProps } from '@fluentui/react-focus';
import { IHoverCardStyleProps } from '@fluentui/react/lib/HoverCard';
import { IHoverCardStyles } from '@fluentui/react/lib/HoverCard';
import { IOverflowSetProps } from '@fluentui/react/lib/OverflowSet';
import { IRefObject } from '@fluentui/react/lib/Utilities';
import { IRenderFunction } from '@fluentui/react/lib/Utilities';
import { IStyle } from '@fluentui/react/lib/Styling';
import { IStyle as IStyle_2 } from '@fluentui/react';
import { IStyleFunctionOrObject } from '@fluentui/react/lib/Utilities';
import { IStyleFunctionOrObject as IStyleFunctionOrObject_2 } from '@fluentui/react';
import { ITheme } from '@fluentui/react/lib/Styling';
import { ITheme as ITheme_2 } from '@fluentui/react';
import * as React_2 from 'react';
import { SankeyLink } from 'd3-sankey';
import { SankeyNode } from 'd3-sankey';
import { ScaleBand } from 'd3-scale';
import { ScaleLinear } from 'd3-scale';
import { TimeLocaleDefinition } from 'd3-time-format';

// @public
export const AreaChart: React_2.FunctionComponent<IAreaChartProps>;

// @public
export const CartesianChart: React_2.FunctionComponent<IModifiedCartesianChartProps>;

// @public
export type ChartDataMode = 'default' | 'fraction' | 'percentage';

// @public (undocumented)
export const ChartHoverCard: React_2.FunctionComponent<IChartHoverCardProps>;

// @public (undocumented)
export const DataVizGradientPalette: {
    gradient1: string;
    gradient2: string;
    gradient3: string;
    gradient4: string;
    gradient5: string;
    gradient6: string;
    gradient7: string;
    gradient8: string;
    gradient9: string;
    gradient10: string;
    gradient1Ext: string;
    gradient2Ext: string;
    gradient3Ext: string;
    gradient4Ext: string;
    gradient5Ext: string;
    gradient6Ext: string;
    gradient7Ext: string;
    gradient8Ext: string;
    gradient9Ext: string;
    gradient10Ext: string;
    success: string;
    highSuccess: string;
    warning: string;
    error: string;
    highError: string;
    disabled: string;
};

// @public (undocumented)
export const DataVizPalette: {
    color1: string;
    color2: string;
    color3: string;
    color4: string;
    color5: string;
    color6: string;
    color7: string;
    color8: string;
    color9: string;
    color10: string;
    color11: string;
    color12: string;
    color13: string;
    color14: string;
    color15: string;
    color16: string;
    color17: string;
    color18: string;
    color19: string;
    color20: string;
    color21: string;
    color22: string;
    color23: string;
    color24: string;
    color25: string;
    color26: string;
    color27: string;
    color28: string;
    color29: string;
    color30: string;
    color31: string;
    color32: string;
    color33: string;
    color34: string;
    color35: string;
    color36: string;
    color37: string;
    color38: string;
    color39: string;
    color40: string;
    info: string;
    disabled: string;
    highError: string;
    error: string;
    warning: string;
    success: string;
    highSuccess: string;
};

// @public
export const DeclarativeChart: React_2.FunctionComponent<DeclarativeChartProps>;

// @public
export interface DeclarativeChartProps extends React_2.RefAttributes<HTMLDivElement> {
    chartSchema: Schema;
    componentRef?: IRefObject<IDeclarativeChart>;
    onSchemaChange?: (eventData: Schema) => void;
}

// @public
export const DonutChart: React_2.FunctionComponent<IDonutChartProps>;

// @public
export const GaugeChart: React_2.FunctionComponent<IGaugeChartProps>;

// @public (undocumented)
export enum GaugeChartVariant {
    // (undocumented)
    MultipleSegments = "multiple-segments",
    // (undocumented)
    SingleSegment = "single-segment"
}

// @public (undocumented)
export enum GaugeValueFormat {
    // (undocumented)
    Fraction = "fraction",
    // (undocumented)
    Percentage = "percentage"
}

// @public (undocumented)
export const getChartHoverCardStyles: (props: IChartHoverCardStyleProps) => IChartHoverCardStyles;

// @public (undocumented)
export const getColorFromToken: (token: string, isDarkTheme?: boolean) => string;

// @public (undocumented)
export const getGradientFromToken: (token: string, isDarkTheme?: boolean) => [string, string];

// @public (undocumented)
export const getNextColor: (index: number, offset?: number, isDarkTheme?: boolean) => string;

// @public (undocumented)
export const getNextGradient: (index: number, offset?: number, isDarkTheme?: boolean) => [string, string];

// @public
export const GroupedVerticalBarChart: React_2.FunctionComponent<IGroupedVerticalBarChartProps>;

// @public
export const HeatMapChart: React_2.FunctionComponent<IHeatMapChartProps>;

// @public
export const HorizontalBarChart: React_2.FunctionComponent<IHorizontalBarChartProps>;

// @public (undocumented)
export enum HorizontalBarChartVariant {
    // (undocumented)
    AbsoluteScale = "absolute-scale",
    // (undocumented)
    PartToWhole = "part-to-whole"
}

// @public
export const HorizontalBarChartWithAxis: React_2.FunctionComponent<IHorizontalBarChartWithAxisProps>;

// @public (undocumented)
export interface IAccessibilityProps {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
}

// @public
export interface IAreaChartProps extends ICartesianChartProps {
    culture?: string;
    data: IChartProps;
    enableGradient?: boolean;
    enablePerfOptimization?: boolean;
    mode?: 'tozeroy' | 'tonexty';
    onRenderCalloutPerDataPoint?: IRenderFunction<ICustomizedCalloutData>;
    onRenderCalloutPerStack?: IRenderFunction<ICustomizedCalloutData>;
    // (undocumented)
    optimizeLargeData?: boolean;
    // @deprecated
    showYAxisGridLines?: boolean;
    styles?: IStyleFunctionOrObject<ICartesianChartStyleProps, ICartesianChartStyles>;
}

// @public
export interface IAreaChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface IAreaChartStyles extends ICartesianChartStyles {
}

// @public (undocumented)
export interface IBasestate {
    // (undocumented)
    activeLegend?: string;
    // (undocumented)
    color?: string;
    // (undocumented)
    containerHeight?: number;
    // (undocumented)
    containerWidth?: number;
    // (undocumented)
    dataForHoverCard?: number;
    // (undocumented)
    _height?: number;
    // (undocumented)
    hoveredLineColor?: string;
    // (undocumented)
    hoverXValue?: string | number | null;
    // (undocumented)
    hoverYValue?: string | number | null;
    // (undocumented)
    isCalloutVisible: boolean;
    // (undocumented)
    isLegendHovered?: boolean;
    // (undocumented)
    isLegendSelected?: boolean;
    // (undocumented)
    lineColor?: string;
    // (undocumented)
    refSelected?: any;
    // (undocumented)
    selectedLegend?: string;
    // (undocumented)
    _width?: number;
    // (undocumented)
    xCalloutValue?: string;
    // (undocumented)
    yCalloutValue?: string;
    // (undocumented)
    YValueHover?: {
        legend?: string;
        y?: number;
        color?: string;
    }[];
}

// @public
export interface ICartesianChartProps {
    calloutProps?: Partial<ICalloutProps>;
    // @deprecated
    chartLabel?: string;
    className?: string;
    componentRef?: IRefObject<IChart>;
    customDateTimeFormatter?: (dateTime: Date) => string;
    dateLocalizeOptions?: Intl.DateTimeFormatOptions;
    enabledLegendsWrapLines?: boolean;
    enableReflow?: boolean;
    focusZonePropsForLegendsInHoverCard?: IFocusZoneProps;
    height?: number;
    hideLegend?: boolean;
    hideTickOverlap?: boolean;
    hideTooltip?: boolean;
    href?: string;
    // (undocumented)
    legendProps?: Partial<ILegendsProps>;
    legendsOverflowProps?: Partial<IOverflowSetProps>;
    // (undocumented)
    legendsOverflowText?: any;
    margins?: IMargins;
    noOfCharsToTruncate?: number;
    parentRef?: HTMLElement | null;
    rotateXAxisLables?: boolean;
    roundedTicks?: boolean;
    secondaryYAxistitle?: string;
    secondaryYScaleOptions?: {
        yMinValue?: number;
        yMaxValue?: number;
    };
    showXAxisLablesTooltip?: boolean;
    strokeWidth?: number;
    styles?: IStyleFunctionOrObject<ICartesianChartStyleProps, ICartesianChartStyles>;
    supportNegativeData?: boolean;
    svgProps?: React_2.SVGProps<SVGSVGElement>;
    theme?: ITheme;
    tickFormat?: string;
    tickPadding?: number;
    tickValues?: number[] | Date[] | string[];
    timeFormatLocale?: TimeLocaleDefinition;
    useUTC?: boolean;
    width?: number;
    wrapXAxisLables?: boolean;
    xAxisTickCount?: number;
    xAxisTickPadding?: number;
    xAxistickSize?: number;
    xAxisTitle?: string;
    xMaxValue?: number;
    yAxisTickCount?: number;
    yAxisTickFormat?: any;
    yAxisTitle?: string;
    yMaxValue?: number;
    yMinValue?: number;
}

// @public
export interface ICartesianChartStyleProps {
    className?: string;
    color?: string;
    enableReflow?: boolean;
    height?: number;
    href?: string;
    isRtl?: boolean;
    lineColor?: string;
    shouldHighlight?: boolean;
    theme: ITheme;
    toDrawShape?: boolean;
    width?: number;
}

// @public
export interface ICartesianChartStyles {
    axisTitle?: IStyle;
    calloutBlockContainer?: IStyle;
    calloutContentRoot?: IStyle;
    calloutContentX?: IStyle;
    calloutContentY?: IStyle;
    calloutDateTimeContainer?: IStyle;
    calloutInfoContainer?: IStyle;
    calloutlegendText?: IStyle;
    chartTitle?: IStyle;
    chartWrapper?: IStyle;
    descriptionMessage?: IStyle;
    hover?: IStyle;
    legendContainer?: IStyle;
    opacityChangeOnHover?: IStyle;
    root?: IStyle;
    shapeStyles?: IStyle;
    tooltip?: IStyle;
    xAxis?: IStyle;
    yAxis?: IStyle;
}

// @public (undocumented)
export interface IChart {
    // (undocumented)
    chartContainer: HTMLElement | null;
    // (undocumented)
    toImage?: (opts?: IImageExportOptions) => Promise<string>;
}

// @public (undocumented)
export interface IChartDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    color?: string;
    data?: number;
    gradient?: [string, string];
    horizontalBarChartdata?: IHorizontalDataPoint;
    legend?: string;
    onClick?: VoidFunction;
    placeHolder?: boolean;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

// @public (undocumented)
export interface IChartHoverCardProps {
    color?: string;
    culture?: string;
    descriptionMessage?: string;
    Legend?: string | number | Date;
    ratio?: [number, number];
    styles?: IStyleFunctionOrObject_2<IChartHoverCardStyleProps, IChartHoverCardStyles>;
    theme?: ITheme_2;
    XValue?: string;
    YValue?: string | number | Date;
}

// @public (undocumented)
export interface IChartHoverCardStyleProps {
    color?: string;
    isRatioPresent?: boolean;
    theme: ITheme_2;
    XValue?: string;
}

// @public (undocumented)
export interface IChartHoverCardStyles {
    calloutBlockContainer?: IStyle_2;
    calloutContentRoot?: IStyle_2;
    calloutContentX?: IStyle_2;
    calloutContentY?: IStyle_2;
    calloutDateTimeContainer?: IStyle_2;
    calloutInfoContainer?: IStyle_2;
    calloutlegendText?: IStyle_2;
    denominator?: IStyle_2;
    descriptionMessage?: IStyle_2;
    numerator?: IStyle_2;
    ratio?: IStyle_2;
}

// @public (undocumented)
export interface IChartProps {
    chartData?: IChartDataPoint[];
    chartDataAccessibilityData?: IAccessibilityProps;
    chartTitle?: string;
    chartTitleAccessibilityData?: IAccessibilityProps;
    lineChartData?: ILineChartPoints[];
    pointLineOptions?: React_2.SVGProps<SVGLineElement>;
    pointOptions?: React_2.SVGProps<SVGCircleElement>;
    SankeyChartData?: ISankeyChartData;
}

// @public (undocumented)
export interface IChildProps {
    // (undocumented)
    containerHeight?: number;
    // (undocumented)
    containerWidth?: number;
    // (undocumented)
    xScale?: any;
    // (undocumented)
    yScale?: any;
    // (undocumented)
    yScaleSecondary?: any;
}

// @public (undocumented)
export interface IColorFillBarData {
    // (undocumented)
    endX: number | Date;
    // (undocumented)
    startX: number | Date;
}

// @public (undocumented)
export interface IColorFillBarsProps {
    // (undocumented)
    applyPattern?: boolean;
    // (undocumented)
    color: string;
    // (undocumented)
    data: IColorFillBarData[];
    // (undocumented)
    legend: string;
    // (undocumented)
    onLegendClick?: (selectedLegend: string | string[] | null) => void | undefined;
}

// @public
export interface ICustomizedCalloutData {
    // (undocumented)
    values: ICustomizedCalloutDataPoint[];
    // (undocumented)
    x: number | string | Date;
}

// @public (undocumented)
export interface ICustomizedCalloutDataPoint {
    // (undocumented)
    color: string;
    // (undocumented)
    legend: string;
    // (undocumented)
    xAxisCalloutData?: string;
    // (undocumented)
    y: number;
    // (undocumented)
    yAxisCalloutData?: string | {
        [id: string]: number;
    };
}

// @public (undocumented)
export interface IDataPoint {
    onClick?: VoidFunction;
    x: number | string;
    y: number;
}

// @public (undocumented)
export interface IDeclarativeChart {
    // (undocumented)
    exportAsImage: (opts?: IImageExportOptions) => Promise<string>;
}

// @public (undocumented)
export interface IDonutChart {
}

// @public
export interface IDonutChartProps extends ICartesianChartProps {
    calloutProps?: Partial<ICalloutProps>;
    componentRef?: IRefObject<IChart>;
    culture?: string;
    data?: IChartProps;
    enableGradient?: boolean;
    hideLabels?: boolean;
    innerRadius?: number;
    onRenderCalloutPerDataPoint?: IRenderFunction<IChartDataPoint>;
    roundCorners?: boolean;
    showLabelsInPercent?: boolean;
    styles?: IStyleFunctionOrObject<IDonutChartStyleProps, IDonutChartStyles>;
    valueInsideDonut?: string | number;
}

// @public
export interface IDonutChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface IDonutChartStyles {
    chart?: IStyle;
    legendContainer: IStyle;
    root?: IStyle;
}

// @public (undocumented)
export interface IEventsAnnotationProps {
    // Warning: (ae-forgotten-export) The symbol "IEventAnnotation" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    events: IEventAnnotation[];
    // (undocumented)
    labelColor?: string;
    // (undocumented)
    labelHeight?: number;
    // (undocumented)
    labelWidth?: number;
    // (undocumented)
    mergedLabel: (count: number) => string;
    // (undocumented)
    strokeColor?: string;
}

// @public
export interface IGaugeChartProps {
    calloutProps?: Partial<ICalloutProps>;
    chartTitle?: string;
    chartValue: number;
    chartValueFormat?: GaugeValueFormat | ((sweepFraction: [number, number]) => string);
    className?: string;
    componentRef?: IRefObject<IChart>;
    culture?: string;
    enableGradient?: boolean;
    height?: number;
    hideLegend?: boolean;
    hideMinMax?: boolean;
    hideTooltip?: boolean;
    // (undocumented)
    legendProps?: Partial<ILegendsProps>;
    maxValue?: number;
    minValue?: number;
    roundCorners?: boolean;
    segments: IGaugeChartSegment[];
    styles?: IStyleFunctionOrObject<IGaugeChartStyleProps, IGaugeChartStyles>;
    sublabel?: string;
    theme?: ITheme;
    variant?: GaugeChartVariant;
    width?: number;
}

// @public
export interface IGaugeChartSegment {
    accessibilityData?: IAccessibilityProps;
    color?: string;
    gradient?: [string, string];
    legend: string;
    size: number;
}

// @public
export interface IGaugeChartStyleProps {
    chartHeight?: number;
    chartValueSize?: number;
    chartWidth?: number;
    className?: string;
    gradientFill?: string;
    lineColor?: string;
    opacity?: number;
    solidFill?: string;
    theme: ITheme;
    toDrawShape?: boolean;
}

// @public
export interface IGaugeChartStyles {
    calloutBlockContainer?: IStyle;
    calloutContentRoot?: IStyle;
    calloutContentX?: IStyle;
    calloutContentY?: IStyle;
    calloutDateTimeContainer?: IStyle;
    calloutInfoContainer?: IStyle;
    calloutlegendText?: IStyle;
    chart?: IStyle;
    chartTitle?: IStyle;
    chartValue?: IStyle;
    descriptionMessage?: IStyle;
    gradientSegment?: IStyle;
    legendsContainer?: IStyle;
    limits?: IStyle;
    needle?: IStyle;
    root?: IStyle;
    segment?: IStyle;
    shapeStyles?: IStyle;
    sublabel?: IStyle;
}

// @public (undocumented)
export interface IGroupedVerticalBarChartData {
    name: string;
    series: IGVBarChartSeriesPoint[];
    stackCallOutAccessibilityData?: IAccessibilityProps;
}

// @public
export interface IGroupedVerticalBarChartProps extends ICartesianChartProps {
    barwidth?: number | 'default' | 'auto';
    chartTitle?: string;
    culture?: string;
    data: IGroupedVerticalBarChartData[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    isCalloutForStack?: boolean;
    // @deprecated
    legendColor?: string;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly';
    onRenderCalloutPerDataPoint?: IRenderFunction<IGVBarChartSeriesPoint>;
    roundCorners?: boolean;
    // @deprecated
    showXAxisGridLines?: boolean;
    // @deprecated
    showXAxisPath?: boolean;
    // @deprecated
    showYAxisGridLines?: boolean;
    // @deprecated
    showYAxisPath?: boolean;
    styles?: IStyleFunctionOrObject<IGroupedVerticalBarChartStyleProps, IGroupedVerticalBarChartStyles>;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
}

// @public
export interface IGroupedVerticalBarChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface IGroupedVerticalBarChartStyles extends ICartesianChartStyles {
    barLabel: IStyle;
    opacityChangeOnHover: IStyle;
}

// @public (undocumented)
export interface IGVBarChartSeriesPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    color: string;
    data: number;
    gradient?: [string, string];
    key: string;
    legend: string;
    onClick?: VoidFunction;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

// @public (undocumented)
export interface IGVDataPoint {
    [key: string]: number | string;
}

// @public (undocumented)
export interface IGVForBarChart {
    [key: string]: IGVBarChartSeriesPoint;
}

// @public (undocumented)
export interface IGVSingleDataPoint {
    [key: string]: IGVDataPoint;
}

// @public (undocumented)
export interface IHeatMapChartData {
    // (undocumented)
    data: IHeatMapChartDataPoint[];
    legend: string;
    value: number;
}

// @public (undocumented)
export interface IHeatMapChartDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    descriptionMessage?: string;
    onClick?: VoidFunction;
    ratio?: [number, number];
    rectText?: string | number;
    // (undocumented)
    value: number;
    // (undocumented)
    x: string | Date | number;
    // (undocumented)
    y: string | Date | number;
}

// @public
export interface IHeatMapChartProps extends Pick<ICartesianChartProps, Exclude<keyof ICartesianChartProps, 'styles'>> {
    chartTitle?: string;
    culture?: string;
    data: IHeatMapChartData[];
    domainValuesForColorScale: number[];
    legendProps?: Partial<ILegendsProps>;
    rangeValuesForColorScale: string[];
    showYAxisLables?: boolean;
    sortOrder?: 'none' | 'alphabetical';
    styles?: IStyleFunctionOrObject<IHeatMapChartStyleProps, IHeatMapChartStyles>;
    xAxisDateFormatString?: string;
    xAxisNumberFormatString?: string;
    xAxisStringFormatter?: (point: string) => string;
    yAxisDateFormatString?: string;
    yAxisNumberFormatString?: string;
    yAxisStringFormatter?: (point: string) => string;
}

// @public
export interface IHeatMapChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface IHeatMapChartStyles {
    // (undocumented)
    root?: IStyle;
    // (undocumented)
    subComponentStyles: {
        cartesianStyles: IStyleFunctionOrObject<ICartesianChartStyleProps, ICartesianChartStyles>;
        calloutStyles: IStyleFunctionOrObject<ICalloutContentStyleProps, ICalloutContentStyles>;
    };
    // (undocumented)
    text?: IStyle;
}

// @public
export interface IHorizontalBarChartProps {
    barChartCustomData?: IRenderFunction<IChartProps>;
    barHeight?: number;
    calloutProps?: Partial<ICalloutProps>;
    chartDataMode?: ChartDataMode;
    className?: string;
    culture?: string;
    data?: IChartProps[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    hideRatio?: boolean[];
    hideTooltip?: boolean;
    onRenderCalloutPerHorizontalBar?: IRenderFunction<IChartDataPoint>;
    roundCorners?: boolean;
    styles?: IStyleFunctionOrObject<IHorizontalBarChartStyleProps, IHorizontalBarChartStyles>;
    theme?: ITheme;
    variant?: HorizontalBarChartVariant;
    width?: number;
}

// @public
export interface IHorizontalBarChartStyleProps {
    barHeight?: number;
    className?: string;
    color?: string;
    hideLabels?: boolean;
    showTriangle?: boolean;
    theme: ITheme;
    variant?: HorizontalBarChartVariant;
    width: number | undefined;
}

// @public
export interface IHorizontalBarChartStyles {
    barLabel: IStyle;
    barWrapper: IStyle;
    benchmarkContainer: IStyle;
    chart: IStyle;
    chartDataTextDenominator: IStyle;
    chartTitle: IStyle;
    chartTitleLeft: IStyle;
    chartTitleRight: IStyle;
    chartWrapper: IStyle;
    items: IStyle;
    root: IStyle;
    triangle: IStyle;
}

// @public (undocumented)
export interface IHorizontalBarChartWithAxisDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    color?: string;
    gradient?: [string, string];
    legend?: string;
    onClick?: VoidFunction;
    x: number;
    xAxisCalloutData?: string;
    y: number | string;
    yAxisCalloutData?: string;
}

// @public
export interface IHorizontalBarChartWithAxisProps extends ICartesianChartProps {
    barHeight?: number;
    chartTitle?: string;
    colors?: string[];
    culture?: string;
    data?: IHorizontalBarChartWithAxisDataPoint[];
    enableGradient?: boolean;
    onRenderCalloutPerDataPoint?: IRenderFunction<IHorizontalBarChartWithAxisDataPoint>;
    roundCorners?: boolean;
    showYAxisLables?: boolean;
    showYAxisLablesTooltip?: boolean;
    styles?: IStyleFunctionOrObject<IHorizontalBarChartWithAxisStyleProps, IHorizontalBarChartWithAxisStyles>;
    useSingleColor?: boolean;
    yAxisPadding?: number;
}

// @public
export interface IHorizontalBarChartWithAxisStyleProps extends ICartesianChartStyleProps {
    legendColor?: string;
}

// @public
export interface IHorizontalBarChartWithAxisStyles extends ICartesianChartStyles {
    chartLabel?: IStyle;
    opacityChangeOnHover: IStyle;
    xAxisDomain?: IStyle;
    xAxisText?: IStyle;
    xAxisTicks?: IStyle;
    yAxisDomain?: IStyle;
    yAxisText?: IStyle;
    yAxisTicks?: IStyle;
}

// @public (undocumented)
export interface IHorizontalDataPoint {
    x: number;
    y: number;
}

// @public (undocumented)
export interface IImageExportOptions {
    // (undocumented)
    background?: string;
    // (undocumented)
    height?: number;
    // (undocumented)
    scale?: number;
    // (undocumented)
    width?: number;
}

// @public
export interface ILegend {
    action?: VoidFunction;
    color: string;
    hoverAction?: VoidFunction;
    isLineLegendInBarChart?: boolean;
    // (undocumented)
    nativeButtonProps?: React_2.ButtonHTMLAttributes<HTMLButtonElement>;
    onMouseOutAction?: (isLegendFocused?: boolean) => void;
    opacity?: number;
    shape?: LegendShape;
    stripePattern?: boolean;
    title: string;
}

// @public (undocumented)
export interface ILegendDataItem {
    legendColor: string;
    legendText: string | number;
}

// @public (undocumented)
export interface ILegendOverflowData {
    // (undocumented)
    overflow?: ILegend[];
    // (undocumented)
    primary: ILegend[];
}

// @public
export interface ILegendsProps {
    allowFocusOnLegends?: boolean;
    canSelectMultipleLegends?: boolean;
    centerLegends?: boolean;
    className?: string;
    defaultSelectedLegend?: string;
    defaultSelectedLegends?: string[];
    enabledWrapLines?: boolean;
    focusZonePropsInHoverCard?: IFocusZoneProps;
    legends: ILegend[];
    onChange?: (selectedLegends: string[], event: React_2.MouseEvent<HTMLButtonElement>, currentLegend?: ILegend) => void;
    onLegendHoverCardLeave?: VoidFunction;
    overflowProps?: Partial<IOverflowSetProps>;
    overflowText?: string;
    // Warning: (ae-forgotten-export) The symbol "ILegendContainer" needs to be exported by the entry point index.d.ts
    ref?: IRefObject<ILegendContainer>;
    selectedLegend?: string;
    selectedLegends?: string[];
    shape?: LegendShape;
    styles?: IStyleFunctionOrObject<ILegendStyleProps, ILegendsStyles>;
    theme?: ITheme;
}

// @public
export interface ILegendsStyles {
    hoverCardRoot: IStyle;
    hoverChange: IStyle;
    legend: IStyle;
    overflowIndicationTextStyle: IStyle;
    rect: IStyle;
    root: IStyle;
    shape: IStyle;
    subComponentStyles: ILegendSubComponentStyles;
    text: IStyle;
    triangle: IStyle;
}

// @public
export interface ILegendStyleProps {
    // (undocumented)
    borderColor?: string;
    // (undocumented)
    className?: string;
    // (undocumented)
    colorOnSelectedState?: string;
    // (undocumented)
    isLineLegendInBarChart?: boolean;
    // (undocumented)
    opacity?: number;
    // (undocumented)
    overflow?: boolean;
    // (undocumented)
    stripePattern?: boolean;
    // (undocumented)
    theme?: ITheme;
}

// @public (undocumented)
export interface ILegendSubComponentStyles {
    // (undocumented)
    hoverCardStyles: IStyleFunctionOrObject<IHoverCardStyleProps, IHoverCardStyles>;
}

// @public (undocumented)
export interface ILineChartDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    hideCallout?: boolean;
    markerSize?: number;
    onDataPointClick?: () => void;
    x: number | Date;
    xAxisCalloutAccessibilityData?: IAccessibilityProps;
    xAxisCalloutData?: string;
    y: number;
    yAxisCalloutData?: string | {
        [id: string]: number;
    };
}

// @public (undocumented)
export interface ILineChartGap {
    endIndex: number;
    startIndex: number;
}

// @public (undocumented)
export interface ILineChartLineOptions extends React_2.SVGProps<SVGPathElement> {
    lineBorderColor?: string;
    lineBorderWidth?: string | number;
    strokeDasharray?: string | number;
    strokeDashoffset?: string | number;
    strokeLinecap?: 'butt' | 'round' | 'square' | 'inherit';
    strokeWidth?: number | string;
}

// @public (undocumented)
export interface ILineChartPoints {
    color?: string;
    data: ILineChartDataPoint[];
    gaps?: ILineChartGap[];
    hideNonActiveDots?: boolean;
    legend: string;
    legendShape?: LegendShape;
    lineOptions?: ILineChartLineOptions;
    onLegendClick?: (selectedLegend: string | null | string[]) => void;
    onLineClick?: () => void;
    opacity?: number;
}

// @public
export interface ILineChartProps extends ICartesianChartProps {
    allowMultipleShapesForPoints?: boolean;
    // (undocumented)
    colorFillBars?: IColorFillBarsProps[];
    culture?: string;
    data: IChartProps;
    enablePerfOptimization?: boolean;
    eventAnnotationProps?: IEventsAnnotationProps;
    getCalloutDescriptionMessage?: (calloutDataProps: ICustomizedCalloutData) => string | undefined;
    lineMode?: 'default' | 'scatter';
    onRenderCalloutPerDataPoint?: IRenderFunction<ICustomizedCalloutData>;
    onRenderCalloutPerStack?: IRenderFunction<ICustomizedCalloutData>;
    // (undocumented)
    optimizeLargeData?: boolean;
    styles?: IStyleFunctionOrObject<ILineChartStyleProps, ILineChartStyles>;
}

// @public
export interface ILineChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface ILineChartStyles extends ICartesianChartStyles {
}

// @public (undocumented)
export interface ILineDataInVerticalBarChart {
    onClick?: VoidFunction;
    useSecondaryYScale?: boolean;
    // (undocumented)
    y: IVerticalBarChartDataPoint['y'];
    // (undocumented)
    yAxisCalloutData?: string | undefined;
}

// @public (undocumented)
export interface ILineDataInVerticalStackedBarChart {
    // (undocumented)
    color: string;
    data?: number;
    // (undocumented)
    legend: string;
    lineOptions?: ILineChartLineOptions;
    useSecondaryYScale?: boolean;
    // (undocumented)
    y: number;
    // (undocumented)
    yAxisCalloutData?: string;
}

// @public (undocumented)
export interface IMargins {
    bottom?: number;
    left?: number;
    right?: number;
    top?: number;
}

// @public (undocumented)
export interface IModifiedCartesianChartProps extends ICartesianChartProps {
    barwidth?: number;
    calloutProps: Partial<ICalloutProps> & {
        isCalloutVisible: boolean;
        id: string;
        YValueHover?: IYValueHover[];
        hoverXValue?: string | number | null;
        legend?: string;
        color?: string;
        YValue?: string | number;
        XValue?: string;
        descriptionMessage?: string;
    };
    chartHoverProps?: IChartHoverCardProps;
    chartTitle?: string;
    // Warning: (ae-forgotten-export) The symbol "ChartTypes" needs to be exported by the entry point index.d.ts
    chartType: ChartTypes;
    children(props: IChildProps): React_2.ReactNode;
    createStringYAxis: (yAxisParams: IYAxisParams, dataPoints: string[], isRtl: boolean, barWidth: number | undefined) => ScaleBand<string>;
    // Warning: (ae-forgotten-export) The symbol "IYAxisParams" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "IAxisData" needs to be exported by the entry point index.d.ts
    createYAxis: (yAxisParams: IYAxisParams, isRtl: boolean, axisData: IAxisData, isIntegralDataset: boolean, useSecondaryYScale?: boolean, supportNegativeData?: boolean, roundedTicks?: boolean) => ScaleLinear<number, number, never>;
    culture?: string;
    customizedCallout?: any;
    datasetForXAxisDomain?: string[];
    enableFirstRenderOptimization?: boolean;
    focusZoneDirection?: FocusZoneDirection;
    // (undocumented)
    getAxisData?: any;
    getDomainMargins?: (containerWidth: number) => IMargins;
    // Warning: (ae-forgotten-export) The symbol "IDomainNRange" needs to be exported by the entry point index.d.ts
    getDomainNRangeValues: (points: ILineChartPoints[] | IVerticalBarChartDataPoint[] | IVerticalStackedBarDataPoint[] | IHorizontalBarChartWithAxisDataPoint[] | IGroupedVerticalBarChartData[] | IHeatMapChartDataPoint[], margins: IMargins, width: number, chartType: ChartTypes, isRTL: boolean, xAxisType: XAxisTypes, barWidth: number, tickValues: Date[] | number[] | string[] | undefined, shiftX: number) => IDomainNRange;
    getGraphData?: any;
    getmargins?: (margins: IMargins) => void;
    getMinMaxOfYAxis: (points: ILineChartPoints[] | IHorizontalBarChartWithAxisDataPoint[] | IVerticalBarChartDataPoint[] | IDataPoint[], yAxisType: YAxisType | undefined) => {
        startValue: number;
        endValue: number;
    };
    isCalloutForStack?: boolean;
    legendBars: JSX.Element | null;
    maxOfYVal?: number;
    onChartMouseLeave?: () => void;
    points: any;
    ref?: IRefObject<IChart>;
    showYAxisLables?: boolean;
    showYAxisLablesTooltip?: boolean;
    stringDatasetForYAxisDomain?: string[];
    svgFocusZoneProps?: IFocusZoneProps;
    tickParams?: {
        tickValues?: number[] | Date[] | string[];
        tickFormat?: string;
    };
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
    // Warning: (ae-forgotten-export) The symbol "XAxisTypes" needs to be exported by the entry point index.d.ts
    xAxisType: XAxisTypes;
    yAxisPadding?: number;
    // Warning: (ae-forgotten-export) The symbol "YAxisType" needs to be exported by the entry point index.d.ts
    yAxisType?: YAxisType;
}

// @public
export interface IMultiStackedBarChartProps {
    barHeight?: number;
    calloutProps?: Partial<ICalloutProps>;
    className?: string;
    culture?: string;
    data?: IChartProps[];
    enableGradient?: boolean;
    focusZonePropsForLegendsInHoverCard?: IFocusZoneProps;
    hideDenominator?: boolean[];
    hideLabels?: boolean;
    hideLegend?: boolean;
    hideRatio?: boolean[];
    hideTooltip?: boolean;
    href?: string;
    legendProps?: Partial<ILegendsProps>;
    legendsOverflowProps?: Partial<IOverflowSetProps>;
    legendsOverflowText?: string;
    onRenderCalloutPerDataPoint?: IRenderFunction<IChartDataPoint>;
    roundCorners?: boolean;
    styles?: IStyleFunctionOrObject<IMultiStackedBarChartStyleProps, IMultiStackedBarChartStyles>;
    theme?: ITheme;
    variant?: MultiStackedBarChartVariant;
    width?: number;
}

// @public
export interface IMultiStackedBarChartStyleProps {
    barHeight?: number;
    className?: string;
    hideLabels?: boolean;
    href?: string;
    legendColor?: string;
    shouldHighlight?: boolean;
    theme: ITheme;
    variant?: MultiStackedBarChartVariant;
    width?: number;
}

// @public
export interface IMultiStackedBarChartStyles {
    barLabel: IStyle;
    chart: IStyle;
    chartTitle: IStyle;
    chartTitleLeft: IStyle;
    chartWrapper: IStyle;
    items: IStyle;
    legendContainer: IStyle;
    noData: IStyle;
    opacityChangeOnHover: IStyle;
    placeHolderOnHover: IStyle;
    ratioDenominator: IStyle;
    ratioNumerator: IStyle;
    root: IStyle;
    singleChartRoot: IStyle;
}

// @public (undocumented)
export interface IPieChart {
}

// @public
export interface IPieChartProps {
    chartTitle?: string;
    className?: string;
    colors?: string[];
    culture?: string;
    data?: IDataPoint[];
    height?: number;
    strokeWidth?: number;
    styles?: IStyleFunctionOrObject<IPieChartStyleProps, IPieChartStyles>;
    theme?: ITheme;
    width?: number;
}

// @public
export type IPieChartStyleProps = Required<Pick<IPieChartProps, 'theme' | 'width' | 'height'>> & Pick<IPieChartProps, 'className'>;

// @public
export interface IPieChartStyles {
    chart?: IStyle;
    chartTitle?: IStyle;
    root?: IStyle;
}

// @public (undocumented)
export interface IRefArrayData {
    // (undocumented)
    index?: string;
    // (undocumented)
    refElement?: SVGGElement;
}

// @public
export interface IResponsiveChildProps {
    // (undocumented)
    height?: number;
    // (undocumented)
    shouldResize?: number;
    // (undocumented)
    styles?: IStyleFunctionOrObject_2<{}, {
        root: IStyle_2;
    }>;
    // (undocumented)
    width?: number;
}

// @public
export interface IResponsiveContainerProps {
    aspect?: number;
    children: React_2.ReactElement<IResponsiveChildProps>;
    height?: number | string;
    maxHeight?: number;
    minHeight?: number | string;
    minWidth?: number | string;
    onResize?: (width: number, height: number) => void;
    width?: number | string;
}

// @public
export interface ISankeyChartAccessibilityProps {
    emptyAriaLabel?: string;
    linkAriaLabel?: string;
    nodeAriaLabel?: string;
}

// @public (undocumented)
export interface ISankeyChartData {
    // (undocumented)
    links: SLink[];
    // (undocumented)
    nodes: SNode[];
}

// @public
export interface ISankeyChartProps {
    accessibility?: ISankeyChartAccessibilityProps;
    borderColorsForNodes?: string[];
    calloutProps?: Partial<ICalloutProps>;
    className?: string;
    colorsForNodes?: string[];
    componentRef?: IRefObject<IChart>;
    data: IChartProps;
    enableReflow?: boolean;
    formatNumberOptions?: Intl.NumberFormatOptions;
    height?: number;
    parentRef?: HTMLElement | null;
    pathColor?: string;
    shouldResize?: number;
    strings?: ISankeyChartStrings;
    styles?: IStyleFunctionOrObject<ISankeyChartStyleProps, ISankeyChartStyles>;
    theme?: ITheme;
    width?: number;
}

// @public
export interface ISankeyChartStrings {
    linkFrom?: string;
}

// @public
export interface ISankeyChartStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    enableReflow?: boolean;
    // (undocumented)
    height: number;
    // (undocumented)
    pathColor?: string;
    // (undocumented)
    theme: ITheme;
    // (undocumented)
    width: number;
}

// @public
export interface ISankeyChartStyles {
    calloutContentRoot?: IStyle;
    chartWrapper?: IStyle;
    links?: IStyle;
    nodes?: IStyle;
    nodeTextContainer?: IStyle;
    root?: IStyle;
    toolTip?: IStyle;
}

// @public (undocumented)
export interface IShapeProps {
    // (undocumented)
    classNameForNonSvg?: string;
    // (undocumented)
    pathProps: React_2.SVGAttributes<SVGPathElement>;
    // (undocumented)
    shape: LegendShape;
    // (undocumented)
    svgProps: React_2.SVGAttributes<SVGElement>;
}

// @public
export interface ISparklineProps {
    className?: string;
    culture?: string;
    data?: IChartProps;
    height?: number;
    showLegend?: boolean;
    styles?: IStyleFunctionOrObject<ISparklineStyleProps, ISparklineStyles>;
    theme?: ITheme;
    valueTextWidth?: number;
    width?: number;
}

// @public (undocumented)
export interface ISparklineStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface ISparklineStyles {
    // (undocumented)
    inlineBlock?: IStyle;
    // (undocumented)
    valueText?: IStyle;
}

// @public (undocumented)
export interface IStackedBarChart {
}

// @public
export interface IStackedBarChartProps {
    barBackgroundColor?: string;
    barHeight?: number;
    benchmarkData?: IChartDataPoint;
    calloutProps?: Partial<ICalloutProps>;
    className?: string;
    culture?: string;
    data?: IChartProps;
    enabledLegendsWrapLines?: boolean;
    enableGradient?: boolean;
    focusZonePropsForLegendsInHoverCard?: IFocusZoneProps;
    hideDenominator?: boolean;
    hideLegend?: boolean;
    hideNumberDisplay?: boolean;
    hideTooltip?: boolean;
    href?: string;
    ignoreFixStyle?: boolean;
    legendProps?: Partial<ILegendsProps>;
    legendsOverflowProps?: Partial<IOverflowSetProps>;
    legendsOverflowText?: string;
    onRenderCalloutPerDataPoint?: IRenderFunction<IChartDataPoint>;
    roundCorners?: boolean;
    styles?: IStyleFunctionOrObject<IStackedBarChartStyleProps, IStackedBarChartStyles>;
    targetData?: IChartDataPoint;
    theme?: ITheme;
    width?: number;
}

// @public
export interface IStackedBarChartStyleProps {
    barHeight?: number;
    benchmarkColor?: string;
    benchmarkRatio?: number;
    className?: string;
    href?: string;
    isChartSelected?: boolean;
    legendColor?: string;
    shouldHighlight?: boolean;
    showTriangle?: boolean;
    targetColor?: string;
    targetRatio?: number;
    theme: ITheme;
    width?: number;
}

// @public
export interface IStackedBarChartStyles {
    benchmark: IStyle;
    benchmarkContainer: IStyle;
    chart: IStyle;
    chartTitle: IStyle;
    chartTitleLeft: IStyle;
    legendContainer: IStyle;
    opacityChangeOnHover: IStyle;
    ratioDenominator: IStyle;
    ratioNumerator: IStyle;
    root: IStyle;
    target: IStyle;
}

// @public (undocumented)
export interface ITreeChartDataPoint {
    bodytext?: string;
    children?: Array<ITreeChartDataPoint>;
    fill: string;
    metric?: string;
    name: string;
    subname?: string;
}

// @public (undocumented)
export interface ITreeDataStructure {
    bodyText?: string;
    children: Array<ITreeDataStructure>;
    dataName: string;
    fill: string;
    id: number;
    metricName?: string;
    parentID: number;
    subName?: string;
    x: number;
    y: number;
}

// @public
export interface ITreeProps {
    className?: string;
    composition?: NodesComposition.long | NodesComposition.compact;
    height?: number;
    layoutWidth?: number;
    margins?: IMargins;
    styles?: IStyleFunctionOrObject<ITreeStyleProps, ITreeStyles>;
    theme?: ITheme;
    treeData: ITreeChartDataPoint;
    treeTraversal?: TreeTraverse.preOrder | TreeTraverse.levelOrder;
    width?: number;
}

// @public (undocumented)
export interface ITreeState {
    _height: number;
    _layoutWidth?: number;
    _width: number;
}

// @public
export interface ITreeStyleProps {
    className?: string;
    theme: ITheme;
}

// @public
export interface ITreeStyles {
    link: IStyle;
    rectBodyText: IStyle;
    rectMetricText: IStyle;
    rectNode: IStyle;
    rectSubText: IStyle;
    rectText: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface IVerticalBarChartDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    color?: string;
    gradient?: [string, string];
    legend?: string;
    lineData?: ILineDataInVerticalBarChart;
    onClick?: VoidFunction;
    x: number | string | Date;
    xAxisCalloutData?: string;
    y: number;
    yAxisCalloutData?: string;
}

// @public
export interface IVerticalBarChartProps extends ICartesianChartProps {
    barWidth?: number | 'default' | 'auto';
    chartTitle?: string;
    colors?: string[];
    culture?: string;
    data?: IVerticalBarChartDataPoint[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    lineLegendColor?: string;
    lineLegendText?: string;
    lineOptions?: ILineChartLineOptions;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly';
    onRenderCalloutPerDataPoint?: IRenderFunction<IVerticalBarChartDataPoint>;
    roundCorners?: boolean;
    styles?: IStyleFunctionOrObject<IVerticalBarChartStyleProps, IVerticalBarChartStyles>;
    useSingleColor?: boolean;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
}

// @public
export interface IVerticalBarChartStyleProps extends ICartesianChartStyleProps {
    legendColor?: string;
}

// @public
export interface IVerticalBarChartStyles extends ICartesianChartStyles {
    barLabel: IStyle;
    // @deprecated
    chartLabel?: IStyle;
    opacityChangeOnHover: IStyle;
    // @deprecated
    xAxisDomain?: IStyle;
    // @deprecated
    xAxisText?: IStyle;
    // @deprecated
    xAxisTicks?: IStyle;
    // @deprecated
    yAxisDomain?: IStyle;
    // @deprecated
    yAxisText?: IStyle;
    // @deprecated
    yAxisTicks?: IStyle;
}

// @public
export interface IVerticalStackedBarChartProps extends ICartesianChartProps {
    allowHoverOnLegend?: boolean;
    barCornerRadius?: number;
    barGapMax?: number;
    barMinimumHeight?: number;
    barWidth?: number | 'default' | 'auto';
    calloutProps?: Partial<ICalloutProps>;
    chartTitle?: string;
    // @deprecated
    colors?: string[];
    culture?: string;
    data: IVerticalStackedChartProps[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    isCalloutForStack?: boolean;
    lineOptions?: ILineChartLineOptions;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly';
    onBarClick?: (event: React_2.MouseEvent<SVGElement>, data: IVerticalStackedChartProps | IVSChartDataPoint) => void;
    onRenderCalloutPerDataPoint?: IRenderFunction<IVSChartDataPoint>;
    onRenderCalloutPerStack?: IRenderFunction<IVerticalStackedChartProps>;
    roundCorners?: boolean;
    styles?: IStyleFunctionOrObject<IVerticalStackedBarChartStyleProps, IVerticalStackedBarChartStyles>;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
    yMinValue?: undefined;
}

// @public
export interface IVerticalStackedBarChartStyleProps extends ICartesianChartStyleProps {
}

// @public
export interface IVerticalStackedBarChartStyles extends ICartesianChartStyles {
    barLabel: IStyle;
    // @deprecated
    chart?: IStyle;
    opacityChangeOnHover?: IStyle;
    // @deprecated
    xAxisDomain?: IStyle;
    // @deprecated
    xAxisText?: IStyle;
    // @deprecated
    xAxisTicks?: IStyle;
    // @deprecated
    yAxisDomain?: IStyle;
    // @deprecated
    yAxisText?: IStyle;
    // @deprecated
    yAxisTicks?: IStyle;
}

// @public (undocumented)
export interface IVerticalStackedBarDataPoint extends Omit<IDataPoint, 'x'> {
    x: number | string | Date;
}

// @public (undocumented)
export interface IVerticalStackedChartProps {
    chartData: IVSChartDataPoint[];
    lineData?: ILineDataInVerticalStackedBarChart[];
    stackCallOutAccessibilityData?: IAccessibilityProps;
    xAxisCalloutData?: string;
    xAxisPoint: number | string | Date;
}

// @public (undocumented)
export interface IVSChartDataPoint {
    callOutAccessibilityData?: IAccessibilityProps;
    color?: string;
    data: number;
    gradient?: [string, string];
    legend: string;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

// @public (undocumented)
export interface IYValueHover {
    // (undocumented)
    callOutAccessibilityData?: IAccessibilityProps;
    // (undocumented)
    color?: string;
    // (undocumented)
    data?: string | number;
    // (undocumented)
    index?: number;
    // (undocumented)
    legend?: string;
    // (undocumented)
    shouldDrawBorderBottom?: boolean;
    // (undocumented)
    y?: number;
    // (undocumented)
    yAxisCalloutData?: string | {
        [id: string]: number;
    };
}

// @public
export const Legends: React_2.FunctionComponent<ILegendsProps>;

// Warning: (ae-forgotten-export) The symbol "Points" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "CustomPoints" needs to be exported by the entry point index.d.ts
//
// @public
export type LegendShape = 'default' | 'triangle' | keyof typeof Points | keyof typeof CustomPoints;

// @public
export const LineChart: React_2.FunctionComponent<ILineChartProps>;

// @public
export const MultiStackedBarChart: React_2.FunctionComponent<IMultiStackedBarChartProps>;

// @public (undocumented)
export enum MultiStackedBarChartVariant {
    // (undocumented)
    AbsoluteScale = "absolute-scale",
    // (undocumented)
    PartToWhole = "part-to-whole"
}

// @public (undocumented)
export enum NodesComposition {
    compact = 0,
    long = 1
}

// @public
export const PieChart: React_2.FunctionComponent<IPieChartProps>;

// @public
export const ResponsiveContainer: React_2.FC<IResponsiveContainerProps>;

// @public
export const SankeyChart: React_2.FunctionComponent<ISankeyChartProps>;

// @public
export interface Schema {
    plotlySchema: any;
}

// @public (undocumented)
export const Shape: React_2.FC<IShapeProps>;

// Warning: (ae-forgotten-export) The symbol "ISNodeExtra" needs to be exported by the entry point index.d.ts
// Warning: (ae-forgotten-export) The symbol "ISLinkExtra" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type SLink = SankeyLink<ISNodeExtra, ISLinkExtra>;

// @public (undocumented)
export type SNode = SankeyNode<ISNodeExtra, ISLinkExtra>;

// @public
export const Sparkline: React_2.FunctionComponent<ISparklineProps>;

// @public
export const StackedBarChart: React_2.FunctionComponent<IStackedBarChartProps>;

// Warning: (ae-forgotten-export) The symbol "ITextboxProps" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export const Textbox: React_2.FunctionComponent<ITextboxProps>;

// @public
export const TreeChart: React_2.FunctionComponent<ITreeProps>;

// @public (undocumented)
export enum TreeTraverse {
    levelOrder = 0,
    preOrder = 1
}

// @public
export const VerticalBarChart: React_2.FunctionComponent<IVerticalBarChartProps>;

// @public
export const VerticalStackedBarChart: React_2.FunctionComponent<IVerticalStackedBarChartProps>;

// @public
export function withResponsiveContainer<TProps extends Omit<IResponsiveContainerProps, 'children'>>(WrappedComponent: React_2.ComponentType<TProps>): React_2.FC<TProps>;

// (No @packageDocumentation comment for this package)

```
