ContextQMD
Back to Fluentui

React Charts.Api

packages/charts/react-charts/library/etc/react-charts.api.md

4.40.2-hotfix254.2 KB
Original Source

API Report File for "@fluentui/react-charts"

Do not edit this file. It is a report generated by API Extractor.

ts

import { CurveFactory } from 'd3-shape';
import type { Font } from '@fluentui/chart-utilities';
import type { JSXElement } from '@fluentui/react-utilities';
import type { Margin } from '@fluentui/chart-utilities';
import { PositioningShorthand } from '@fluentui/react-positioning';
import * as React_2 from 'react';
import { Ref } from 'react';
import { SankeyGraph } from 'd3-sankey';
import { SankeyLayout } from 'd3-sankey';
import { SankeyLink } from 'd3-sankey';
import { SankeyNode } from 'd3-sankey';
import { ScaleBand } from 'd3-scale';
import { ScaleLinear } from 'd3-scale';
import { SVGProps } from 'react';
import { TimeLocaleDefinition } from 'd3-time-format';

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

// @public
export function adjustPadding(sankey: SankeyLayoutGenerator, height: number, nodesInColumn: NodesInColumns): void;

// @public (undocumented)
export const AnnotationOnlyChart: React_2.FC<AnnotationOnlyChartProps>;

// @public
export interface AnnotationOnlyChartProps {
    annotations: ChartAnnotation[];
    chartTitle?: string;
    componentRef?: React_2.Ref<Chart>;
    description?: string;
    fontColor?: string;
    fontFamily?: string;
    height?: number;
    margin?: Partial<Margin>;
    paperBackgroundColor?: string;
    plotBackgroundColor?: string;
    width?: number;
}

// @public (undocumented)
export interface AnnotationPlotRect {
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

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

// @public (undocumented)
export const ARC_PADDING = 2;

// @public (undocumented)
export const AreaChart: React_2.FunctionComponent<AreaChartProps>;

// @public (undocumented)
export interface AreaChartAreaPoint {
    // (undocumented)
    values: AreaChartDataSetPoint;
    // (undocumented)
    xVal: string | number;
}

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

// @public
export interface AreaChartProps extends CartesianChartProps {
    culture?: string;
    data: ChartProps;
    enableGradient?: boolean;
    enablePerfOptimization?: boolean;
    mode?: 'tozeroy' | 'tonexty';
    onRenderCalloutPerDataPoint?: RenderFunction<CustomizedCalloutData>;
    onRenderCalloutPerStack?: RenderFunction<CustomizedCalloutData>;
    // (undocumented)
    optimizeLargeData?: boolean;
    styles?: CartesianChartStyles;
}

// @public
export interface AreaChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface AreaChartStyles extends CartesianChartStyles {
}

// @public
export interface AreaPolarSeries extends DataSeries {
    data: PolarDataPoint[];
    lineOptions?: LineChartLineOptions;
    type: 'areapolar';
}

// @public
export type AxisCategoryOrder = 'default' | 'data' | string[] | 'category ascending' | 'category descending' | 'total ascending' | 'total descending' | 'min ascending' | 'min descending' | 'max ascending' | 'max descending' | 'sum ascending' | 'sum descending' | 'mean ascending' | 'mean descending' | 'median ascending' | 'median descending';

// @public
export type AxisProps = {
    tickStep?: number | string;
    tick0?: number | Date;
    tickText?: string[];
};

// @public
export type AxisScaleType = 'default' | 'log';

// @public
export interface BarSeries<X extends string | number | Date, Y extends string | number | Date> extends DataSeries {
    data: DataPointV2<X, Y>[];
    key?: string;
    type: 'bar';
}

// @public (undocumented)
export interface Basestate {
    // (undocumented)
    activeLegend?: string;
    // (undocumented)
    color?: string;
    // (undocumented)
    containerHeight?: number;
    // (undocumented)
    containerWidth?: number;
    // (undocumented)
    dataForHoverCard?: number | string;
    // (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 | string;
        color?: string;
    }[];
}

// @public (undocumented)
export const BREAKPOINTS: {
    minRadius: number;
    arcWidth: number;
    fontSize: number;
}[];

// @public (undocumented)
export const calcNeedleRotation: (chartValue: number, minValue: number, maxValue: number) => number;

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

// @public
export interface CartesianChartProps {
    annotations?: ChartAnnotation[];
    calloutProps?: Partial<ChartPopoverProps>;
    calloutPropsPerDataPoint?: (dataPointCalloutProps: any) => ChartPopoverProps;
    className?: string;
    componentRef?: React_2.Ref<Chart>;
    customDateTimeFormatter?: (dateTime: Date) => string;
    dateLocalizeOptions?: Intl.DateTimeFormatOptions;
    enabledLegendsWrapLines?: boolean;
    // @deprecated
    enableReflow?: boolean;
    height?: number;
    hideLegend?: boolean;
    hideTickOverlap?: boolean;
    hideTooltip?: boolean;
    href?: string;
    // (undocumented)
    legendProps?: Partial<LegendsProps>;
    // (undocumented)
    legendsOverflowText?: any;
    margins?: Margins;
    noOfCharsToTruncate?: number;
    parentRef?: HTMLElement | null;
    reflowProps?: {
        mode: 'none' | 'min-width';
    };
    rotateXAxisLables?: boolean;
    roundedTicks?: boolean;
    secondaryYAxistitle?: string;
    secondaryYScaleOptions?: {
        yMinValue?: number;
        yMaxValue?: number;
    };
    secondaryYScaleType?: AxisScaleType;
    showXAxisLablesTooltip?: boolean;
    showYAxisLables?: boolean;
    showYAxisLablesTooltip?: boolean;
    strokeWidth?: number;
    styles?: CartesianChartStyles;
    svgProps?: React_2.SVGProps<SVGSVGElement>;
    tickFormat?: string;
    tickPadding?: number;
    tickValues?: number[] | Date[] | string[] | undefined;
    timeFormatLocale?: TimeLocaleDefinition;
    titleStyles?: TitleStyles;
    useUTC?: string | boolean;
    width?: number;
    wrapXAxisLables?: boolean;
    xAxis?: AxisProps & {
        tickLayout?: 'default' | 'auto';
    };
    xAxisAnnotation?: string;
    xAxisCategoryOrder?: AxisCategoryOrder;
    xAxisTickCount?: number;
    xAxisTickPadding?: number;
    xAxistickSize?: number;
    xAxisTitle?: string;
    xMaxValue?: number;
    xMinValue?: number;
    xScaleType?: AxisScaleType;
    yAxis?: AxisProps;
    yAxisAnnotation?: string;
    yAxisCategoryOrder?: AxisCategoryOrder;
    yAxisTickCount?: number;
    yAxisTickFormat?: any;
    yAxisTickValues?: number[] | Date[] | string[];
    yAxisTitle?: string;
    yMaxValue?: number;
    yMinValue?: number;
    yScaleType?: AxisScaleType;
}

