semiotic 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/semiotic.d.ts

@@ -0,0 +1,1098 @@
+/// <reference types="react" />
+/// <reference types="graceful-fs" />
+// modules
+import * as React from "react";
+import { RefObject } from "react";
+import { ScaleLinear, ScaleBand } from "d3-scale";
+import { Mark } from "semiotic-mark";
+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<object>;
+    position?: number[];
+    enabled?: boolean;
+    useSpans?: boolean;
+    margin: MarginType;
+    projection?: string;
+    customDoubleClickBehavior?: Function;
+    customClickBehavior?: Function;
+    customHoverBehavior?: Function;
+    voronoiHover: 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;
+    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?: object[];
+        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 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;
+}
+interface EdgeType {
+    source?: NodeType;
+    target?: NodeType;
+    d?: string;
+    x?: number;
+    y?: number;
+    sankeyWidth?: number;
+    direction?: string;
+    width?: number;
+    points?: Array<{
+        x: number;
+        y: 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[], size: number[]) => void);
+    fixExistingNodes?: boolean | Function;
+}
+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;
+interface AnnotationLayerProps {
+    useSpans: boolean;
+    legendSettings?: LegendProps;
+    margin: {
+        top?: number;
+        left?: number;
+        right?: number;
+        bottom?: number;
+    };
+    size: number[];
+    axes?: React.ReactNode[];
+    annotationHandling?: AnnotationHandling | AnnotationTypes;
+    annotations: AnnotationType[];
+    pointSizeFunction?: Function;
+    labelSizeFunction?: Function;
+    svgAnnotationRule: Function;
+    htmlAnnotationRule: Function;
+    voronoiHover: Function;
+    position?: number[];
+}
+declare function AnnotationLayer(props: AnnotationLayerProps): JSX.Element;
+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 | accessorType<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?: React.ReactNode;
+    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;
+    voronoiHover: Function;
+    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;
+};
+type State = {
+    canvasDrawing: Array<{
+        tx: number;
+        ty: number;
+        i: number;
+        d: {
+            data: object;
+        };
+        styleFn: Function;
+        markProps: {
+            renderMode?: object;
+            markType: string;
+            width: number;
+            height: number;
+            x: number;
+            y: number;
+            r: number;
+            rx: number;
+            d: string;
+        };
+        renderFn?: Function;
+    }>;
+    dataVersion?: string;
+    renderedElements: Array<React.ReactNode>;
+    focusedPieceIndex: number | null;
+    focusedVisualizationGroup?: string;
+    piecesGroup: object;
+    props: Props;
+    handleKeyDown: Function;
+};
+declare class VisualizationLayer extends React.PureComponent<Props, State> {
+    static defaultProps: {
+        position: number[];
+        margin: {
+            left: number;
+            top: number;
+            right: number;
+            bottom: number;
+        };
+    };
+    constructor(props: Props);
+    updateCtrl: AbortController;
+    componentDidUpdate(lp: object): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(nextProps: Props, prevState: State): {
+        props: Props;
+        renderedElements: any[];
+        dataVersion: string;
+        canvasDrawing: any[];
+        piecesGroup: {};
+    };
+    handleKeyDown: (e: {
+        keyCode;
+    }, vizgroup: string) => void;
+    render(): 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 & XYFrameProps) | (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
+    isResizing: NodeJS.Timeout;
+    displayName: string;
+};
+declare const ResponsiveMinimapXYFrame: {
+    (props: (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
+    isResizing: NodeJS.Timeout;
+    displayName: string;
+};
+declare const ResponsiveXYFrame: {
+    (props: (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & NetworkFrameProps) | (ResponsiveFrameProps & OrdinalFrameProps)): JSX.Element;
+    isResizing: NodeJS.Timeout;
+    displayName: string;
+};
+declare const ResponsiveOrdinalFrame: {
+    (props: (ResponsiveFrameProps & XYFrameProps) | (ResponsiveFrameProps & NetworkFrameProps) | (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 };