semiotic 2.0.2 → 2.0.3

package/dist/semiotic.module.js

@@ -13098,13 +13098,16 @@ const createResponsiveFrame = (ParticularFrame) => {
     return ResponsiveFrame;
 };
 
-const ResponsiveNetworkFrame = createResponsiveFrame(NetworkFrame);
+const ResponsiveNetworkFrame = 
+/*#__PURE__*/ createResponsiveFrame(NetworkFrame);
 
-const ResponsiveMinimapXYFrame = createResponsiveFrame(MinimapXYFrame);
+const ResponsiveMinimapXYFrame = 
+/*#__PURE__*/ createResponsiveFrame(MinimapXYFrame);
 
-const ResponsiveXYFrame = createResponsiveFrame(XYFrame);
+const ResponsiveXYFrame = /*#__PURE__*/ createResponsiveFrame(XYFrame);
 
-const ResponsiveOrdinalFrame = createResponsiveFrame(OrdinalFrame);
+const ResponsiveOrdinalFrame = 
+/*#__PURE__*/ createResponsiveFrame(OrdinalFrame);
 
 const allFrameDefaults = {
     margin: 0
@@ -13155,10 +13158,10 @@ function createSparkFrame(Frame, defaults, frameName) {
     };
 }
 
-const SparkXYFrame = createSparkFrame(XYFrame, xyFrameDefaults);
+const SparkXYFrame = /*#__PURE__*/ createSparkFrame(XYFrame, xyFrameDefaults);
 
-const SparkOrdinalFrame = createSparkFrame(OrdinalFrame, ordinalFrameDefaults);
+const SparkOrdinalFrame = /*#__PURE__*/ createSparkFrame(OrdinalFrame, ordinalFrameDefaults);
 
-const SparkNetworkFrame = createSparkFrame(NetworkFrame, networkFrameDefaults);
+const SparkNetworkFrame = /*#__PURE__*/ createSparkFrame(NetworkFrame, networkFrameDefaults);
 
 export { SemioticAnnotation as Annotation, AnnotationLayer, Axis, Brush, DividedLine, FacetController, InteractionLayer, Legend, SemioticMark as Mark, MiniMap, MinimapXYFrame, NetworkFrame, OrdinalFrame, ResponsiveMinimapXYFrame, ResponsiveNetworkFrame, ResponsiveOrdinalFrame, ResponsiveXYFrame, SparkNetworkFrame, SparkOrdinalFrame, SparkXYFrame, VisualizationLayer, XYFrame, calculateDataExtent, funnelize, heatmapping, hexbinning, nodesEdgesFromHierarchy };

package/dist/setupTests.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/dist/store/TooltipStore.d.ts

@@ -0,0 +1,2 @@
+declare let TooltipProvider: (selector: any) => any, useTooltip: (selector: any) => any;
+export { TooltipProvider, useTooltip };

package/dist/store/createStore.d.ts

@@ -0,0 +1 @@
+export declare function createStore(fn: any): ((selector: any) => any)[];

package/dist/svg/SvgHelper.d.ts

@@ -0,0 +1,37 @@
+export declare const arcTweener: (oldProps: any, newProps: any) => (t: any) => any;
+export declare const drawAreaConnector: ({ x1, x2, y1, y2, sizeX1, sizeY1, sizeX2, sizeY2 }: {
+    x1: any;
+    x2: any;
+    y1: any;
+    y2: any;
+    sizeX1: any;
+    sizeY1: any;
+    sizeX2: any;
+    sizeY2: any;
+}) => string;
+export declare const wrap: (text: any, width: any) => void;
+export declare const hexToRgb: (hex: any) => any;
+export declare const groupBarMark: ({ bins, binMax, relativeBuckets, columnWidth, projection, adjustedSize, summaryI, summary, renderValue, summaryStyle, type, baseMarkProps }: {
+    bins: any;
+    binMax: any;
+    relativeBuckets: any;
+    columnWidth: any;
+    projection: any;
+    adjustedSize: any;
+    summaryI: any;
+    summary: any;
+    renderValue: any;
+    summaryStyle: any;
+    type: any;
+    baseMarkProps: any;
+}) => {
+    marks: any[];
+    points: any[];
+};
+export declare function linearRibbon(): {
+    (pathData: any): any;
+    x(_value: any): (d: any) => any;
+    y(_value: any): (d: any) => any;
+    r(_value: any): (d: any) => any;
+    interpolate(_value: any): any;
+};