// @public
export interface CartesianChartStyleProps {
    className?: string;
    color?: string;
    // @deprecated
    enableReflow?: boolean;
    height?: number;
    href?: string;
    lineColor?: string;
    shouldHighlight?: boolean;
    toDrawShape?: boolean;
    useRtl?: boolean;
    width?: number;
}

// @public
export interface CartesianChartStyles {
    annotationLayer?: string;
    axisAnnotation?: string;
    axisTitle?: string;
    chart?: string;
    chartTitle?: string;
    chartWrapper?: string;
    descriptionMessage?: string;
    hover?: string;
    legendContainer?: string;
    opacityChangeOnHover?: string;
    plotContainer?: string;
    root?: string;
    shapeStyles?: string;
    svgTooltip?: string;
    tooltip?: string;
    xAxis?: string;
    yAxis?: string;
}

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

// @public (undocumented)
export interface ChartAnnotation {
    accessibility?: ChartAnnotationAccessibilityProps;
    connector?: ChartAnnotationConnectorProps;
    coordinates: ChartAnnotationCoordinate;
    data?: Record<string, unknown>;
    id?: string;
    layout?: ChartAnnotationLayoutProps;
    style?: ChartAnnotationStyleProps;
    text: string;
}

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

// @public (undocumented)
export type ChartAnnotationArrowHead = 'none' | 'start' | 'end' | 'both';

// @public (undocumented)
export interface ChartAnnotationConnectorProps {
    arrow?: ChartAnnotationArrowHead;
    dashArray?: string;
    endPadding?: number;
    startPadding?: number;
    strokeColor?: string;
    strokeWidth?: number;
}

// @public (undocumented)
export interface ChartAnnotationContext {
    isRtl?: boolean;
    plotRect: AnnotationPlotRect;
    svgRect: {
        width: number;
        height: number;
    };
    xScale?: (value: any) => number;
    yScalePrimary?: (value: any) => number;
    yScaleSecondary?: (value: any) => number;
}

// @public (undocumented)
export type ChartAnnotationCoordinate = {
    type: 'data';
    x: number | string | Date;
    y: number | string | Date;
    yAxis?: 'primary' | 'secondary';
} | {
    type: 'relative';
    x: number;
    y: number;
} | {
    type: 'pixel';
    x: number;
    y: number;
} | {
    type: 'mixed';
    xCoordinateType: 'data' | 'relative' | 'pixel';
    yCoordinateType: 'data' | 'relative' | 'pixel';
    x: number | string | Date;
    y: number | string | Date;
    yAxis?: 'primary' | 'secondary';
};

// @public (undocumented)
export type ChartAnnotationHorizontalAlign = 'start' | 'center' | 'end';

// @public (undocumented)
export const ChartAnnotationLayer: React_2.FC<ChartAnnotationLayerProps>;

// @public (undocumented)
export interface ChartAnnotationLayerProps {
    // (undocumented)
    annotations?: ChartAnnotation[];
    // (undocumented)
    className?: string;
    // (undocumented)
    context: ChartAnnotationContext;
    hideDefaultStyles?: boolean;
}

// @public (undocumented)
export interface ChartAnnotationLayoutProps {
    align?: ChartAnnotationHorizontalAlign;
    className?: string;
    clipToBounds?: boolean;
    maxWidth?: number;
    offsetX?: number;
    offsetY?: number;
    verticalAlign?: ChartAnnotationVerticalAlign;
}

// @public (undocumented)
export interface ChartAnnotationStyleProps {
    backgroundColor?: string;
    borderColor?: string;
    borderRadius?: number;
    borderStyle?: React_2.CSSProperties['borderStyle'];
    borderWidth?: number;
    boxShadow?: string;
    className?: string;
    fontSize?: string;
    fontWeight?: React_2.CSSProperties['fontWeight'];
    opacity?: number;
    padding?: string;
    rotation?: number;
    textColor?: string;
}

// @public (undocumented)
export type ChartAnnotationVerticalAlign = 'top' | 'middle' | 'bottom';

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

