/// <reference types="react" />
/// <reference types="graceful-fs" />
import AnnotationLayer from "./AnnotationLayer";
import { ScaleLinear, ScaleBand } from "d3-scale";
import * as React from "react";
import { RefObject } from "react";
import { Mark } from "semiotic-mark";
interface NodeType {
    degree: number;
    inDegree: number;
    outDegree: number;
    id?: string;
    createdByFrame?: boolean;
    x: number;
    y: number;
    x1: number;
    x0: number;
    y1: number;
    y0: number;
    height: number;
    width: number;
    radius: number;
    direction: string;
    textHeight: number;
    textWidth: number;
    fontSize: number;
    fontWeight?: number;
    rotate?: number;
    scale: number;
    _NWFText?: string;
    text?: string;
    r: number;
    nodeSize: number;
    component: number;
    shapeNode: boolean;
    depth?: number;
    d?: string;
    index?: number;
    zoomedHeight?: number;
    zoomedWidth?: number;
    value?: number;
}
interface EdgeType {
    circular?: boolean;
    circularPathData?: any;
    source?: NodeType;
    target?: NodeType;
    d?: string;
    x?: number;
    y?: number;
    y0?: number;
    y1?: number;
    sankeyWidth?: number;
    direction?: string;
    width?: number;
    points?: Array<{
        x: number;
        y: number;
    }>;
    showArrows?: boolean;
    ephemeral?: boolean;
    value?: number;
}
interface GraphSettingsType {
    type: string | (({ edges, nodes }: {
        edges: EdgeType[];
        nodes: NodeType[];
    }) => void);
    nodes: object[];
    edges: object[] | object;
    nodeHash: Map<any, NodeType>;
    edgeHash: Map<any, EdgeType>;
    hierarchicalNetwork: boolean;
    filterRenderedNodes?: Function;
}
interface NetworkSettingsType {
    type?: string | (({ edges, nodes }: {
        edges: EdgeType[];
        nodes: NodeType[];
    }) => void);
    hierarchyChildren?: Function;
    hierarchySum?: Function;
    layout?: Function;
    nodeSize?: Function;
    nodes?: NodeType[];
    edges?: EdgeType[];
    iterations?: number;
    width?: number;
    height?: number;
    projection?: "horizontal" | "radial" | "vertical";
    customSankey?: Function;
    groupWidth?: number;
    padAngle?: number;
    padding?: number;
    orient?: string;
    nodePadding?: number;
    nodePaddingRatio?: number;
    nodeWidth?: number;
    direction?: string;
    fontSize?: number;
    rotate?: Function;
    fontWeight?: number;
    textAccessor?: Function;
    edgeStrength?: number;
    distanceMax?: number;
    edgeDistance?: number;
    forceManyBody?: Function | number;
    hierarchicalNetwork: boolean;
    graphSettings: GraphSettingsType;
    sortGroups?: Function;
    simulation?: Function;
    sort?: (a: GenericObject, b: GenericObject) => number;
    zoom?: boolean | "stretch" | ((nodes: NodeType[], edges: EdgeType[], size: number[]) => void);
    fixExistingNodes?: boolean | Function;
    showArrows?: boolean;
}
interface NetworkFrameState extends GeneralFrameState {
    nodeData: object[];
    edgeData: object[];
    projectedNodes: NodeType[];
    projectedEdges: EdgeType[];
    projectedXYPoints: object[];
    overlay: object[];
    nodeIDAccessor: (args: GenericObject) => string;
    sourceAccessor: (args: GenericObject) => GenericObject | string;
    targetAccessor: (args: GenericObject) => GenericObject | string;
    nodeSizeAccessor: (args: GenericObject) => number;
    edgeWidthAccessor: (args: GenericObject) => number;
    nodeLabelAnnotations: object[];
    graphSettings: GraphSettingsType;
    networkFrameRender: RenderPipelineType;
    props: NetworkFrameProps;
}
interface NetworkFrameProps extends GeneralFrameProps {
    graph?: {
        nodes: NodeType[];
        edges: EdgeType[];
    } | EdgeType[] | {
        (): () => void;
        nodes: Function;
        edges: Function;
        node: Function;
        edge: Function;
    };
    nodes?: object[];
    edges?: object[] | object;
    networkType?: string | object;
    nodeStyle?: GenericObject | ((args: GenericObject) => GenericObject);
    nodeClass?: string | ((args: GenericObject) => string);
    canvasNodes?: boolean | ((args: GenericObject) => boolean);
    edgeStyle?: GenericObject | ((args: GenericObject) => GenericObject);
    edgeClass?: string | ((args: GenericObject) => string);
    canvasEdges?: boolean | ((args: GenericObject) => boolean);
    nodeRenderMode?: string | ((args: GenericObject) => string);
    edgeRenderMode?: string | ((args: GenericObject) => string);
    nodeLabels?: boolean | ((args: GenericObject) => JSX.Element | string | null);
    edgeRenderKey?: (args: GenericObject) => string;
    nodeRenderKey?: (args: GenericObject) => string;
    edgeWidthAccessor?: string | ((args: GenericObject) => number);
    nodeSizeAccessor?: string | ((args: GenericObject) => number);
    targetAccessor?: string | ((args: GenericObject) => string | GenericObject);
    sourceAccessor?: string | ((args: GenericObject) => string | GenericObject);
    nodeIDAccessor?: string | ((args: GenericObject) => string);
    edgeType?: string | Function;
    customNodeIcon?: Function;
    customEdgeIcon?: Function;
    renderOrder?: ReadonlyArray<"edges" | "nodes">;
    filterRenderedNodes?: (value?: NodeType, index?: number, array?: NodeType[]) => any;
}
//import { object } from "./generalTypes"
type AnnotationType = {
    type?: string | Function;
    column?: {
        name: string;
    };
    facetColumn?: string;
    bounds?: RawPoint[];
    x?: number;
    y?: number;
    yTop?: number;
    yBottom?: number;
    yMiddle?: number;
    coordinates?: object[];
    key?: string;
    percent?: number;
    style?: GenericObject | ((arg?: GenericObject, index?: number) => GenericObject);
    ids?: string[];
    edge?: any;
    source?: NodeType;
    target?: NodeType;
    id?: string;
    element?: Element;
    label?: string | Element;
    neighbors?: object[];
    isColumnAnnotation?: boolean;
};
type CustomHoverType = boolean | Array<AnnotationType | Function> | object | Function | "all" | "edge" | "node" | "area";
type AnnotationTypes = "marginalia" | "bump" | false;
interface AnnotationLayout {
    type: AnnotationTypes;
    orient?: "nearest" | "left" | "right" | "top" | "bottom" | Array<string>;
    characterWidth?: number;
    noteHeight?: Function | number;
    noteWidth?: Function | number;
    lineWidth?: number;
    lineHeight?: number;
    padding?: number;
    iterations?: number;
    pointSizeFunction?: Function;
    labelSizeFunction?: Function;
    marginOffset?: number;
    axisMarginOverride?: {
        top?: number;
        right?: number;
        bottom?: number;
        left?: number;
    };
}
interface AnnotationHandling {
    dataVersion?: string;
    layout: AnnotationLayout;
}
interface AnnotationProps {
    noteData: {
        eventListeners?: object;
        events?: object;
        onDragEnd?: Function;
        onDragStart?: Function;
        onDrag?: Function;
        type: string | Function;
        editMode?: boolean;
        screenCoordinates?: Array<Array<number>>;
        // What is this type supposed to be? It gets used only in a boolean context
        // I mostly assume this is used to indicate the presence of `nx`, `ny`, `dx`, `dy`
        coordinates?: boolean;
        noteHeight?: Function | number;
        noteWidth?: Function | number;
        x: number | number[];
        y: number | number[];
        nx?: number;
        ny?: number;
        dx?: number;
        dy?: number;
        // TODO: What should this be typed as?
        note: {
            label?: string;
            title?: string;
        };
        i?: number;
        fixedPosition?: boolean;
        label?: string;
    };
}
type GlyphProps = {
    lineHeight: number;
    lineWidth: number;
    value: number;
};
type AxisPart = {
    value: number;
};
interface AxisProps {
    orient: "left" | "right" | "top" | "bottom";
    label?: {
        position?: {
            anchor?: string;
            location?: string;
            rotation?: string;
        };
        name: string;
        locationDistance: number;
    };
    dynamicLabelPosition?: boolean;
    position?: number[];
    rotate?: number;
    tickFormat?: Function;
    size?: number[];
    width?: number;
    height?: number;
    className?: string;
    padding?: number;
    tickValues?: number[] | Function;
    scale?: ScaleLinear<number, number>;
    ticks?: number;
    footer?: boolean;
    tickSize?: number;
    tickLineGenerator?: ({ xy, orient, i, baseMarkProps, className }: {
        xy?: object;
        orient?: string;
        i?: number;
        baseMarkProps?: object;
        className?: string;
    }) => SVGElement;
    baseline?: boolean | "under";
    jaggedBase?: boolean;
    margin?: MarginType;
    center?: boolean;
    axisParts?: AxisPart[];
    annotationFunction?: (args: any) => void;
    glyphFunction?: (args: GlyphProps) => SVGElement;
    axis?: object;
    extentOverride?: number[];
    key?: string | number;
    axisAnnotationFunction?: (args: object) => void;
    xyPoints?: object[];
    marginalSummaryType?: AxisSummaryTypeSettings | OrdinalSummaryTypes;
    showOutboundTickLines?: boolean;
}
type AxisGeneratingFunction = (args: object) => AxisProps;
type TitleType = string | Element | {
    title?: string | Element;
    orient?: string;
};
interface AdvancedInteractionSettings {
    voronoiClipping?: boolean | number;
    voronoiFilter?: Function;
}
interface Interactivity {
    start?: Function;
    during?: Function;
    end?: Function;
    brush?: string;
    extent?: Array<number[]> | number[];
    columnsBrush?: boolean;
    projection?: string;
    projectedColumns?: object;
    startEmpty?: boolean;
}
type InteractionLayerProps = {
    name?: string;
    interaction?: Interactivity;
    overlay?: Array<object>;
    oColumns?: object;
    xScale: ScaleLinear<number, number>;
    yScale: ScaleLinear<number, number>;
    rScale?: ScaleLinear<number, number>;
    svgSize: Array<number>;
    hoverAnnotation?: CustomHoverType;
    interactionOverflow?: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    };
    size: Array<number>;
    projectedYMiddle?: string;
    projectedX: string;
    projectedY: string;
    points?: Array<{
        data: any;
    }>;
    position?: number[];
    enabled?: boolean;
    useSpans?: boolean;
    margin: MarginType;
    projection?: string;
    customDoubleClickBehavior?: Function;
    customClickBehavior?: Function;
    customHoverBehavior?: Function;
    canvasRendering?: boolean;
    disableCanvasInteraction: boolean;
    showLinePoints?: string;
    renderPipeline: object;
    advancedSettings?: AdvancedInteractionSettings;
};
type VoronoiEntryType = {
    voronoiX: number;
    voronoiY: number;
    coincidentPoints: object[];
    type?: string;
    data?: object[];
};
type BaseColumnType = {
    x: number;
    width: number;
};
type InteractionLayerState = {
    overlayRegions: Array<React.ReactElement>;
    props: InteractionLayerProps;
    canvasMap: Map<string, number>;
    interactionCanvas: React.ReactNode;
    SpanOrDiv: Function;
};
type SupportedLegendGlyphs = "fill" | "line";
type ItemType = SupportedLegendGlyphs | Function;
interface LegendItem {
    label: string;
}
interface LegendGroup {
    type?: ItemType;
    styleFn: Function;
    items: LegendItem[];
    label: string;
}
interface LegendProps {
    legendGroups?: LegendGroup[];
    customClickBehavior?: Function;
    title?: string;
    width?: number;
    height?: number;
    orientation?: string;
    position?: "left" | "right";
}
type GenericObject = {
    [key: string]: any;
};
interface MarginType {
    top: number;
    bottom: number;
    left: number;
    right: number;
}
type ProjectionTypes = "vertical" | "horizontal" | "radial";
type ExtentType = number[] | {
    extent?: number[];
    onChange?: Function;
    includeAnnotations?: boolean;
};
interface ProjectedPoint {
    x?: number;
    y?: number;
    xTop?: number;
    xMiddle?: number;
    xBottom?: number;
    yTop?: number;
    yMiddle?: number;
    yBottom?: number;
    parentSummary?: ProjectedSummary;
    parentLine?: ProjectedLine;
    percent?: number;
    data?: object;
    _XYFrameRank?: number;
    style?: Function | object;
    class?: Function | string;
    coordinates?: object[];
}
type PieceLayoutType = (args: {
    type: string | {
        type: string;
    };
    data: any;
    renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
    eventListenersGenerator: any;
    styleFn: (d: object) => object;
    projection: string;
    classFn: (d: object) => string;
    adjustedSize: number[];
    chartSize: number[];
    margin: MarginType;
    rScale?: Function;
    baseMarkProps: object;
}) => GenericObject[];
interface ProjectedLine {
    data: ProjectedPoint[];
    key: string | number;
    __lineIndex?: number;
    coordinates: object[];
}
interface ProjectedSummary {
    _baseData: object[];
    _xyfCoordinates: [number | Date, number | Date][];
    coordinates: {
        x: number;
        y: number;
    }[];
    data: object[];
    y: number;
    x: number;
    parentSummary?: GenericObject;
    bounds: object[] | number[];
    customMark?: Function;
    type?: string;
    curve?: Function;
    processedData?: boolean;
    binMax?: number;
}
type RoughType = {
    canvas: Function;
    generator: Function;
};
type CanvasPostProcessTypes = Function;
type ExtentSettingsType = {
    extent?: Array<number>;
    onChange?: Function;
};
type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
interface AccessorFnType {
    <T>(arg: GenericObject): T;
}
type BasicLineTypes = "line" | "area" | "summary" | "cumulative" | "cumulative-reverse" | "linepercent" | "stackedarea" | "stackedarea-invert" | "stackedpercent" | "bumparea" | "bumparea-invert" | "bumpline" | "stackedpercent-invert" | "difference";
interface LineTypeSettings {
    type: BasicLineTypes | Function;
    simpleLine?: boolean;
    y1?: (d?: ProjectedPoint, index?: number) => number;
    interpolator: string | Function;
}
type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
interface SummaryTypeSettings {
    showSlope?: boolean;
    type: BasicSummaryTypes | Function;
    label?: string | Function;
    cellPx?: number;
    xCellPx?: number;
    yCellPx?: number;
    bins?: number;
    xBins?: number;
    yBins?: number;
    binValue?: Function;
    binMax?: number;
    customMark?: Function;
}
interface RawLine {
    coordinates?: object[];
}
interface RawSummary {
    processedData?: object[];
    coordinates?: object[];
    preprocess?: boolean;
}
interface RawPoint {
}
interface CustomAreaMarkProps {
    d: object;
    baseMarkProps: object;
    margin: object;
    styleFn: Function;
    classFn: Function;
    renderFn: Function;
    chartSize: Function;
    adjustedSize: number[];
}
interface ProjectedBin {
    x: number;
    y: number;
    binItems: object[];
    customMark?: (props: CustomAreaMarkProps) => JSX.Element;
    _xyfCoordinates: Array<number[]>;
    value: number;
    percent: number;
    data: object;
    parentSummary: object;
    centroid: boolean;
}
type GenericAccessor<GenericValue> = (args?: GenericObject, index?: number) => GenericValue;
type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
type RenderPipelineType = {
    [key in VizLayerTypes]?: {
        data?: any;
        ariaLabel?: {
            chart?: string;
            items?: string;
        };
        behavior?: Function;
        styleFn?: Function;
    };
};
type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
type OrdinalSummaryTypeSettings = {
    type: OrdinalSummaryTypes;
    amplitude?: number;
    eventListenersGenerator?: Function;
    flip?: boolean;
    bins?: number;
    axis?: AxisProps;
};
interface AxisSummaryTypeSettings extends OrdinalSummaryTypeSettings {
    summaryStyle?: object;
    pointStyle?: object;
    renderMode?: object | string;
    summaryClass?: string;
    r?: number;
    showPoints?: boolean;
    filter?: Function;
}
interface GeneralFrameProps {
    useSpans?: boolean;
    title?: string | object;
    margin?: number | {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    } | ((args: object) => number | {
        top?: number;
        left?: number;
        right?: number;
        bottom?: number;
    });
    name?: string;
    dataVersion?: string;
    frameKey?: string;
    size?: number[];
    canvasPostProcess?: CanvasPostProcessTypes;
    additionalDefs?: React.ReactNode;
    className?: string;
    customHoverBehavior?: Function;
    customClickBehavior?: Function;
    customDoubleClickBehavior?: Function;
    hoverAnnotation?: CustomHoverType;
    disableContext?: boolean;
    interaction?: Interactivity;
    svgAnnotationRules?: Function;
    htmlAnnotationRules?: Function;
    tooltipContent?: Function;
    optimizeCustomTooltipPosition?: boolean;
    annotations?: object[];
    baseMarkProps?: object;
    backgroundGraphics?: React.ReactNode | Function;
    foregroundGraphics?: React.ReactNode | Function;
    beforeElements?: React.ReactNode;
    afterElements?: React.ReactNode;
    annotationSettings?: AnnotationHandling;
    renderKey?: string | GenericAccessor<string>;
    legend?: object | boolean;
    matte?: object;
    onUnmount?: Function;
    sketchyRenderingEngine?: RoughType;
    frameRenderOrder?: Array<string>;
    disableCanvasInteraction?: boolean;
    interactionSettings?: AdvancedInteractionSettings;
    disableProgressiveRendering?: boolean;
}
interface GeneralFrameState {
    dataVersion?: string;
    adjustedPosition: number[];
    adjustedSize: number[];
    backgroundGraphics?: React.ReactNode | Function;
    foregroundGraphics?: React.ReactNode | Function;
    title: TitleType;
    margin: MarginType;
    legendSettings?: LegendProps;
    renderNumber: number;
}
interface DividedLineProps {
    parameters: Function;
    className: string;
    customAccessors: {
        x: Function;
        y: Function;
    };
    lineDataAccessor: Function;
    data: ProjectedLine[];
    interpolate?: Function;
    searchIterations?: number;
}
declare function DividedLine(props: DividedLineProps): JSX.Element;
interface XYFrameProps extends GeneralFrameProps {
    lines?: RawLine[] | RawLine;
    points?: RawPoint[];
    summaries?: RawSummary[] | RawSummary;
    axes?: Array<AxisProps | AxisGeneratingFunction>;
    xScaleType?: ScaleLinear<number, number>;
    yScaleType?: ScaleLinear<number, number>;
    xExtent?: ExtentType;
    yExtent?: ExtentType;
    invertX?: boolean;
    invertY?: boolean;
    xAccessor?: accessorType<number>;
    yAccessor?: accessorType<number>;
    lineDataAccessor?: accessorType<RawPoint[]>;
    summaryDataAccessor?: accessorType<RawPoint[]>;
    lineType?: LineTypeSettings | string;
    summaryType?: SummaryTypeSettings;
    lineRenderMode?: string | object | Function;
    pointRenderMode?: string | object | Function;
    summaryRenderMode?: string | object | Function;
    showLinePoints?: boolean | string;
    showSummaryPoints?: boolean;
    defined?: Function;
    lineStyle?: GenericAccessor<object> | object;
    pointStyle?: GenericAccessor<object> | object;
    summaryStyle?: GenericAccessor<object> | object;
    lineClass?: GenericAccessor<string> | string;
    pointClass?: GenericAccessor<string> | string;
    summaryClass?: GenericAccessor<string> | string;
    canvasPoints?: GenericAccessor<boolean> | boolean;
    canvasLines?: GenericAccessor<boolean> | boolean;
    canvasSummaries?: GenericAccessor<boolean> | boolean;
    customPointMark?: Function | object;
    customLineMark?: Function;
    customSummaryMark?: Function;
    lineIDAccessor?: GenericAccessor<string> | string;
    minimap?: object;
    fullDataset?: Array<ProjectedPoint | ProjectedBin | ProjectedSummary>;
    projectedLines?: ProjectedLine[];
    projectedSummaries?: Array<ProjectedSummary>;
    projectedPoints?: ProjectedPoint[];
    renderOrder?: ReadonlyArray<"lines" | "points" | "summaries">;
    useSummariesAsInteractionLayer?: boolean;
    filterRenderedLines?: (value: ProjectedLine, index: number, array: ProjectedLine[]) => any;
    filterRenderedSummaries?: (value: ProjectedSummary, index: number, array: ProjectedSummary[]) => any;
    filterRenderedPoints?: (value: ProjectedPoint | ProjectedBin | ProjectedSummary, index: number, array: (ProjectedPoint | ProjectedBin | ProjectedSummary)[]) => any;
}
type AnnotatedSettingsProps = {
    xAccessor?: GenericAccessor<number>[];
    yAccessor?: GenericAccessor<number>[];
    summaryDataAccessor?: GenericAccessor<RawPoint[]>[];
    lineDataAccessor?: GenericAccessor<RawPoint[]>[];
    renderKeyFn?: GenericAccessor<string>;
    lineType?: LineTypeSettings;
    summaryType?: SummaryTypeSettings;
    lineIDAccessor?: GenericAccessor<string>;
    summaries?: object[];
    lines?: object[];
    title?: TitleType;
    xExtent?: number[];
    yExtent?: number[];
};
interface XYFrameState extends GeneralFrameState {
    lineData?: RawLine[] | RawLine;
    pointData?: RawPoint[] | RawPoint;
    summaryData?: RawSummary[] | RawSummary;
    projectedLines?: ProjectedLine[];
    projectedPoints?: ProjectedPoint[];
    projectedSummaries?: ProjectedSummary[];
    fullDataset: Array<ProjectedPoint | ProjectedBin | ProjectedSummary>;
    axesData?: AxisProps[];
    axes?: React.ReactNode[];
    axesTickLines?: React.ReactNode;
    calculatedXExtent: number[];
    calculatedYExtent: number[];
    xAccessor: GenericAccessor<number>[];
    yAccessor: GenericAccessor<number>[];
    xScale: ScaleLinear<number, number>;
    yScale: ScaleLinear<number, number>;
    xExtent: number[];
    yExtent: number[];
    areaAnnotations: object[];
    xyFrameRender: RenderPipelineType;
    canvasDrawing: object[];
    size: number[];
    annotatedSettings: AnnotatedSettingsProps;
    overlay?: object[];
    props: XYFrameProps;
    SpanOrDiv: Function;
}
interface SummaryLayoutType {
    preprocess?: boolean;
    processedData?: boolean;
    summaryType: SummaryTypeSettings;
    data: {
        _xyfCoordinates?: [number | Date, number | Date][];
        coordinates: {
            x: number;
            y: number;
        }[];
    };
    finalXExtent?: number[];
    finalYExtent?: number[];
    size?: number[];
    xScaleType?: ScaleLinear<Number, Number>;
    yScaleType?: ScaleLinear<Number, Number>;
    margin?: MarginType;
    baseMarkProps?: object;
    styleFn?: Function;
    classFn?: Function;
    renderFn?: Function;
    chartSize?: number[];
}
declare const XYFrame: React.NamedExoticComponent<XYFrameProps>;
type OExtentObject = {
    extent?: Array<string>;
    onChange?: Function;
};
type OExtentSettingsType = Array<string> | OExtentObject;
interface RExtentObject {
    extent?: Array<number>;
    onChange?: Function;
    includeAnnotations?: boolean;
}
type PieceTypes = "none" | "bar" | "clusterbar" | "point" | "swarm" | "timeline" | "barpercent";
interface PieceTypeSettings {
    type: PieceTypes;
    offsetAngle?: number;
    angleRange?: number[];
}
interface ProjectedOrdinalSummary {
    originalData?: {
        x?: number;
        y?: number;
    };
    xyPoints?: object[];
    marks?: object[];
    thresholds?: any;
}
interface OrdinalFrameProps extends GeneralFrameProps {
    type?: PieceTypes | PieceTypeSettings;
    summaryType?: OrdinalSummaryTypeSettings;
    connectorType?: Function;
    rAccessor?: accessorType<number>;
    oAccessor?: accessorType<string | number>;
    oExtent?: OExtentSettingsType;
    rExtent?: RExtentObject | number[];
    invertR?: boolean;
    projection?: ProjectionTypes;
    summaryHoverAnnotation?: CustomHoverType;
    pieceHoverAnnotation?: CustomHoverType;
    hoverAnnotation?: CustomHoverType;
    canvasPostProcess?: CanvasPostProcessTypes;
    canvasPieces?: boolean | accessorType<boolean>;
    canvasSummaries?: boolean | accessorType<boolean>;
    connectorClass?: string | accessorType<string>;
    pieceClass?: string | accessorType<string>;
    summaryClass?: string | accessorType<string>;
    connectorRenderMode?: string | accessorType<string | GenericObject>;
    connectorStyle?: object | accessorType<GenericObject>;
    canvasConnectors?: boolean | accessorType<boolean>;
    summaryStyle?: object | accessorType<object>;
    style?: object | accessorType<object>;
    oSort?: (a: string, b: string, c: object[], d: object[]) => number;
    dynamicColumnWidth?: string | accessorType<number>;
    pieceIDAccessor?: string | accessorType<string>;
    ordinalAlign?: string;
    oLabel?: boolean | ((labelValue: string, columnData: any, index: number, column: any) => string | Element);
    renderMode?: object | string | accessorType<string | object>;
    summaryRenderMode?: object | string | accessorType<string | object>;
    pixelColumnWidth?: number;
    oScaleType?: any;
    rScaleType?: () => ScaleLinear<number, number>;
    data: Array<object | number>;
    oPadding?: number;
    axes?: AxisGeneratingFunction | AxisProps | Array<AxisProps | AxisGeneratingFunction>;
    renderOrder?: ReadonlyArray<"pieces" | "summaries" | "connectors">;
    multiAxis?: boolean;
}
interface OrdinalFrameState extends GeneralFrameState {
    pieceDataXY: Array<object>;
    axisData?: AxisProps[];
    axes?: React.ReactNode[];
    axesTickLines?: any;
    oLabels: {
        labels: React.ReactNode;
    };
    columnOverlays: Array<object>;
    oAccessor: Array<Function>;
    rAccessor: Array<Function>;
    oScaleType: ScaleBand<string>;
    rScaleType: ScaleLinear<number, number>;
    oExtent: Array<string>;
    rExtent: Array<number>;
    oScale: ScaleBand<string>;
    rScale: ScaleLinear<number, number>;
    calculatedOExtent: Array<string>;
    calculatedRExtent: Array<number>;
    projectedColumns: object;
    orFrameRender: RenderPipelineType;
    pieceIDAccessor: GenericAccessor<string>;
    type: object;
    summaryType: object;
    props: OrdinalFrameProps;
}
declare const OrdinalFrame: React.NamedExoticComponent<OrdinalFrameProps>;
interface MinimapXYFrameProps extends XYFrameProps {
    renderBefore?: boolean;
    minimap: {
        summaries: object[];
    };
}
declare function MinimapXYFrame(props: MinimapXYFrameProps): JSX.Element;
interface MinimapProps extends XYFrameProps {
    brushStart: Function;
    brush: Function;
    brushEnd: Function;
    xBrushable: boolean;
    yBrushable: boolean;
    yBrushExtent?: number[];
    xBrushExtent?: number[];
    size: number[];
}
declare const MiniMap: (props: MinimapProps) => JSX.Element;
declare function Axis(props: AxisProps): JSX.Element;
declare function Legend(props: LegendProps): JSX.Element;
declare function SemioticAnnotation(props: AnnotationProps): JSX.Element;
declare const Annotation: typeof SemioticAnnotation;
interface BrushProps {
    extent?: number[] | number[][];
    selectedExtent?: number[] | number[][];
    svgBrush: {
        (): () => void;
        move: Function;
    };
    position?: number[];
}
declare function Brush(props: BrushProps): JSX.Element;
declare function InteractionLayer(props: InteractionLayerProps): JSX.Element;
type ContextType = {
    getContext: Function;
    width: number;
    height: number;
    style: {
        width: number;
        height: number;
    };
} | null;
type Props = {
    axes?: Array<React.ReactNode>;
    frameKey?: string;
    xScale: Function;
    yScale: Function;
    dataVersion?: string;
    canvasContext?: RefObject<ContextType>;
    width: number;
    height: number;
    margin: MarginType;
    canvasPostProcess?: Function;
    title?: JSX.Element | string;
    ariaTitle?: string;
    matte?: React.ReactNode;
    matteClip?: boolean;
    renderPipeline: RenderPipelineType;
    baseMarkProps?: object;
    projectedCoordinateNames: object;
    position: Array<number>;
    disableContext?: boolean;
    renderOrder: ReadonlyArray<VizLayerTypes>;
    sketchyRenderingEngine?: RoughType;
    axesTickLines?: React.ReactNode;
    frameRenderOrder: Array<string>;
    additionalVizElements: object;
    disableProgressiveRendering?: boolean;
};
declare function VisualizationLayer(props: Props): JSX.Element;
declare const NetworkFrame: React.NamedExoticComponent<NetworkFrameProps>;
declare function funnelize({ data, steps, key }: {
    data: Array<Object>;
    steps: Array<string>;
    key: string;
}): any[];
type CalculateDataTypes = {
    lineDataAccessor: Array<Function>;
    summaryDataAccessor: Array<Function>;
    summaryStyleFn: Function;
    summaryClassFn: Function;
    summaryRenderModeFn: Function;
    xAccessor: Array<Function>;
    yAccessor: Array<Function>;
    summaries?: Array<RawSummary>;
    points?: Array<RawPoint>;
    lines?: Array<RawLine>;
    lineType: LineTypeSettings;
    showLinePoints?: boolean | string;
    showSummaryPoints?: boolean;
    xExtent?: ExtentType;
    yExtent?: ExtentType;
    invertX?: boolean;
    invertY?: boolean;
    summaryType: SummaryTypeSettings;
    adjustedSize: Array<number>;
    chartSize: Array<number>;
    xScaleType: Function;
    yScaleType: Function;
    baseMarkProps?: object;
    margin: MarginType;
    defined?: Function;
    annotations: object[];
    filterRenderedLines: (value: ProjectedLine, index: number, array: ProjectedLine[]) => any;
    filterRenderedSummaries: (value: ProjectedSummary, index: number, array: ProjectedSummary[]) => any;
    filterRenderedPoints: (value: ProjectedPoint | ProjectedBin | ProjectedSummary, index: number, array: (ProjectedPoint | ProjectedBin | ProjectedSummary)[]) => any;
};
declare const calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, baseMarkProps, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: CalculateDataTypes) => {
    xExtent: any[];
    yExtent: any[];
    projectedLines: ProjectedLine[];
    projectedPoints: ProjectedPoint[];
    projectedSummaries: ProjectedSummary[];
    fullDataset: (ProjectedPoint | ProjectedBin | ProjectedSummary)[];
    calculatedXExtent: any[];
    calculatedYExtent: any[];
};
interface FacetControllerProps {
    children: React.ReactElement;
    sharedRExtent: boolean;
    sharedXExtent: boolean;
    sharedYExtent: boolean;
}
type Props$0 = FacetControllerProps & OrdinalFrameProps & XYFrameProps;
declare function FacetController(props: Props$0): JSX.Element;
interface ResponsiveFrameProps {
    debounce?: number;
    responsiveWidth?: boolean;
    responsiveHeight?: boolean;
    gridDisplay?: boolean;
    elementResizeEvent?: Function;
}
declare const ResponsiveNetworkFrame: {
    (props: (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
    isResizing: NodeJS.Timeout;
    displayName: string;
};
declare const ResponsiveMinimapXYFrame: {
    (props: (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
    isResizing: NodeJS.Timeout;
    displayName: string;
};
declare const ResponsiveXYFrame: {
    (props: (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
    isResizing: NodeJS.Timeout;
    displayName: string;
};
declare const ResponsiveOrdinalFrame: {
    (props: (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
    isResizing: NodeJS.Timeout;
    displayName: string;
};
declare const SparkXYFrame: (props: {
    sparkStyle?: object;
    size?: number | number[];
}) => JSX.Element;
declare const SparkOrdinalFrame: (props: {
    sparkStyle?: object;
    size?: number | number[];
}) => JSX.Element;
declare const SparkNetworkFrame: (props: {
    sparkStyle?: object;
    size?: number | number[];
}) => JSX.Element;
declare function hexbinning({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent: baseXExtent, finalYExtent: baseYExtent, size, xScaleType, yScaleType, margin, baseMarkProps, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): any[] | {
    type: string;
    processedData: boolean;
    coordinates: any[];
    binMax: any;
};
// ADD PRECALC AND EXPOSE PRECALC FUNCTION
declare function heatmapping({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent, finalYExtent, size, xScaleType, yScaleType, margin, baseMarkProps, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): ProjectedSummary | {
    x: number;
    y: number;
}[];
declare const nodesEdgesFromHierarchy: (baseRootNode: any, idAccessor?: (d: any) => any) => {
    edges: any[];
    nodes: any[];
};
export { AnnotationLayer, DividedLine, XYFrame, MinimapXYFrame, MiniMap, Brush, Axis, InteractionLayer, VisualizationLayer, OrdinalFrame, Annotation, NetworkFrame, ResponsiveMinimapXYFrame, ResponsiveOrdinalFrame, ResponsiveNetworkFrame, ResponsiveXYFrame, SparkOrdinalFrame, SparkNetworkFrame, SparkXYFrame, Legend, Mark, funnelize, calculateDataExtent, FacetController, hexbinning, heatmapping, nodesEdgesFromHierarchy, NodeType, EdgeType, GraphSettingsType, NetworkSettingsType, NetworkFrameState, NetworkFrameProps, AnnotationType, CustomHoverType, AnnotationTypes, AnnotationHandling, AnnotationProps, AxisProps, AxisGeneratingFunction, ContextType, GenericObject, MarginType, ProjectionTypes, ExtentType, ProjectedPoint, PieceLayoutType, ProjectedLine, ProjectedSummary, RoughType, CanvasPostProcessTypes, ExtentSettingsType, accessorType, AccessorFnType, BasicLineTypes, LineTypeSettings, BasicSummaryTypes, SummaryTypeSettings, RawLine, RawSummary, RawPoint, CustomAreaMarkProps, ProjectedBin, GenericAccessor, VizLayerTypes, RenderPipelineType, OrdinalSummaryTypes, OrdinalSummaryTypeSettings, AxisSummaryTypeSettings, GeneralFrameProps, GeneralFrameState, AdvancedInteractionSettings, Interactivity, InteractionLayerProps, VoronoiEntryType, BaseColumnType, InteractionLayerState, SupportedLegendGlyphs, ItemType, LegendItem, LegendGroup, LegendProps, OExtentObject, PieceTypes, PieceTypeSettings, ProjectedOrdinalSummary, OrdinalFrameProps, OrdinalFrameState, XYFrameProps, AnnotatedSettingsProps, XYFrameState, SummaryLayoutType };