package/dist/svg/areaDrawing.d.ts

@@ -0,0 +1,31 @@
+import { SummaryLayoutType } from "../types/xyTypes";
+import { ProjectedSummary } from "../types/generalTypes";
+export declare function lineBounding({ summaryType, data, defined }: {
+    summaryType: any;
+    data: any;
+    defined: any;
+}): any[];
+export declare function contouring({ summaryType, data, finalXExtent, finalYExtent }: {
+    summaryType: any;
+    data: any;
+    finalXExtent: any;
+    finalYExtent: any;
+}): any[];
+export 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;
+};
+export 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;
+}[];
+export declare function trendlining({ preprocess, summaryType: baseSummaryType, data: baseData, finalXExtent, xScaleType }: SummaryLayoutType): any;
+export declare function shapeBounds(coordinates: any): {
+    center: number[];
+    top: number[];
+    left: number[];
+    right: number[];
+    bottom: number[];
+};

package/dist/svg/ckmeans.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Ckmeans algorithm from d3-scale-cluster
+ *
+ * Much of the code that lies within was taken from the simple-statistics library,
+ * which offers a javascript implementation of the ckmeans algorithm originally
+ * designed by Haizhou Wang and Mingzhou Song
+ *
+ * https://cran.r-project.org/web/packages/Ckmeans.1d.dp/
+ * https://github.com/simple-statistics/simple-statistics
+ *
+ * The simple-statistics software license is included below
+ *
+ * --
+ *
+ * ISC License
+ *
+ * Copyright (c) 2014, Tom MacWright
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * Ckmeans clustering is an improvement on heuristic-based clustering
+ * approaches like Jenks. The algorithm was developed in
+ * [Haizhou Wang and Mingzhou Song](http://journal.r-project.org/archive/2011-2/RJournal_2011-2_Wang+Song.pdf)
+ * as a [dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming) approach
+ * to the problem of clustering numeric data into groups with the least
+ * within-group sum-of-squared-deviations.
+ *
+ * Minimizing the difference within groups - what Wang & Song refer to as
+ * `withinss`, or within sum-of-squares, means that groups are optimally
+ * homogenous within and the data is split into representative groups.
+ * This is very useful for visualization, where you may want to represent
+ * a continuous variable in discrete color or style groups. This function
+ * can provide groups that emphasize differences between data.
+ *
+ * Being a dynamic approach, this algorithm is based on two matrices that
+ * store incrementally-computed values for squared deviations and backtracking
+ * indexes.
+ *
+ * Unlike the [original implementation](https://cran.r-project.org/web/packages/Ckmeans.1d.dp/index.html),
+ * this implementation does not include any code to automatically determine
+ * the optimal number of clusters: this information needs to be explicitly
+ * provided.
+ *
+ * ### References
+ * _Ckmeans.1d.dp: Optimal k-means Clustering in One Dimension by Dynamic
+ * Programming_ Haizhou Wang and Mingzhou Song ISSN 2073-4859
+ *
+ * from The R Journal Vol. 3/2, December 2011
+ * @param {Array<number>} data input data, as an array of number values
+ * @param {number} nClusters number of desired classes. This cannot be
+ * greater than the number of values in the data array.
+ * @returns {Array<Array<number>>} clustered input
+ * @example
+ * ckmeans([-1, 2, -1, 2, 4, 5, 6, -1, 2, -1], 3);
+ * // The input, clustered into groups of similar numbers.
+ * //= [[-1, -1, -1, -1], [2, 2, 2], [4, 5, 6]]);
+ */
+export declare function ckmeans(data: any, nClusters: any): any[];

package/dist/svg/frameFunctions.d.ts

@@ -0,0 +1,119 @@
+import * as React from "react";
+import { AxisProps } from "../types/annotationTypes";
+import { MarginType, ProjectionTypes } from "../types/generalTypes";
+import { ScaleLinear } from "d3-scale";
+export declare type TitleType = string | Element | {
+    title?: string | Element;
+    orient?: string;
+};
+declare type PieceType = {
+    type: string;
+    innerRadius?: number;
+};
+declare type SummaryType = {
+    type: string;
+};
+declare type CalculateMarginTypes = {
+    margin?: number | object;
+    axes?: Array<AxisProps>;
+    title: TitleType;
+    oLabel?: any;
+    projection?: ProjectionTypes;
+    size?: number[];
+};
+declare type AdjustedPositionSizeTypes = {
+    size: Array<number>;
+    position?: Array<number>;
+    margin: MarginType;
+    projection?: ProjectionTypes;
+};
+declare type ORFrameConnectionRendererTypes = {
+    type: {
+        type: Function;
+    };
+    data: any;
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: ProjectionTypes;
+    canvasRender: Function;
+    canvasDrawing: Array<object>;
+    baseMarkProps: object;
+    pieceType: PieceType;
+};
+declare type ORFrameSummaryRendererTypes = {
+    data: Array<object>;
+    type: SummaryType;
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: ProjectionTypes;
+    adjustedSize: Array<number>;
+    chartSize: number;
+    baseMarkProps: object;
+    margin: object;
+};
+declare type ORFrameAxisGeneratorTypes = {
+    projection: ProjectionTypes;
+    axis?: Array<AxisProps>;
+    adjustedSize: Array<number>;
+    size: Array<number>;
+    rScale: ScaleLinear<number, number>;
+    rScaleType: ScaleLinear<number, number>;
+    pieceType: PieceType;
+    rExtent: Array<number>;
+    data: Array<object>;
+    maxColumnValues?: number;
+    xyData: Array<{
+        value: number;
+        data: object;
+    }>;
+    margin: MarginType;
+    thresholds?: number[];
+};
+export declare const circlePath: (cx: number, cy: number, r: number) => string;
+export declare const drawMarginPath: ({ margin, size, inset }: {
+    margin: MarginType;
+    size: Array<number>;
+    inset: number;
+}) => string;
+export declare const calculateMargin: ({ margin, axes, title: rawTitle, oLabel, projection, size }: CalculateMarginTypes) => MarginType;
+declare type ObjectifyType = {
+    type?: string | Function;
+};
+export declare function objectifyType(type?: string | Function | ObjectifyType): ObjectifyType;
+export declare function generateOrdinalFrameEventListeners(customHoverBehavior: Function, customClickBehavior: Function): (d?: object, i?: number) => {
+    onMouseEnter?: (e: any) => void;
+    onMouseLeave?: (e: any) => void;
+    onClick?: (e: any) => void;
+};
+export declare function keyAndObjectifyBarData({ data, renderKey, oAccessor, rAccessor: baseRAccessor, originalRAccessor, originalOAccessor, multiAxis }: {
+    data: Array<object | number>;
+    renderKey: Function;
+    oAccessor: Array<Function>;
+    rAccessor: Array<(d: number | object, i?: number) => number>;
+    multiAxis?: boolean;
+    originalOAccessor: Array<string | Function>;
+    originalRAccessor: Array<string | Function>;
+}): {
+    allData: Array<object>;
+    multiExtents?: Array<Array<number>>;
+};
+export declare function adjustedPositionSize({ size, position, margin, projection }: AdjustedPositionSizeTypes): {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+};
+export declare function generateFrameTitle({ title: rawTitle, size }: {
+    title: TitleType;
+    size: Array<number>;
+}): any;
+export declare function orFrameConnectionRenderer({ type, data, renderMode, eventListenersGenerator, styleFn, classFn, projection, canvasRender, canvasDrawing, baseMarkProps, pieceType }: ORFrameConnectionRendererTypes): any[];
+export declare function orFrameSummaryRenderer({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, chartSize, baseMarkProps, margin }: ORFrameSummaryRendererTypes): any;
+export declare const orFrameAxisGenerator: ({ projection, axis, adjustedSize, size, rScale, rScaleType, pieceType, rExtent, data, maxColumnValues, xyData, margin, thresholds }: ORFrameAxisGeneratorTypes) => {
+    axis: JSX.Element[];
+    axesTickLines: Object[];
+};
+export declare const canvasEvent: (canvasContext: any, overlayRegions: any, canvasMap: any, e: any) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/svg/lineDrawing.d.ts

@@ -0,0 +1,99 @@
+import { ProjectedLine, ProjectedPoint, RawLine, RawSummary } from "../types/generalTypes";
+import { AnnotationType } from "../types/annotationTypes";
+declare type SummaryProjectionTypes = {
+    data: Array<RawSummary>;
+    summaryDataAccessor: Array<Function>;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+};
+declare type LineProjectionTypes = {
+    data: Array<RawLine>;
+    lineDataAccessor: Array<Function>;
+    xProp: string;
+    xPropTop?: string;
+    xPropBottom?: string;
+    yProp: string;
+    yPropTop?: string;
+    yPropBottom?: string;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+};
+declare type DifferenceLineProps = {
+    data: Array<ProjectedLine>;
+    yProp: string;
+    yPropTop: string;
+    yPropBottom: string;
+};
+declare type StackedAreaTypes = {
+    type: string;
+    data: Array<ProjectedLine>;
+    xProp: string;
+    yProp: string;
+    yPropMiddle: string;
+    sort?: (a: ProjectedLine, b: ProjectedLine) => number;
+    yPropTop: string;
+    yPropBottom: string;
+};
+declare type CumulativeLineTypes = {
+    type: string;
+    data: Array<ProjectedLine>;
+    yPropMiddle: string;
+    yPropTop: string;
+    yPropBottom: string;
+    y1?: Function;
+};
+declare type LineChartTypes = {
+    data: Array<ProjectedLine>;
+    y1?: Function;
+    x1?: Function;
+    yPropTop: string;
+    yPropMiddle: string;
+    yPropBottom: string;
+    xPropTop: string;
+    xPropMiddle: string;
+    xPropBottom: string;
+};
+declare type RelativeYTypes = {
+    point?: ProjectedPoint | AnnotationType;
+    projectedYMiddle: string;
+    projectedY: string;
+    yAccessor: Array<Function>;
+    yScale: Function;
+    showLinePoints?: boolean | string;
+};
+declare type RelativeXTypes = {
+    point?: ProjectedPoint | AnnotationType;
+    projectedXMiddle: string;
+    projectedX: string;
+    xAccessor: Array<Function>;
+    xScale: Function;
+};
+export declare const projectSummaryData: ({ data, summaryDataAccessor, xAccessor, yAccessor }: SummaryProjectionTypes) => any[];
+export declare const projectLineData: ({ data, lineDataAccessor, xProp, xPropTop, xPropBottom, yProp, yPropTop, yPropBottom, xAccessor, yAccessor }: LineProjectionTypes) => ProjectedLine[];
+export declare const differenceLine: ({ data, yProp, yPropTop, yPropBottom }: DifferenceLineProps) => ProjectedLine[];
+export declare const stackedArea: ({ type, data, xProp, yProp, yPropMiddle, sort, yPropTop, yPropBottom }: StackedAreaTypes) => ProjectedLine[];
+export declare const lineChart: ({ data, y1, x1, yPropTop, yPropMiddle, yPropBottom, xPropTop, xPropMiddle, xPropBottom }: LineChartTypes) => ProjectedLine[];
+export declare const cumulativeLine: ({ data, y1, yPropTop, yPropMiddle, yPropBottom, type }: CumulativeLineTypes) => ProjectedLine[];
+export declare const bumpChart: ({ type, data, xProp, yProp, yPropMiddle, yPropTop, yPropBottom }: StackedAreaTypes) => ProjectedLine[];
+export declare const dividedLine: (parameters: Function, points: Array<Object>, searchIterations?: number) => {
+    key: any;
+    points: any[];
+}[];
+export declare function funnelize({ data, steps, key }: {
+    data: Array<Object>;
+    steps: Array<string>;
+    key: string;
+}): any[];
+export declare function relativeY({ point, projectedY, yAccessor, yScale, showLinePoints }: RelativeYTypes): any;
+export declare function relativeX({ point, projectedXMiddle, projectedX, xAccessor, xScale }: RelativeXTypes): any;
+export declare function findPointByID({ point, idAccessor, lines, xScale, projectedX, xAccessor }: {
+    point: ProjectedPoint;
+    idAccessor: Function;
+    lines: {
+        data: ProjectedLine[];
+    };
+    xScale: Function;
+    projectedX: string;
+    xAccessor: Array<Function>;
+}): ProjectedPoint;
+export {};

package/dist/svg/networkDrawing.d.ts

@@ -0,0 +1,134 @@
+import * as React from "react";
+export declare const radialCurveGenerator: (size: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const circleNodeGenerator: ({ d, i, styleFn, renderMode, key, className, transform, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    transform: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const matrixEdgeGenerator: (size: any, nodes: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const arcEdgeGenerator: (size: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const sankeyArrowGenerator: (props: any) => React.JSX.Element;
+export declare const chordEdgeGenerator: (size: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const dagreEdgeGenerator: (direction: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const sankeyNodeGenerator: ({ d, i, styleFn, renderMode, key, className, transform, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    transform: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const chordNodeGenerator: (size: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const matrixNodeGenerator: (size: any, nodes: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const radialRectNodeGenerator: (size: any, center: any, type: any) => ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const radialLabelGenerator: (node: any, nodei: any, nodeIDAccessor: any, size: any) => React.JSX.Element;
+export declare const hierarchicalRectNodeGenerator: ({ d, i, styleFn, renderMode, key, className, baseMarkProps }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    baseMarkProps: any;
+}) => React.JSX.Element;
+export declare const drawNodes: ({ data, renderKeyFn, customMark, styleFn, classFn, renderMode, canvasDrawing, canvasRenderFn, baseMarkProps, networkSettings }: {
+    data: any;
+    renderKeyFn: any;
+    customMark: any;
+    styleFn: any;
+    classFn: any;
+    renderMode: any;
+    canvasDrawing: any;
+    canvasRenderFn: any;
+    baseMarkProps: any;
+    networkSettings: any;
+}) => any[];
+export declare const drawEdges: (settings: any) => any[];
+export declare function topologicalSort(nodesArray: any, edgesArray: any): false | any[];
+export declare const ribbonLink: (d: any) => any;
+export declare const areaLink: (d: any) => string;
+export declare function circularAreaLink(link: any): any;
+export declare const softStack: (edges: any, nodes: any, sourceAccessor: any, targetAccessor: any, nodeIDAccessor: any) => {
+    hierarchy: {
+        id: string;
+        children: any[];
+        childMap: Map<any, any>;
+    };
+    isHierarchical: boolean;
+    hasLogicalRoot: boolean;
+} | {
+    hierarchy: {};
+    isHierarchical: boolean;
+    hasLogicalRoot: boolean;
+};

package/dist/svg/pieceDrawing.d.ts

@@ -0,0 +1,13 @@
+export declare function pointOnArcAtAngle(center: any, angle: any, distance: any): any[];
+export declare const renderLaidOutPieces: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, baseMarkProps, renderKeyFn, ariaLabel, axis }: {
+    data: any;
+    shouldRender: any;
+    canvasRender: any;
+    canvasDrawing: any;
+    styleFn: any;
+    classFn: any;
+    baseMarkProps: any;
+    renderKeyFn: any;
+    ariaLabel: any;
+    axis: any;
+}) => any[];

package/dist/svg/pieceLayouts.d.ts

@@ -0,0 +1,71 @@
+export declare function pointOnArcAtAngle(center: any, angle: any, distance: any): any[];
+export declare function clusterBarLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, baseMarkProps, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    baseMarkProps: any;
+    rScale: any;
+}): any[];
+export declare function barLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, baseMarkProps, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    baseMarkProps: any;
+    rScale: any;
+}): any[];
+export declare function timelineLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, baseMarkProps, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    baseMarkProps: any;
+    rScale: any;
+}): any[];
+export declare function pointLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, baseMarkProps, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    baseMarkProps: any;
+    rScale: any;
+}): any[];
+export declare function swarmLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, baseMarkProps, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    baseMarkProps: any;
+    rScale: any;
+}): any[];