// @public (undocumented)
export interface ChartDataPoint {
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    data?: number;
    horizontalBarChartdata?: HorizontalDataPoint;
    legend?: string;
    onClick?: VoidFunction;
    placeHolder?: boolean;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

// @public (undocumented)
export const ChartPopover: React_2.FunctionComponent<ChartPopoverProps>;

// @public (undocumented)
export interface ChartPopoverProps {
    // (undocumented)
    clickPosition?: {
        x: number;
        y: number;
    };
    // (undocumented)
    color?: string;
    // (undocumented)
    culture?: string;
    // (undocumented)
    customCallout?: {
        customizedCallout?: JSXElement;
        customCalloutProps?: ChartPopoverProps;
    };
    // (undocumented)
    descriptionMessage?: string;
    // (undocumented)
    hoverXValue?: string | number;
    // (undocumented)
    isCalloutForStack?: boolean;
    // (undocumented)
    isCartesian?: boolean;
    // (undocumented)
    isPopoverOpen?: boolean;
    // (undocumented)
    legend?: string | number | Date;
    // (undocumented)
    positioning?: PositioningShorthand;
    // (undocumented)
    ratio?: [number, number];
    // (undocumented)
    styles?: Partial<PopoverComponentStyles>;
    // (undocumented)
    xAxisCalloutAccessibilityData?: {
        ariaLabel?: string;
        data?: string;
    };
    // (undocumented)
    xCalloutValue?: string;
    // (undocumented)
    XValue?: string;
    // (undocumented)
    yCalloutValue?: string;
    // (undocumented)
    YValue?: string | number | Date;
    // (undocumented)
    YValueHover?: YValueHover[];
}

// @public (undocumented)
export interface ChartProps {
    chartData?: ChartDataPoint[];
    chartDataAccessibilityData?: AccessibilityProps;
    chartTitle?: string;
    chartTitleAccessibilityData?: AccessibilityProps;
    lineChartData?: LineChartPoints[];
    pointLineOptions?: SVGProps<SVGLineElement>;
    pointOptions?: SVGProps<SVGCircleElement>;
    SankeyChartData?: SankeyChartData;
    scatterChartData?: ScatterChartPoints[];
}

// @public (undocumented)
export const ChartTable: React_2.FunctionComponent<ChartTableProps>;

// @public
export interface ChartTableProps {
    chartTitle?: string;
    className?: string;
    componentRef?: React_2.Ref<Chart>;
    headers: {
        value: string | number | boolean | null;
        style?: React_2.CSSProperties;
    }[];
    height?: string | number;
    rows: {
        value: string | number | boolean | null;
        style?: React_2.CSSProperties;
    }[][];
    styles?: ChartTableStyles;
    titleStyles?: TitleStyles;
    width?: string | number;
}

// @public
export interface ChartTableStyles {
    // (undocumented)
    bodyCell?: string;
    // (undocumented)
    chart?: string;
    // (undocumented)
    chartTitle?: string;
    // (undocumented)
    headerCell?: string;
    // (undocumented)
    root?: string | React_2.CSSProperties;
    // (undocumented)
    svgTooltip?: string;
    // (undocumented)
    table?: string;
}

// @public (undocumented)
export interface ChildProps {
    // (undocumented)
    containerHeight?: number;
    // (undocumented)
    containerWidth?: number;
    // (undocumented)
    optimizeLargeData?: boolean;
    // (undocumented)
    xScale?: any;
    // (undocumented)
    yScalePrimary?: any;
    // (undocumented)
    yScaleSecondary?: any;
}

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

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

// @public (undocumented)
export type ConnectorRenderData = {
    key: string;
    start: AnnotationPoint;
    end: AnnotationPoint;
    strokeColor: string;
    strokeWidth: number;
    dashArray?: string;
    arrow: ChartAnnotationArrowHead;
    markerSize: number;
    markerStrokeWidth: number;
};

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

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

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

// @public
export interface DataPointV2<X extends string | number | Date, Y extends string | number | Date> {
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    markerSize?: number;
    onClick?: () => void;
    text?: string;
    x: X;
    xAxisCalloutData?: string;
    y: Y;
    yAxisCalloutData?: string;
}

// @public
export interface DataSeries {
    color?: string;
    gradient?: [string, string];
    legend: string;
    legendShape?: LegendShape;
    onLegendClick?: (selectedLegend: string | null | string[]) => void;
    opacity?: number;
    useSecondaryYScale?: boolean;
}

// @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;
    colorwayType?: ColorwayType;
    componentRef?: React_2.Ref<IDeclarativeChart>;
    onSchemaChange?: (eventData: Schema) => void;
}

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

// @public
export interface DonutChartProps extends CartesianChartProps {
    calloutProps?: ChartPopoverProps;
    calloutPropsPerDataPoint?: (dataPointCalloutProps: ChartDataPoint) => ChartPopoverProps;
    className?: string;
    componentRef?: React_2.Ref<Chart>;
    culture?: string;
    data?: ChartProps;
    height?: number;
    hideLabels?: boolean;
    hideLegend?: boolean;
    hideTooltip?: boolean;
    href?: string;
    innerRadius?: number;
    // (undocumented)
    legendProps?: Partial<LegendsProps>;
    // (undocumented)
    legendsOverflowText?: any;
    onRenderCalloutPerDataPoint?: (dataPointCalloutProps: ChartDataPoint) => JSXElement | undefined;
    order?: 'default' | 'sorted';
    parentRef?: HTMLElement | null;
    roundCorners?: boolean;
    showLabelsInPercent?: boolean;
    styles?: DonutChartStyles;
    titleStyles?: TitleStyles;
    valueInsideDonut?: string | number;
    width?: number;
}

// @public
export interface DonutChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface DonutChartStyles {
    axisAnnotation?: string;
    chart?: string;
    chartTitle?: string;
    chartWrapper?: string;
    legendContainer: string;
    root?: string;
    svgTooltip?: string;
}

// @public (undocumented)
export interface DPointType {
    // (undocumented)
    values: {
        0: number;
        1: number;
        data: {};
    };
    // (undocumented)
    xVal: number | Date;
}

// @public (undocumented)
export interface EventsAnnotationProps {
    // (undocumented)
    events: EventAnnotation[];
    // (undocumented)
    labelColor?: string;
    // (undocumented)
    labelHeight?: number;
    // (undocumented)
    labelWidth?: number;
    // (undocumented)
    mergedLabel: (count: number) => string;
    // (undocumented)
    strokeColor?: string;
}

