@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.11

package/types/src/chart/layout/ChartLayout.d.ts

@@ -0,0 +1,825 @@
+import { Bounds, Point } from '@sheetxl/utils';
+import { IFill } from '../../fill/IFill';
+import { IStroke } from '../../fill/IStroke';
+import { IText } from '../../text/IText';
+/**
+ * A chart laid out: every rect, scale, tick, label string and bar width, in px from the chart's
+ * top-left, with every color concrete. A painter translates it and decides nothing.
+ *
+ * @remarks
+ * Plain data, never stored on the model: it is computed from the chart, its theme and a size.
+ *
+ * What it is drawn with is said in the shapes' own vocabulary, with these promises:
+ * - A fill is an {@link IFill.JSON} (solid, gradient, pattern or image) and `null` for none; a line
+ *   an {@link IStroke.JSON} with its `fill` and `width` stated, and `null` for none; text the
+ *   {@link IText.RunPropertiesJSON} of its run, with its `font.family`, `size` and `color` stated.
+ * - Every color is concrete: `#RRGGBB`, or `rgba(r,g,b,a)` when it is not opaque. Never a theme
+ *   reference (`accent1`), a CSS variable or `light-dark()`.
+ * - Every length is in px: a line's `width` and a run's `size` too, which the model states in points.
+ * - A line's `dash` is as {@link IStroke.JSON} states it, a preset or lengths;
+ *   `IStroke.toDashLengths` reads either in line widths.
+ */
+export interface ChartLayout {
+    /** The chart in px, unzoomed. */
+    width: number;
+    height: number;
+    chartArea: {
+        fill: IFill.JSON | null;
+        border: IStroke.JSON | null;
+        /** The radius of the chart area's corners, measured along the border's path; 0 for square corners. */
+        cornerRadius: number;
+    };
+    title: ChartLayout.TextLayout | null;
+    plotArea: {
+        /** Where the axes cross and the series are drawn. */
+        inner: Bounds;
+        /** The plot area with its axes' labels: what Excel calls the plot area's outer box. */
+        outer: Bounds;
+        fill: IFill.JSON | null;
+        border: IStroke.JSON | null;
+    };
+    /** One per axis of the chart, deleted ones included. */
+    axes: ChartLayout.AxisLayout[];
+    /** One per chart group, in the chart's order. */
+    groups: ChartLayout.GroupLayout[];
+    legend: ChartLayout.LegendLayout | null;
+}
+export declare namespace ChartLayout {
+    interface Insets {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }
+    interface TextLayout {
+        text: string;
+        /** The element's box. */
+        rect: Bounds;
+        /** Space inside the box around the text, in the text's own direction. */
+        insets: Insets;
+        font: IText.RunPropertiesJSON;
+        /**
+         * The text's angle in degrees counterclockwise, about the box's center: 90 reads up, as an axis
+         * title up a side does. Absent for level text.
+         */
+        rotation?: number;
+    }
+    /** The label of one point: its text in a box that fits it. */
+    interface DataLabelLayout extends TextLayout {
+        fill: IFill.JSON | null;
+        border: IStroke.JSON | null;
+    }
+    interface TickLayout {
+        /** The tick's value on the axis scale. */
+        value: number;
+        /** The label, formatted; `''` for a tick without one. */
+        label: string;
+    }
+    type AxisPosition = 'bottom' | 'left' | 'right' | 'top';
+    interface AxisLayoutBase {
+        /** The axis's id in the chart (`axId`). */
+        id: number;
+        /** The id of the axis this one crosses. */
+        crossAxisId: number;
+        position: AxisPosition;
+        /** The axis is laid out, so its series have a scale, but nothing of it is drawn. */
+        deleted: boolean;
+        /**
+         * The axis runs from its maximum to its minimum (`orientation maxMin`): a vertical axis down,
+         * a horizontal one right to left. A reversed category axis puts the first category at the top
+         * or the right, and mirrors each cluster.
+         */
+        reversed: boolean;
+        line: IStroke.JSON | null;
+        majorGridlines: IStroke.JSON | null;
+        /**
+         * The major gridlines, in px: a line across the plot at each tick of a value axis, and between
+         * categories (or on them, `midCat`) of a category axis. Absent when the axis shows none.
+         */
+        gridlines?: Segment[];
+        tickMark: 'none' | 'out' | 'in' | 'cross';
+        /** In px. */
+        tickLength: number;
+        /** `null` when the axis shows no labels. */
+        labelFont: IText.RunPropertiesJSON | null;
+        /** Between the axis line and the near edge of its labels, in px. */
+        labelMargin: number;
+        /**
+         * Where the axis line is, in px: the y of a horizontal axis, the x of a vertical one. On the
+         * plot area's edge named by `position`, unless the axis crosses the other inside the plot (a
+         * scatter's x axis at y = 0 when the y values straddle zero). Labels and tick marks go with it.
+         */
+        lineAt: number;
+        /**
+         * Where the labels and tick marks are, in px as `lineAt`, where they do not go with the line: at
+         * the plot's low or high edge (`tickLblPos` low or high, a 2016 chart's categories) while the line
+         * crosses the other axis inside the plot. Absent where they go with the line.
+         */
+        labelsAt?: number;
+        title: TextLayout | null;
+        /** The display unit label (`dispUnitsLbl`) of an axis whose values are shown in a unit, beside its title. */
+        unitLabel?: TextLayout;
+        /**
+         * The labels are stacked letter over letter (`vert="wordArtVert"`): each label's letters are
+         * joined by `\n`, `labelLineHeight` apart. Along the bottom or top a label too tall for half
+         * the plot's outer height breaks into columns, joined by `\t`, side by side.
+         */
+        labelVertical?: boolean;
+    }
+    /**
+     * A category axis, or a date axis: one category per day, month or year from its first date to
+     * its last, each point in its date's, and labels on the major ticks only.
+     */
+    interface CategoryAxisLayout extends AxisLayoutBase {
+        kind: 'category';
+        /** One label per category, formatted. */
+        categories: string[];
+        /**
+         * One per category, its label as drawn: its lines joined by `\n`, ending in `…` when cut short;
+         * `null` for a category whose label is not shown.
+         */
+        labels: (string | null)[];
+        /**
+         * The angle the labels are drawn at, in degrees counterclockwise. A label turned up ends with its
+         * top right corner on its category's center; turned down, it starts there with its top left
+         * corner. A level label is centered on its category.
+         */
+        labelRotation: number;
+        /** The distance between a label's lines, in px. */
+        labelLineHeight: number;
+        /** Whether the crossing axis crosses between categories (bands) or on them. */
+        crossBetween: 'between' | 'midCat';
+        /**
+         * Multi-level categories: the levels beyond `labels`, the nearest the axis first. Absent when
+         * the axis draws one level.
+         */
+        levels?: CategoryLevelLayout[];
+        /**
+         * Multi-level categories: the lines that part groups of categories, drawn in the axis line's
+         * stroke in place of tick marks, at the plot's ends and between groups, from the axis line out
+         * through the levels they part.
+         */
+        dividers?: Segment[];
+    }
+    /** One level of multi-level categories beyond the innermost: a label per group of categories. */
+    interface CategoryLevelLayout {
+        labels: CategoryGroupLabelLayout[];
+    }
+    /**
+     * The label of a group of categories, centered on the group: level along the bottom or top,
+     * turned to read up beside a vertical axis. Its lines are joined by `\n`.
+     */
+    interface CategoryGroupLabelLayout extends TextLayout {
+        /** The group's first and last categories. */
+        first: number;
+        last: number;
+        /** The distance between the label's lines, in px. */
+        lineHeight: number;
+    }
+    /** A straight line, in px. */
+    interface Segment {
+        from: Point;
+        to: Point;
+    }
+    interface ValueAxisLayout extends AxisLayoutBase {
+        kind: 'value';
+        min: number;
+        max: number;
+        /** Ticks fall at `min + k·majorUnit`, whatever `min` is; on a log axis at `min · majorUnit^k`. */
+        majorUnit: number;
+        /** A logarithmic axis's base: values are placed by their logarithm. */
+        logBase?: number;
+        ticks: TickLayout[];
+        /** Stacked labels (`labelVertical`): the distance between a label's letters, in px. */
+        labelLineHeight?: number;
+    }
+    type AxisLayout = CategoryAxisLayout | ValueAxisLayout;
+    interface MarkerLayout {
+        symbol: 'circle' | 'square' | 'diamond' | 'triangle' | 'x' | 'star' | 'plus' | 'dot' | 'dash';
+        /** In px. */
+        size: number;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+    }
+    interface SeriesLayout {
+        /** What the series maps back to in the chart, for selection. */
+        id: string;
+        name: string;
+        /** One per category; `null` is a gap. */
+        values: (number | null)[];
+        /**
+         * On a date axis, the category each point is drawn in, by point: its date's day, month or
+         * year; `null` for a point with no date. Absent where each point is in the category of its index.
+         */
+        slots?: (number | null)[];
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+        /** Line and scatter groups only. */
+        marker: MarkerLayout | null;
+        /** By point, its data label; `null` for a point without one. Absent when no point has one. */
+        labels?: (DataLabelLayout | null)[];
+        /** The series' trendlines, in the order it lists them. Absent when it has none. */
+        trendlines?: TrendlineLayout[];
+        /** The series' error bars, in the order it lists them. Absent when it has none. */
+        errorBars?: ErrorBarsLayout[];
+    }
+    /** A series' error bars: a bar about each point, along the value axis or a scatter's x axis. */
+    interface ErrorBarsLayout {
+        /** `{series id}:e{index}`. */
+        id: string;
+        direction: 'x' | 'y';
+        /** In px, cut to the plot area: each bar's line, then its caps, each drawn as one line. */
+        paths: Point[][];
+        stroke: IStroke.JSON | null;
+    }
+    /** A line fitted to a series' points, or their moving average. */
+    interface TrendlineLayout {
+        /** `{series id}:t{index}`. */
+        id: string;
+        /** Its entry in the legend. */
+        name: string;
+        /** Its path, in px, cut to the plot area: runs of points, each drawn as one line. */
+        paths: Point[][];
+        stroke: IStroke.JSON | null;
+        /** Its equation and R². */
+        label: TrendlineLabelLayout | null;
+    }
+    /** A run of a trendline label's text; an exponent is raised and smaller. */
+    interface TextRunLayout {
+        text: string;
+        superscript?: boolean;
+    }
+    /** A trendline's label: its lines centered on each other in a box that fits them. */
+    interface TrendlineLabelLayout {
+        rect: Bounds;
+        insets: Insets;
+        font: IText.RunPropertiesJSON;
+        /** Each line's runs, the equation first. */
+        lines: TextRunLayout[][];
+        /** The height of a line, in px. */
+        lineHeight: number;
+        /** The size of a raised run's font, in px. */
+        superscriptSize: number;
+        fill: IFill.JSON | null;
+        border: IStroke.JSON | null;
+    }
+    interface BarSeriesLayout extends SeriesLayout {
+        /**
+         * What each point is plotted as: its value, or its share of the category's total when the
+         * group is 100% stacked. A stacked series sits on the sum of these over the series before it,
+         * positive and negative values summed apart.
+         */
+        plotted: (number | null)[];
+        /** Each point's bar, in px; `null` for a gap. */
+        rects: (Bounds | null)[];
+    }
+    interface LineSeriesLayout extends SeriesLayout {
+        /**
+         * What each point is plotted as: its value, or its share of the category's total when the
+         * group is 100% stacked. A stacked series sits on the sum of these over the series before it.
+         */
+        plotted: (number | null)[];
+        /** Each point, in px; `null` for a gap. */
+        points: (Point | null)[];
+    }
+    /** A bar group. Stacked series are stacked in order, the first nearest the category axis. */
+    interface BarGroupLayout {
+        type: 'bar';
+        /** `[category axis id, value axis id]`. */
+        axisIds: [number, number];
+        /**
+         * `col`: columns, categories along a horizontal axis. `bar`: horizontal bars, categories up a
+         * vertical axis, the first at the bottom, and each cluster's first series lowest.
+         */
+        barDir: 'bar' | 'col';
+        grouping: 'clustered' | 'stacked' | 'percentStacked';
+        /** Every bar in the group, in px. */
+        barWidth: number;
+        /** -100..100: the share of a bar's width neighbors overlap by. A painter's gap is its negation. */
+        overlap: number;
+        /** The gap between clusters as a percentage of a bar's width. */
+        gapWidth: number;
+        series: BarSeriesLayout[];
+        /** Stacked bars: a line from each series' end in a category to its end in the next. */
+        seriesLines?: LinesLayout;
+    }
+    /** A waterfall's bar: one point's step, or its total. */
+    interface WaterfallBarLayout {
+        /** In px. */
+        rect: Bounds;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+        /** The point is a total: its bar runs from zero, not from the bar before it. */
+        total: boolean;
+    }
+    interface WaterfallSeriesLayout extends SeriesLayout {
+        /** By point, the running total its bar ends at, which the next bar starts from; `null` for a blank. */
+        plotted: (number | null)[];
+        /** By point, its bar; `null` for a blank. */
+        bars: (WaterfallBarLayout | null)[];
+    }
+    /**
+     * A waterfall: each point a bar from the running total of the points before it to that total with
+     * its value added, a total a bar from zero to its value; a line from each bar's end to the next bar.
+     */
+    interface WaterfallGroupLayout {
+        type: 'waterfall';
+        /** `[category axis id, value axis id]`. */
+        axisIds: [number, number];
+        /** Every bar, in px. */
+        barWidth: number;
+        /** The gap between bars as a percentage of a bar's width. */
+        gapWidth: number;
+        series: WaterfallSeriesLayout[];
+        /** The lines from each bar's end across to the next bar. */
+        connectorLines?: LinesLayout;
+    }
+    /**
+     * A line group, or a stock group, whose series are lines. Stacked series are stacked in order, the
+     * first at the bottom.
+     */
+    interface LineGroupLayout {
+        type: 'line';
+        axisIds: [number, number];
+        grouping: 'standard' | 'stacked' | 'percentStacked';
+        /** Whether each line is drawn across a blank point (`dispBlanksAs span`) rather than broken at it. */
+        spanBlanks?: boolean;
+        series: LineSeriesLayout[];
+        /** A bar in each category from the first series' value to the last's. */
+        upDownBars?: UpDownBarsLayout;
+        /** A line in each category from its lowest value to its highest. */
+        hiLowLines?: LinesLayout;
+        /** A line from each category's values to the category axis. */
+        dropLines?: LinesLayout;
+    }
+    /** A group's lines of one kind: high-low lines, drop lines or series lines. */
+    interface LinesLayout {
+        /** `g{group index}:` and the kind: `hiLow`, `drop` or `series`. */
+        id: string;
+        /** In px, cut to the plot area. */
+        segments: Segment[];
+        stroke: IStroke.JSON | null;
+    }
+    /** A bar of a group's up/down bars. */
+    interface UpDownBarLayout {
+        /** The category it is in. */
+        category: number;
+        /** The last series' value is above the first's. */
+        up: boolean;
+        /** In px, the box its line is centered on; a bar of equal values has no height. */
+        rect: Bounds;
+    }
+    /** A line or stock group's up/down bars, drawn under its series. */
+    interface UpDownBarsLayout {
+        /** `g{group index}:upDown`. */
+        id: string;
+        bars: UpDownBarLayout[];
+        up: {
+            fill: IFill.JSON | null;
+            stroke: IStroke.JSON | null;
+        };
+        down: {
+            fill: IFill.JSON | null;
+            stroke: IStroke.JSON | null;
+        };
+    }
+    interface AreaSeriesLayout extends SeriesLayout {
+        /**
+         * What each point is plotted as: its value, or its share of the category's total when the
+         * group is 100% stacked. A stacked series sits on the sum of these over the series before it.
+         */
+        plotted: (number | null)[];
+        /** The top edge of the area at each category, in px; `null` for a gap. */
+        points: (Point | null)[];
+    }
+    /** An area group. Series are stacked in order, the first at the bottom. */
+    interface AreaGroupLayout {
+        type: 'area';
+        axisIds: [number, number];
+        grouping: 'standard' | 'stacked' | 'percentStacked';
+        /** The value the first series fills down to: where the category axis crosses the value axis. */
+        baseValue: number;
+        /** That value's y, in px. */
+        baseY: number;
+        series: AreaSeriesLayout[];
+        /** A line from each category's values to the category axis. */
+        dropLines?: LinesLayout;
+    }
+    interface ScatterSeriesLayout extends SeriesLayout {
+        /** One per point, paired with `values`; `null` is a gap. */
+        xValues: (number | null)[];
+        /** Each point, in px; `null` where either value is a gap. */
+        points: (Point | null)[];
+        /** Whether the line through the points is drawn as a curve. */
+        smooth: boolean;
+    }
+    /** A scatter group: points on two value axes, joined by a line when the series has a stroke. */
+    interface ScatterGroupLayout {
+        type: 'scatter';
+        /** `[x axis id, y axis id]`, both value axes. */
+        axisIds: [number, number];
+        /** Whether each line is drawn across a blank point (`dispBlanksAs span`) rather than broken at it. */
+        spanBlanks?: boolean;
+        series: ScatterSeriesLayout[];
+    }
+    interface SliceLayout {
+        /** In degrees clockwise from 12 o'clock. */
+        startAngle: number;
+        endAngle: number;
+        /** What the slice is drawn around: the pie's center, moved out along the slice's middle when it is exploded. */
+        center: Point;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+    }
+    interface PieSeriesLayout extends SeriesLayout {
+        /** The ring the series fills, in px from the center; `innerRadius` is 0 for a pie. */
+        innerRadius: number;
+        outerRadius: number;
+        /** One per point; `null` for a point not drawn (blank). */
+        slices: (SliceLayout | null)[];
+    }
+    /** A pie or doughnut. A pie draws its first series only; a doughnut draws each as a ring. */
+    interface PieGroupLayout {
+        type: 'pie';
+        doughnut: boolean;
+        center: Point;
+        /** In px. */
+        radius: number;
+        series: PieSeriesLayout[];
+    }
+    /** A slice of a pie of pie or bar of pie, in the first pie or the second. */
+    interface OfPieSliceLayout extends SliceLayout {
+        /** In px: the radius of the pie it is in. */
+        radius: number;
+    }
+    /** A point's part of the bar of a bar of pie. */
+    interface OfPieBarLayout {
+        /** In px. */
+        rect: Bounds;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+    }
+    interface OfPieSeriesLayout extends SeriesLayout {
+        /** By point: its slice, of the first pie or the second; `null` for a point in the bar, or not drawn (blank). */
+        slices: (OfPieSliceLayout | null)[];
+        /** By point: its part of the bar, top down in point order; `null` for a point not in it. Absent for a pie of pie. */
+        bars?: (OfPieBarLayout | null)[];
+        /** By point: whether it is in the second plot. */
+        second: boolean[];
+        /** The slice of the first pie that stands for the points of the second plot, of no span where it has none. */
+        other: OfPieSliceLayout;
+    }
+    /**
+     * A pie of pie or bar of pie: a pie of the series' points but those split off it, whose slice for
+     * them (Excel's "Other") faces a second pie or a bar of them. It draws its first series only.
+     */
+    interface OfPieGroupLayout {
+        type: 'ofPie';
+        /** What the second plot is. */
+        of: 'pie' | 'bar';
+        /** The first pie's center and radius, in px. */
+        center: Point;
+        radius: number;
+        /** The second pie, of a pie of pie. */
+        second: {
+            center: Point;
+            radius: number;
+        } | null;
+        /** The bar, of a bar of pie: its box, in px. */
+        bar: Bounds | null;
+        series: OfPieSeriesLayout[];
+        /** The two lines from the ends of the Other slice to the second plot. */
+        seriesLines?: LinesLayout;
+    }
+    interface BubbleSeriesLayout extends ScatterSeriesLayout {
+        /** By point, its bubble's radius in px, centered on its point; `null` for a point with none. */
+        radii: (number | null)[];
+        /** By point, whether its size is negative: its bubble is drawn in the group's `negative` style. */
+        negative: boolean[];
+    }
+    /** A bubble group: a scatter whose points are bubbles sized by the points' bubble sizes. */
+    interface BubbleGroupLayout {
+        type: 'bubble';
+        /** `[x axis id, y axis id]`, both value axes. */
+        axisIds: [number, number];
+        series: BubbleSeriesLayout[];
+        /** How a bubble of a negative size is drawn: hollow. */
+        negative: {
+            fill: IFill.JSON | null;
+            stroke: IStroke.JSON | null;
+        };
+    }
+    interface RadarSeriesLayout extends SeriesLayout {
+        /** By category, the point on its spoke; `null` for a blank. Joined in order, the last to the first. */
+        points: (Point | null)[];
+    }
+    /**
+     * A radar chart: spokes from its center, one per category clockwise from 12 o'clock, the value axis
+     * up the first, its values' rings through the spokes, and the series' polygons. The group draws its
+     * axes; the chart's axes are laid out (their scale) and draw nothing.
+     */
+    interface RadarGroupLayout {
+        type: 'radar';
+        axisIds: [number, number];
+        /** The series' polygons are filled, not lines. */
+        filled: boolean;
+        center: Point;
+        /** In px: the value axis's maximum's distance from the center. */
+        radius: number;
+        spokes: Segment[];
+        spokeStroke: IStroke.JSON | null;
+        /** The ring of each major tick past the minimum, a polygon through the spokes. */
+        rings: Point[][];
+        ringStroke: IStroke.JSON | null;
+        /** By category, its label beyond its spoke's end; `null` where the axis shows none. */
+        categoryLabels: (TextLayout | null)[];
+        /** The value axis's labels, left of the first spoke. */
+        valueLabels: TextLayout[];
+        series: RadarSeriesLayout[];
+    }
+    /** A band of a surface's values: the parts of the surface between two of its value axis's ticks. */
+    interface SurfaceBandLayout {
+        from: number;
+        to: number;
+        fill: IFill.JSON | null;
+        /** A wireframe's line. */
+        stroke: IStroke.JSON | null;
+        /** In px. */
+        polygons: Point[][];
+    }
+    /**
+     * A surface seen from the top, a contour: a grid of a column per category and a row per series,
+     * the surface through its values colored by band. The group draws its axes; the chart's axes are
+     * laid out (their scale) and draw nothing.
+     */
+    interface SurfaceGroupLayout {
+        type: 'surface';
+        axisIds: number[];
+        /** The bands are lines, not fills. */
+        wireframe: boolean;
+        /** A 3-D surface, which Excel draws in perspective, drawn flat from above. */
+        flat: boolean;
+        /** In px. */
+        grid: Bounds;
+        bands: SurfaceBandLayout[];
+        /** Below the grid, a label at each category. */
+        categoryLabels: TextLayout[];
+        /** Right of the grid, a label at each series. */
+        seriesLabels: TextLayout[];
+        series: SeriesLayout[];
+    }
+    /** A segment of a sunburst: one category of the hierarchy, or one point, as a ring sector. */
+    interface SunburstSegmentLayout {
+        /** Its depth in the hierarchy: 0 for a top-level category. */
+        level: number;
+        name: string;
+        /** Its value: its point's, or the sum of the points under it. */
+        value: number;
+        /** In degrees clockwise from 12 o'clock. */
+        startAngle: number;
+        endAngle: number;
+        /** In px from the center. */
+        innerRadius: number;
+        outerRadius: number;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+        /** The point a leaf is, by its index in the series; `null` for a category with points under it. */
+        point: number | null;
+        /** Its name along the radius, wrapped to the ring's depth; absent where it does not fit. */
+        label?: TextLayout;
+    }
+    interface SunburstSeriesLayout extends SeriesLayout {
+        /** Every segment, a category before the ones under it. */
+        segments: SunburstSegmentLayout[];
+    }
+    /**
+     * A sunburst: the hierarchy of a series' categories as rings about a hole, the top-level
+     * categories innermost, each segment's angle its value's share; only the first series is drawn.
+     */
+    interface SunburstGroupLayout {
+        type: 'sunburst';
+        center: Point;
+        /** In px: the outer ring's outer edge. */
+        radius: number;
+        /** In px: the hole's radius. */
+        hole: number;
+        series: SunburstSeriesLayout[];
+    }
+    /** A bin of a histogram, as labeled on its category axis. */
+    interface HistogramBinLayout {
+        kind: 'underflow' | 'bin' | 'overflow';
+        /** The bin's bounds; an underflow bin has no `from`, an overflow bin no `to`. */
+        from: number | null;
+        to: number | null;
+        label: string;
+    }
+    interface HistogramSeriesLayout extends SeriesLayout {
+        /** By bin, its bar, in px; `null` for an empty bin. */
+        bars: (Bounds | null)[];
+        /** A pareto's line, listed as a series of its own after the bars' (`series/<key>-line`): its points at the bars' centers, in px. */
+        line?: {
+            points: (Point | null)[];
+            axisId: number;
+        };
+    }
+    /**
+     * A histogram: a bar per bin, the bins along the category axis with no gap between them unless
+     * the group states one; a pareto's bars largest first with a line of the running share, drawn
+     * from the first bar's center to the last's against a percentage axis on the right.
+     */
+    interface HistogramGroupLayout {
+        type: 'histogram';
+        /** `[category axis id, value axis id]`. */
+        axisIds: [number, number];
+        bins: HistogramBinLayout[];
+        /** Every bar, in px. */
+        barWidth: number;
+        /** The gap between bars as a percentage of a bar's width. */
+        gapWidth: number;
+        series: HistogramSeriesLayout[];
+    }
+    /** One box of a box and whisker series: a category's statistics as drawn. */
+    interface BoxLayout {
+        /** The box, from the first quartile to the third, in px. */
+        rect: Bounds;
+        /** The median's line across the box, in px. */
+        median: Segment;
+        /** The whisker's line from the box's top up and from its bottom down, each with its cap, in px; absent where it has no length. */
+        whiskerHigh?: {
+            line: Segment;
+            cap: Segment;
+        };
+        whiskerLow?: {
+            line: Segment;
+            cap: Segment;
+        };
+        /** The x at the mean, in px: its center and the size of its box. */
+        mean?: {
+            center: Point;
+            size: number;
+        };
+        /** A dot at each value beyond the whiskers: its center and diameter, in px. */
+        outliers: {
+            center: Point;
+            size: number;
+        }[];
+        /** A dot at each value within the whiskers. */
+        innerPoints: {
+            center: Point;
+            size: number;
+        }[];
+        fill: IFill.JSON | null;
+        /** The outline, median, whiskers and marks. */
+        stroke: IStroke.JSON | null;
+        stats: {
+            min: number;
+            q1: number;
+            median: number;
+            q3: number;
+            max: number;
+            mean: number;
+        };
+    }
+    interface BoxWhiskerSeriesLayout extends SeriesLayout {
+        /** By category, its box; `null` for a category the series has no values in. */
+        boxes: (BoxLayout | null)[];
+        /** The line from each box's mean to the next's, where the series shows one. */
+        meanLine?: LinesLayout;
+    }
+    /** A box and whisker group: a box per series in each category, the series side by side as a cluster. */
+    interface BoxWhiskerGroupLayout {
+        type: 'boxWhisker';
+        /** `[category axis id, value axis id]`. */
+        axisIds: [number, number];
+        /** Every box, in px. */
+        boxWidth: number;
+        /** The gap between clusters as a percentage of a category. */
+        gapWidth: number;
+        series: BoxWhiskerSeriesLayout[];
+    }
+    /** A tile of a treemap: one leaf, as a rect in its branch's fill. */
+    interface TreemapTileLayout {
+        /** Its depth in the hierarchy: 0 for a top-level category. */
+        level: number;
+        name: string;
+        value: number;
+        /** In px. */
+        rect: Bounds;
+        fill: IFill.JSON | null;
+        stroke: IStroke.JSON | null;
+        /** The point it is, by its index in the series; `null` for a category with points under it. */
+        point: number | null;
+        /** Its label in its bottom-left corner, wrapped to its width; absent where it does not fit. */
+        label?: TextLayout;
+    }
+    /** A top-level category's label: over its tiles' top-left corner, or on a banner above them. */
+    interface TreemapParentLabelLayout {
+        name: string;
+        label: TextLayout;
+        /** The banner, in px, where the labels are banners. */
+        banner?: {
+            rect: Bounds;
+            fill: IFill.JSON | null;
+            stroke: IStroke.JSON | null;
+        };
+    }
+    interface TreemapSeriesLayout extends SeriesLayout {
+        /** Every leaf's tile. */
+        tiles: TreemapTileLayout[];
+        /** The top-level categories' labels, in their order; none where the series shows none. */
+        parents: TreemapParentLabelLayout[];
+    }
+    /**
+     * A treemap: the hierarchy of a series' categories as nested rects filling the plot area, each
+     * top-level category a branch in one fill; only the first series is drawn.
+     */
+    interface TreemapGroupLayout {
+        type: 'treemap';
+        /** The plot area, in px: what the tiles fill. */
+        plot: Bounds;
+        parentLabels: 'none' | 'banner' | 'overlapping';
+        series: TreemapSeriesLayout[];
+    }
+    interface FunnelSeriesLayout extends SeriesLayout {
+        /** By point, its bar, in px; `null` for a blank or a value of no width. */
+        bars: (Bounds | null)[];
+    }
+    /**
+     * A funnel: a bar per point, the first at the top, each as wide as its value's share of the
+     * largest and centered on the plot, beside a category axis the group draws itself.
+     */
+    interface FunnelGroupLayout {
+        type: 'funnel';
+        /** `[category axis id]`; the axis is laid out by the group. */
+        axisIds: number[];
+        /** The plot's inside, in px: the bars' room right of the axis. */
+        plot: Bounds;
+        /** Every bar, in px. */
+        barHeight: number;
+        /** The gap between bars as a percentage of a bar's height. */
+        gapWidth: number;
+        /** The category axis's line, in px; `null` for none. */
+        axisLine: Segment | null;
+        axisStroke: IStroke.JSON | null;
+        /** By point, its category's label left of the axis; `null` where the axis shows none. */
+        categoryLabels: (TextLayout | null)[];
+        series: FunnelSeriesLayout[];
+    }
+    /**
+     * A group of a kind the host registered (`ChartKinds`): what the kind's layout answers. The kind's
+     * painter reads `data`; nothing else does.
+     */
+    interface CustomGroupLayout {
+        type: 'custom';
+        /** The kind's name, as registered (`custom:<kind>`). */
+        kind: string;
+        /** The ids of the axes the group draws against; none for a kind that takes the plot alone. */
+        axisIds: number[];
+        /** The plot's inside, in px: where the kind drew. */
+        plot: Bounds;
+        series: SeriesLayout[];
+        /** The kind's own geometry, for its painter; JSON. */
+        data?: unknown;
+    }
+    /**
+     * A group of a type not drawn yet (the 2016 types): the plot it would draw in, and a label there
+     * saying so, in place of what it would draw. The first such group of a chart carries the label.
+     */
+    interface PlaceholderGroupLayout {
+        type: 'regionMap';
+        /** None: the type's axes are not drawn. */
+        axisIds: number[];
+        /** The plot area, in px. */
+        plot: Bounds;
+        series: SeriesLayout[];
+        /** "<type> rendering is not supported yet", centered in the plot. */
+        label?: TextLayout;
+    }
+    type GroupLayout = BarGroupLayout | WaterfallGroupLayout | SunburstGroupLayout | HistogramGroupLayout | BoxWhiskerGroupLayout | TreemapGroupLayout | FunnelGroupLayout | LineGroupLayout | AreaGroupLayout | ScatterGroupLayout | BubbleGroupLayout | PieGroupLayout | OfPieGroupLayout | RadarGroupLayout | SurfaceGroupLayout | CustomGroupLayout | PlaceholderGroupLayout;
+    interface LegendEntryLayout {
+        seriesId: string;
+        /** An entry for one point of the series (a pie's slice), rather than for the series. */
+        pointIndex?: number;
+        /** An entry for the series' trendline of this index (its `trendlines`), rather than for the series. */
+        trendlineIndex?: number;
+        /** An entry for a surface's value band of this index (its group's `bands`), rather than for a series. */
+        bandIndex?: number;
+        text: string;
+        /** The entry: its key's slot and its text. */
+        rect: Bounds;
+        /** The key, inside the entry. The text starts as far after it as the key starts into the entry. */
+        keyRect: Bounds;
+        /** The key's colors, where they are not its series' (a waterfall's increase, decrease and total). */
+        swatch?: {
+            fill: IFill.JSON | null;
+            stroke: IStroke.JSON | null;
+        };
+    }
+    interface LegendLayout {
+        rect: Bounds;
+        orient: 'horizontal' | 'vertical';
+        font: IText.RunPropertiesJSON;
+        entries: LegendEntryLayout[];
+    }
+}
+//# sourceMappingURL=ChartLayout.d.ts.map