// @public (undocumented)
export interface ExtendedSegment extends GaugeChartSegment {
    // (undocumented)
    end: number;
    // (undocumented)
    start: number;
}

// @public (undocumented)
export const FunnelChart: React_2.FunctionComponent<FunnelChartProps>;

// @public
export interface FunnelChartDataPoint {
    color?: string;
    stage: string | number;
    subValues?: Array<{
        category: string;
        value: number;
        color: string;
    }>;
    value?: number;
}

// @public
export interface FunnelChartProps {
    calloutProps?: ChartPopoverProps;
    chartTitle?: string;
    className?: string;
    componentRef?: React_2.Ref<Chart>;
    culture?: string;
    data: FunnelChartDataPoint[];
    height?: number;
    hideLegend?: boolean;
    legendProps?: Partial<LegendsProps>;
    orientation?: 'horizontal' | 'vertical';
    styles?: FunnelChartStyles;
    titleStyles?: TitleStyles;
    width?: number;
}

// @public
export interface FunnelChartStyleProps {
    chartHeight: number;
    chartWidth: number;
    className?: string;
}

// @public
export interface FunnelChartStyles {
    calloutContentRoot?: string;
    chart?: string;
    chartTitle?: string;
    root?: string;
    svgTooltip?: string;
    text?: string;
}

// @public (undocumented)
export const GanttChart: React_2.FunctionComponent<GanttChartProps>;

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

// @public
export interface GanttChartProps extends CartesianChartProps {
    barHeight?: number;
    chartTitle?: string;
    culture?: string;
    data?: GanttChartDataPoint[];
    enableGradient?: boolean;
    maxBarHeight?: number;
    onRenderCalloutPerDataPoint?: RenderFunction<GanttChartDataPoint>;
    roundCorners?: boolean;
    yAxisPadding?: number;
}

// @public
export interface GanttChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface GanttChartStyles extends CartesianChartStyles {
}

// @public (undocumented)
export const GaugeChart: React_2.FunctionComponent<GaugeChartProps>;

// @public
export interface GaugeChartProps {
    calloutProps?: Partial<ChartPopoverProps>;
    chartTitle?: string;
    chartValue: number;
    chartValueFormat?: GaugeValueFormat | ((sweepFraction: [number, number]) => string);
    componentRef?: React.Ref<Chart>;
    culture?: string;
    enableGradient?: boolean;
    height?: number;
    hideLegend?: boolean;
    hideMinMax?: boolean;
    hideTooltip?: boolean;
    // (undocumented)
    legendProps?: Partial<LegendsProps>;
    maxValue?: number;
    minValue?: number;
    roundCorners?: boolean;
    segments: GaugeChartSegment[];
    styles?: GaugeChartStyles;
    sublabel?: string;
    titleStyles?: TitleStyles;
    variant?: GaugeChartVariant;
    width?: number;
}

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

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

// @public (undocumented)
export type GaugeChartVariant = 'single-segment' | 'multiple-segments';

// @public (undocumented)
export type GaugeValueFormat = 'percentage' | 'fraction';

// @public (undocumented)
export const getChartValueLabel: (chartValue: number, minValue: number, maxValue: number, chartValueFormat?: GaugeValueFormat | ((sweepFraction: [number, number]) => string), forCallout?: boolean) => string;

// @public (undocumented)
export const getColorContrast: (c1: string, c2: string) => number;

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

// @public (undocumented)
export function getContrastTextColor(backgroundColor: string, isDarkTheme?: boolean): string;

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

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

// @public (undocumented)
export const getSegmentLabel: (segment: ExtendedSegment, minValue: number, maxValue: number, variant?: GaugeChartVariant, isAriaLabel?: boolean) => string;

// @public (undocumented)
export const GroupedVerticalBarChart: React_2.FC<GroupedVerticalBarChartProps>;

// @public (undocumented)
export interface GroupedVerticalBarChartData {
    name: string;
    series: GVBarChartSeriesPoint[];
    stackCallOutAccessibilityData?: AccessibilityProps;
}

// @public
export interface GroupedVerticalBarChartProps extends CartesianChartProps {
    barWidth?: number | 'default' | 'auto';
    chartTitle?: string;
    colors?: string[];
    culture?: string;
    data?: GroupedVerticalBarChartData[];
    dataV2?: (BarSeries<string, number> | LineSeries<string, number>)[];
    hideLabels?: boolean;
    isCalloutForStack?: boolean;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly';
    roundCorners?: boolean;
    styles?: GroupedVerticalBarChartStyles;
    useSingleColor?: boolean;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
}

// @public
export interface GroupedVerticalBarChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface GroupedVerticalBarChartStyles extends CartesianChartStyles {
    barLabel: string;
}

// @public
export function groupNodesByColumn(graph: SankeyChartData): NodesInColumns;

// @public (undocumented)
export interface GVBarChartSeriesPoint {
    barLabel?: string;
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    data: number;
    key: string;
    legend: string;
    onClick?: VoidFunction;
    useSecondaryYScale?: boolean;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

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

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

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

// @public (undocumented)
export const HeatMapChart: React_2.FunctionComponent<HeatMapChartProps>;

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

// @public (undocumented)
export interface HeatMapChartDataPoint {
    callOutAccessibilityData?: AccessibilityProps;
    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 HeatMapChartProps extends CartesianChartProps {
    chartTitle?: string;
    culture?: string;
    data: HeatMapChartData[];
    domainValuesForColorScale: number[];
    rangeValuesForColorScale: string[];
    sortOrder?: 'none' | 'alphabetical';
    styles?: HeatMapChartStyles;
    xAxisDateFormatString?: string;
    xAxisNumberFormatString?: string;
    xAxisStringFormatter?: (point: string) => string;
    yAxisDateFormatString?: string;
    yAxisNumberFormatString?: string;
    yAxisStringFormatter?: (point: string) => string;
}

// @public
export interface HeatMapChartStyles extends CartesianChartStyles {
    // (undocumented)
    calloutContentRoot?: string;
    // (undocumented)
    root?: string;
    // (undocumented)
    text?: string;
}

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

// @public
export interface HorizontalBarChartProps extends React_2.RefAttributes<HTMLDivElement> {
    barHeight?: number;
    calloutProps?: ChartPopoverProps;
    calloutPropsPerDataPoint?: (dataPointCalloutProps: ChartDataPoint) => ChartPopoverProps;
    chartDataMode?: ChartDataMode;
    className?: string;
    color?: string;
    culture?: string;
    data?: ChartProps[];
    hideLabels?: boolean;
    hideRatio?: boolean[];
    hideTooltip?: boolean;
    // (undocumented)
    legendProps?: Partial<LegendsProps>;
    // (undocumented)
    legendsOverflowText?: any;
    onRenderCalloutPerHorizontalBar?: (props: ChartDataPoint) => JSXElement | undefined;
    showLegendForSinglePointBar?: boolean;
    showTriangle?: boolean;
    styles?: HorizontalBarChartStyles;
    variant?: HorizontalBarChartVariant;
    width?: number;
}

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

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

// @public (undocumented)
export const HorizontalBarChartWithAxis: React_2.FunctionComponent<HorizontalBarChartWithAxisProps>;

// @public (undocumented)
export interface HorizontalBarChartWithAxisDataPoint {
    barLabel?: string;
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    legend?: string;
    onClick?: VoidFunction;
    x: number;
    xAxisCalloutData?: string;
    y: number | string;
    yAxisCalloutData?: string;
}

// @public
export interface HorizontalBarChartWithAxisProps extends CartesianChartProps {
    barHeight?: number;
    chartTitle?: string;
    colors?: string[];
    culture?: string;
    data?: HorizontalBarChartWithAxisDataPoint[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    onRenderCalloutPerDataPoint?: RenderFunction<HorizontalBarChartWithAxisDataPoint>;
    roundCorners?: boolean;
    styles?: HorizontalBarChartWithAxisStyles;
    useSingleColor?: boolean;
    yAxisPadding?: number;
}

// @public
export interface HorizontalBarChartWithAxisStyleProps extends CartesianChartStyleProps {
    legendColor?: string;
}

// @public
export interface HorizontalBarChartWithAxisStyles extends CartesianChartStyles {
    barLabel?: string;
    chartLabel?: string;
    opacityChangeOnHover: string;
    xAxisDomain?: string;
    xAxisText?: string;
    xAxisTicks?: string;
    yAxisDomain?: string;
    yAxisText?: string;
    yAxisTicks?: string;
}

// @public (undocumented)
export interface HorizontalDataPoint {
    total?: number;
    x: number;
}

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

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

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

// @public (undocumented)
export interface LegendContainer {
    // (undocumented)
    toSVG: (svgWidth: number, isRTL?: boolean) => {
        node: SVGSVGElement | null;
        width: number;
        height: number;
    };
}

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

// @public (undocumented)
export const Legends: React_2.FunctionComponent<LegendsProps>;

// @public
export type LegendShape = 'default' | 'triangle' | keyof typeof Points | keyof typeof CustomPoints;

// @public
export interface LegendsProps {
    allowFocusOnLegends?: boolean;
    canSelectMultipleLegends?: boolean;
    centerLegends?: boolean;
    className?: string;
    defaultSelectedLegend?: string;
    defaultSelectedLegends?: string[];
    enabledWrapLines?: boolean;
    legendRef?: React_2.Ref<LegendContainer>;
    legends: Legend[];
    onChange?: (selectedLegends: string[], event: React_2.MouseEvent<HTMLButtonElement>, currentLegend?: Legend) => void;
    overflowStyles?: React_2.CSSProperties;
    overflowText?: string;
    selectedLegend?: string;
    selectedLegends?: string[];
    shape?: LegendShape;
    styles?: LegendsStyles;
}

// @public
export interface LegendsStyles {
    annotation?: string;
    hoverChange?: string;
    legend?: string;
    // (undocumented)
    legendContainer?: string;
    rect?: string;
    resizableArea?: string;
    root?: string;
    shape?: string;
    text?: string;
    triangle?: string;
}

// @public (undocumented)
export interface LegendState {
    // (undocumented)
    activeLegend: string;
    selectedLegends: LegendMap;
}

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

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

// @public (undocumented)
export interface LineChartDataPoint extends BaseDataPoint {
    markerColor?: string;
    text?: string;
    x: number | Date;
    y: number;
}

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

// @public (undocumented)
export interface LineChartLineOptions extends SVGProps<SVGPathElement> {
    curve?: 'linear' | 'natural' | 'step' | 'stepAfter' | 'stepBefore' | CurveFactory;
    lineBorderColor?: string;
    lineBorderWidth?: string | number;
    mode?: 'lines' | 'markers' | 'text' | 'lines+markers' | 'text+markers' | 'text+lines' | 'text+lines+markers' | 'none' | 'gauge' | 'number' | 'delta' | 'number+delta' | 'gauge+number' | 'gauge+number+delta' | 'gauge+delta' | 'markers+text' | 'lines+text' | 'lines+markers+text';
    strokeDasharray?: string | number;
    strokeDashoffset?: string | number;
    strokeLinecap?: 'butt' | 'round' | 'square' | 'inherit';
    strokeWidth?: number | string;
}

// @public (undocumented)
export interface LineChartPoints {
    color?: string;
    data: LineChartDataPoint[] | ScatterChartDataPoint[];
    gaps?: LineChartGap[];
    hideNonActiveDots?: boolean;
    legend: string;
    legendShape?: LegendShape;
    lineOptions?: LineChartLineOptions;
    onLegendClick?: (selectedLegend: string | null | string[]) => void;
    onLineClick?: () => void;
    opacity?: number;
    useSecondaryYScale?: boolean;
}

// @public
export interface LineChartProps extends CartesianChartProps {
    allowMultipleShapesForPoints?: boolean;
    // (undocumented)
    colorFillBars?: ColorFillBarsProps[];
    culture?: string;
    data: ChartProps;
    enablePerfOptimization?: boolean;
    eventAnnotationProps?: EventsAnnotationProps;
    getCalloutDescriptionMessage?: (calloutDataProps: CustomizedCalloutData) => string | undefined;
    isCalloutForStack?: boolean;
    onRenderCalloutPerDataPoint?: RenderFunction<CustomizedCalloutData>;
    onRenderCalloutPerStack?: RenderFunction<CustomizedCalloutData>;
    // (undocumented)
    optimizeLargeData?: boolean;
    styles?: LineChartStyles;
}

// @public
export interface LineChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface LineChartStyles extends CartesianChartStyles {
    lineBorder?: string;
    markerLabel?: string;
}

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

// @public (undocumented)
export interface LineDataInVerticalStackedBarChart {
    // (undocumented)
    color: string;
    data?: number | string;
    // (undocumented)
    legend: string;
    legendShape?: LegendShape;
    lineOptions?: LineChartLineOptions;
    useSecondaryYScale?: boolean;
    // (undocumented)
    y: number | string;
    // (undocumented)
    yAxisCalloutData?: string;
}

// @public
export interface LinePolarSeries extends DataSeries {
    data: PolarDataPoint[];
    lineOptions?: LineChartLineOptions;
    type: 'linepolar';
}

// @public
export interface LineSeries<X extends string | number | Date, Y extends string | number | Date> extends DataSeries {
    data: DataPointV2<X, Y>[];
    gaps?: LineChartGap[];
    hideInactiveDots?: boolean;
    lineOptions?: LineChartLineOptions;
    onLineClick?: () => void;
    type: 'line';
}

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

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

// @public (undocumented)
export interface ModifiedCartesianChartProps extends CartesianChartProps {
    barwidth?: number;
    calloutProps?: ChartPopoverProps;
    chartTitle?: string;
    chartType: ChartTypes;
    children(props: ChildProps): React_2.ReactNode;
    createStringYAxis: (yAxisParams: IYAxisParams, dataPoints: string[], isRtl: boolean, axisData: IAxisData, barWidth: number | undefined, chartType?: ChartTypes) => ScaleBand<string>;
    createYAxis: (yAxisParams: IYAxisParams, isRtl: boolean, axisData: IAxisData, isIntegralDataset: boolean, chartType: ChartTypes, useSecondaryYScale?: boolean, roundedTicks?: boolean, scaleType?: AxisScaleType, _useRtl?: boolean) => ScaleLinear<number, number, never>;
    culture?: string;
    customizedCallout?: any;
    datasetForXAxisDomain?: string[];
    enableFirstRenderOptimization?: boolean;
    // (undocumented)
    getAxisData?: any;
    getDomainMargins?: (containerWidth: number) => Margins;
    getDomainNRangeValues: (points: LineChartPoints[] | VerticalBarChartDataPoint[] | VerticalStackedBarDataPoint[] | HorizontalBarChartWithAxisDataPoint[] | GroupedVerticalBarChartData[] | HeatMapChartDataPoint[] | GanttChartDataPoint[], margins: Margins, width: number, chartType: ChartTypes, isRTL: boolean, xAxisType: XAxisTypes, barWidth: number, tickValues: Date[] | number[] | string[] | undefined) => IDomainNRange;
    getGraphData?: any;
    getmargins?: (margins: Margins) => void;
    getMinMaxOfYAxis: (points: LineChartPoints[] | HorizontalBarChartWithAxisDataPoint[] | VerticalBarChartDataPoint[] | DataPoint[] | ScatterChartPoints[] | GanttChartDataPoint[], yAxisType: YAxisType | undefined, useSecondaryYScale?: boolean) => {
        startValue: number;
        endValue: number;
    };
    getYDomainMargins?: (containerHeight: number) => Margins;
    isCalloutForStack?: boolean;
    legendBars: JSXElement | null;
    maxOfYVal?: number;
    onChartMouseLeave?: () => void;
    points: any;
    showRoundOffXTickValues?: boolean;
    showYAxisLables?: boolean;
    showYAxisLablesTooltip?: boolean;
    stringDatasetForYAxisDomain?: string[];
    tickParams?: {
        tickValues?: number[] | Date[] | string[];
        tickFormat?: string;
    };
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
    xAxisType: XAxisTypes;
    yAxisPadding?: number;
    yAxisType?: YAxisType;
}

// @public
export type PolarAxisProps = AxisProps & {
    tickValues?: number[] | Date[] | string[];
    tickFormat?: string;
    tickCount?: number;
    categoryOrder?: AxisCategoryOrder;
    scaleType?: AxisScaleType;
    rangeStart?: number | Date;
    rangeEnd?: number | Date;
};

// @public (undocumented)
export const PolarChart: React_2.FunctionComponent<PolarChartProps>;

// @public
export interface PolarChartProps {
    angularAxis?: PolarAxisProps & {
        unit?: 'radians' | 'degrees';
    };
    chartTitle?: string;
    componentRef?: React_2.Ref<Chart>;
    culture?: string;
    data: (AreaPolarSeries | LinePolarSeries | ScatterPolarSeries)[];
    dateLocalizeOptions?: Intl.DateTimeFormatOptions;
    direction?: 'clockwise' | 'counterclockwise';
    height?: number;
    hideLegend?: boolean;
    hideTooltip?: boolean;
    hole?: number;
    // (undocumented)
    legendProps?: Partial<LegendsProps>;
    margins?: Margins;
    radialAxis?: PolarAxisProps;
    shape?: 'circle' | 'polygon';
    styles?: PolarChartStyles;
    useUTC?: boolean;
    width?: number;
}

// @public
export interface PolarChartStyleProps {
}

// @public
export interface PolarChartStyles {
    chart?: string;
    chartWrapper?: string;
    gridLineInner?: string;
    gridLineOuter?: string;
    legendContainer?: string;
    root?: string;
    tickLabel?: string;
}

// @public
export interface PolarDataPoint {
    angularAxisCalloutData?: string;
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    markerSize?: number;
    onClick?: () => void;
    r: string | number | Date;
    radialAxisCalloutData?: string;
    text?: string;
    theta: string | number;
}

// @public (undocumented)
export interface PopoverComponentStyles {
    // (undocumented)
    calloutBlockContainer: string;
    // (undocumented)
    calloutBlockContainertoDrawShapefalse: string;
    // (undocumented)
    calloutBlockContainertoDrawShapetrue: string;
    // (undocumented)
    calloutContainer: string;
    // (undocumented)
    calloutContentRoot: string;
    // (undocumented)
    calloutContentX: string;
    // (undocumented)
    calloutContentY: string;
    // (undocumented)
    calloutDateTimeContainer: string;
    // (undocumented)
    calloutInfoContainer: string;
    // (undocumented)
    calloutlegendText: string;
    // (undocumented)
    denominator: string;
    // (undocumented)
    descriptionMessage: string;
    // (undocumented)
    numerator: string;
    // (undocumented)
    ratio: string;
    // (undocumented)
    shapeStyles: string;
}

// @public (undocumented)
export function preRenderLayout(margins: Margins, containerWidth: number, containerHeight: number, isRtl: boolean): {
    sankey: SankeyLayoutGenerator;
    height: number;
    width: number;
};

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

// @public (undocumented)
export interface ResolvedAnnotationPosition {
    anchor: AnnotationPoint;
    point: AnnotationPoint;
}

// @public
export interface ResponsiveChildProps {
    // (undocumented)
    height?: number;
    // (undocumented)
    shouldResize?: number;
    // (undocumented)
    styles?: ResponsiveChildStyles;
    // (undocumented)
    width?: number;
}

// @public
export interface ResponsiveChildStyles {
    // (undocumented)
    chart?: string;
    // (undocumented)
    chartWrapper?: string;
    // (undocumented)
    root?: string;
}

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

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

// @public (undocumented)
export const SankeyChart: React_2.FunctionComponent<SankeyChartProps>;

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

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

// @public
export interface SankeyChartProps {
    accessibility?: SankeyChartAccessibilityProps;
    borderColorsForNodes?: string[];
    calloutProps?: ChartPopoverProps;
    className?: string;
    colorsForNodes?: string[];
    componentRef?: Ref<Chart>;
    culture?: string;
    data: ChartProps;
    // @deprecated
    enableReflow?: boolean;
    formatNumberOptions?: Intl.NumberFormatOptions;
    height?: number;
    hideLegend?: boolean;
    parentRef?: HTMLElement | null;
    pathColor?: string;
    reflowProps?: {
        mode: 'none' | 'min-width';
    };
    shouldResize?: number;
    strings?: SankeyChartStrings;
    styles?: SankeyChartStyles;
    titleStyles?: TitleStyles;
    width?: number;
}

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

// @public
export interface SankeyChartStyles {
    chart?: string;
    chartTitle?: string;
    chartWrapper?: string;
    links?: string;
    nodes?: string;
    nodeTextContainer?: string;
    root?: string;
    svgTooltip?: string;
    toolTip?: string;
}

// @public
export const ScatterChart: React_2.FunctionComponent<ScatterChartProps>;

// @public
export interface ScatterChartDataPoint extends BaseDataPoint {
    markerColor?: string;
    markerSize?: number;
    text?: string;
    x: number | Date | string;
    y: number;
}

// @public (undocumented)
export interface ScatterChartPoints {
    color?: string;
    data: ScatterChartDataPoint[];
    hideNonActiveDots?: boolean;
    legend: string;
    legendShape?: LegendShape;
    onLegendClick?: (selectedLegend: string | null | string[]) => void;
    opacity?: number;
    useSecondaryYScale?: boolean;
}

// @public
export interface ScatterChartProps extends CartesianChartProps {
    culture?: string;
    data: ChartProps;
    getCalloutDescriptionMessage?: (calloutDataProps: CustomizedCalloutData) => string | undefined;
    onRenderCalloutPerDataPoint?: RenderFunction<CustomizedCalloutData>;
    onRenderCalloutPerStack?: RenderFunction<CustomizedCalloutData>;
    styles?: ScatterChartStyles;
}

// @public
export interface ScatterChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface ScatterChartStyles extends CartesianChartStyles {
    markerLabel?: string;
}

// @public
export interface ScatterPolarSeries extends DataSeries {
    data: PolarDataPoint[];
    type: 'scatterpolar';
}

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

// @public (undocumented)
export const Shape: React_2.FunctionComponent<ShapeProps>;

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

// @public (undocumented)
export type SLink = SankeyLink<SNodeExtra, SLinkExtra>;

// @public (undocumented)
export type SNode = SankeyNode<SNodeExtra, SLinkExtra>;

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

// @public
export interface SparklineProps extends React.RefAttributes<HTMLDivElement> {
    className?: string;
    culture?: string;
    data?: ChartProps;
    height?: number;
    showLegend?: boolean;
    styles?: SparklineStyles;
    valueTextWidth?: number;
    width?: number;
}

// @public (undocumented)
export interface SparklineStyleProps extends CartesianChartStyleProps {
}

// @public
export interface SparklineStyles {
    // (undocumented)
    inlineBlock?: string;
    // (undocumented)
    valueText?: string;
}

// @public (undocumented)
export const Textbox: React_2.FunctionComponent<TextboxProps>;

// @public
export const VegaDeclarativeChart: React_2.ForwardRefExoticComponent<VegaDeclarativeChartProps & React_2.RefAttributes<HTMLDivElement>>;

// @public
export interface VegaDeclarativeChartProps {
    chartSchema: VegaSchema;
    className?: string;
    onSchemaChange?: (newSchema: VegaSchema) => void;
    style?: React_2.CSSProperties;
}

// @public
export interface VegaLiteSpec {
    $schema?: string;
    autosize?: string | {
        type?: string;
        contains?: string;
    };
    background?: string;
    config?: Record<string, unknown>;
    data?: VegaLiteData;
    description?: string;
    encoding?: VegaLiteEncoding;
    facet?: Record<string, unknown>;
    hconcat?: VegaLiteSpec[];
    height?: number | 'container';
    layer?: VegaLiteUnitSpec[];
    mark?: VegaLiteMarkDef;
    padding?: number | {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    };
    repeat?: Record<string, unknown>;
    resolve?: {
        scale?: {
            x?: 'shared' | 'independent';
            y?: 'shared' | 'independent';
            color?: 'shared' | 'independent';
            opacity?: 'shared' | 'independent';
            size?: 'shared' | 'independent';
            shape?: 'shared' | 'independent';
        };
        axis?: {
            x?: 'shared' | 'independent';
            y?: 'shared' | 'independent';
        };
        legend?: {
            color?: 'shared' | 'independent';
            opacity?: 'shared' | 'independent';
            size?: 'shared' | 'independent';
            shape?: 'shared' | 'independent';
        };
    };
    selection?: Record<string, unknown>;
    title?: string | VegaLiteTitleParams;
    transform?: Array<Record<string, unknown>>;
    vconcat?: VegaLiteSpec[];
    width?: number | 'container';
}

// @public
export interface VegaSchema {
    selectedLegends?: string[];
    vegaLiteSpec: VegaLiteSpec;
}

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

// @public (undocumented)
export interface VerticalBarChartDataPoint {
    barLabel?: string;
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    legend?: string;
    lineData?: LineDataInVerticalBarChart;
    onClick?: VoidFunction;
    x: number | string | Date;
    xAxisCalloutData?: string;
    y: number;
    yAxisCalloutData?: string;
}

// @public
export interface VerticalBarChartProps extends CartesianChartProps {
    barWidth?: number | 'default' | 'auto';
    chartTitle?: string;
    colors?: string[];
    culture?: string;
    data?: VerticalBarChartDataPoint[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    lineLegendColor?: string;
    lineLegendText?: string;
    lineOptions?: LineChartLineOptions;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly' | 'histogram';
    onRenderCalloutPerDataPoint?: RenderFunction<VerticalBarChartDataPoint>;
    roundCorners?: boolean;
    styles?: Partial<VerticalBarChartStyles>;
    useSingleColor?: boolean;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
}

// @public
export interface VerticalBarChartStyleProps extends CartesianChartStyleProps {
    legendColor?: string;
}

// @public
export interface VerticalBarChartStyles extends CartesianChartStyles {
    barLabel: string;
    lineBorder: string;
}

// @public (undocumented)
export const VerticalStackedBarChart: React_2.FunctionComponent<VerticalStackedBarChartProps>;

// @public
export interface VerticalStackedBarChartProps extends CartesianChartProps {
    allowHoverOnLegend?: boolean;
    barCornerRadius?: number;
    barGapMax?: number;
    barMinimumHeight?: number;
    barWidth?: number | 'default' | 'auto';
    chartTitle?: string;
    culture?: string;
    data: VerticalStackedChartProps[];
    enableGradient?: boolean;
    hideLabels?: boolean;
    isCalloutForStack?: boolean;
    lineOptions?: LineChartLineOptions;
    maxBarWidth?: number;
    mode?: 'default' | 'plotly';
    onBarClick?: (event: React_2.MouseEvent<SVGElement>, data: VerticalStackedChartProps | VSChartDataPoint) => void;
    onRenderCalloutPerDataPoint?: RenderFunction<VSChartDataPoint>;
    onRenderCalloutPerStack?: RenderFunction<VerticalStackedChartProps>;
    roundCorners?: boolean;
    styles?: Partial<VerticalStackedBarChartStyles>;
    xAxisInnerPadding?: number;
    xAxisOuterPadding?: number;
    xAxisPadding?: number;
    yMinValue?: number | undefined;
}

// @public
export interface VerticalStackedBarChartStyleProps extends CartesianChartStyleProps {
}

// @public
export interface VerticalStackedBarChartStyles extends CartesianChartStyles {
    barLabel: string;
    opacityChangeOnHover?: string;
}

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

// @public (undocumented)
export interface VerticalStackedChartProps {
    chartData: VSChartDataPoint[];
    lineData?: LineDataInVerticalStackedBarChart[];
    stackCallOutAccessibilityData?: AccessibilityProps;
    xAxisCalloutData?: string;
    xAxisPoint: number | string | Date;
}

// @public (undocumented)
export interface VSChartDataPoint {
    barLabel?: string;
    callOutAccessibilityData?: AccessibilityProps;
    color?: string;
    culture?: string;
    data: number | string;
    legend: string;
    xAxisCalloutData?: string;
    yAxisCalloutData?: string;
}

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

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

// (No @packageDocumentation comment for this package)