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

package/types/src/chart/_ChartSource.d.ts

@@ -0,0 +1,47 @@
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IWorksheet } from '../sheet/IWorksheet';
+import { IChart } from './IChart';
+import { ChartModel } from './model/ChartModel';
+import { CategoryAxisFields, NewChartType } from './model/_NewChart';
+/** The kind a `custom:<kind>` type names (`ChartKinds`), or `null` for any other type. */
+export declare const customKindOf: (type: IChart.Type | string | undefined) => string | null;
+/** The gallery type `type` names. @throws ExpectedError for a type a new chart cannot be yet. */
+export declare function newChartType(type: IChart.Type | string | undefined): NewChartType;
+/**
+ * A cell's number format as a chart part states it: the code, where the cell names a preset, and
+ * for a built-in date the code `locale` renders it with (`Short Date` is built-in format 14, which
+ * en-US Excel writes into a cache as `m/d/yyyy`, I10).
+ */
+export declare const toFormatCode: (format: string, locale?: string) => string;
+/** A range as a chart's formula names it: sheet-qualified and absolute. */
+export declare const formulaOfRange: (range: ICellRange) => string;
+/**
+ * What a series setter's input states for a dimension: an array constant as values written into the
+ * chart, else a reference. Values are always numbers (`numRef`); categories are numbers when every
+ * cell they name holds a number or a date, two lines deep a multi-level reference, else text, as a
+ * new chart states them (DESIGN-CHART §3.5).
+ *
+ * @param host The sheet a bare address is on.
+ */
+export declare function sourceFromInput(input: ICellRange | string, dimension: 'values' | 'categories', host: IWorksheet): ChartModel.DataSource;
+/** How many cells (or array values) a setter's input names; 0 where it names none. */
+export declare function cellCountOf(input: ICellRange | string, host: IWorksheet | null): number;
+/**
+ * An axis's categories from a setter's input: the source each series states, as
+ * {@link sourceFromInput} makes it, and what the axis states of them ({@link categoryAxisOf}), or
+ * `null` where the input is not cells (an array constant, a name that is not one range).
+ *
+ * @param host The sheet a bare address is on.
+ */
+export declare function categoriesFromInput(input: ICellRange | string, host: IWorksheet): {
+    source: ChartModel.DataSource;
+    axis: CategoryAxisFields | null;
+};
+/**
+ * The series of a chart of `type` over `source`, and the chart's model, as Excel makes a new chart
+ * (DESIGN-CHART §3.5).
+ *
+ * @param host The sheet a bare address is on.
+ */
+export declare function createModelFromSource(type: NewChartType, source: ICellRange | ICellRanges | string, host: IWorksheet, seriesBy?: IChart.SeriesBy): ChartModel.ChartSpace;
+//# sourceMappingURL=_ChartSource.d.ts.map

package/types/src/chart/createChart.d.ts

@@ -0,0 +1,26 @@
+import { IStyleCollection } from '../style/IStyleCollection';
+import { IChart } from './IChart';
+export interface CreateChartOptions {
+    /**
+     * The styles the chart's theme references (its colors, its fonts) resolve against.
+     * @defaultValue the default theme
+     */
+    getStyles?: () => IStyleCollection | null;
+}
+/**
+ * Makes a chart outside a workbook: for a slide, a report, or a chart handed from one place to
+ * another as its JSON.
+ *
+ * @param json The chart as {@link IChart.toJSON} answers it (a chart in a workbook restates the
+ * caches of every cell it plots in it), or made by hand with a `model`.
+ *
+ * @remarks
+ * The chart reads its model as it is: its values are the caches the JSON carries, its theme is
+ * the default or `getStyles`', and it has no cells to follow and no movable. Every read and write
+ * of {@link IChart} works, `getLayout` lays it out at a size, and `@sheetxl/react`'s `ChartElement`
+ * draws it. Its writes are not undoable: it has no transaction store.
+ *
+ * The chart's code is loaded with the first chart, so this is asynchronous (DESIGN-CHART §7).
+ */
+export declare function createChart(json: IChart.JSON, options?: CreateChartOptions): Promise<IChart>;
+//# sourceMappingURL=createChart.d.ts.map

package/types/src/chart/index.d.ts

@@ -1,3 +1,7 @@
 export * from './IChart';
 export * from './IChartCollection';
+export * from './model/ChartModel';
+export type { ChartLayout } from './layout/ChartLayout';
+export { ChartKinds, type ChartKind } from './kinds/ChartKind';
+export { createChart, type CreateChartOptions } from './createChart';
 //# sourceMappingURL=index.d.ts.map

package/types/src/chart/kinds/ChartKind.d.ts

@@ -0,0 +1,252 @@
+import { Bounds, Point } from '@sheetxl/utils';
+import { ChartLayout } from '../layout/ChartLayout';
+import { Box, PieSlice, ValueScale } from '../layout/_LayoutUtils';
+import { ChartModel } from '../model/ChartModel';
+import { ResolvedChart } from '../resolve/_ResolvedChart';
+import { DateSlots } from '../math/DateUnitCalcs';
+/**
+ * A kind of chart group: how its series are laid out. The built-in kinds (bar, line, area,
+ * scatter, bubble, pie, of-pie, radar, surface) are registered through {@link ChartKinds} the way
+ * a custom kind is, and a custom group (`ChartModel.Group.type === 'custom'`) is laid out by the kind
+ * registered under `custom:<its kind>`.
+ *
+ * @remarks
+ * The layout lays out the chart's chrome (title, legend, plot area, axes and their scales) and
+ * asks each group's kind for the group: where its bars, points, slices or whatever it draws go.
+ *
+ * @beta The context a kind is given speaks the layout's frame units today: points from the frame's
+ * origin, as the layout works in them (DESIGN-CHART §4), with `at` and `px` to convert. It will
+ * speak px, as {@link ChartLayout} does, before the contract is settled.
+ *
+ * `coordinates` says what the chrome lays out for the kind: `cartesian`, a pair of axes
+ * (category and value, or a scatter's two value axes) whose scales are fit to what
+ * {@link ChartKind.categoryAxis} says the group plots; `plot`, nothing but the plot's inside (a
+ * pie); `own`, the kind lays out the whole plot area and its axes itself (a radar, a surface).
+ */
+export interface ChartKind {
+    /**
+     * The group types the kind lays out: a built-in group type (`'bar'`, `'line'`, `'stock'`...), or
+     * `custom:<kind>` for a custom group's kind.
+     */
+    readonly types: readonly string[];
+    /** What the chrome lays out for a group of the kind. */
+    readonly coordinates: 'cartesian' | 'plot' | 'own';
+    /**
+     * Whether a group of the kind is drawn at all. A group not drawn takes no axis, no legend key and
+     * no room.
+     * @defaultValue `true`
+     */
+    drawn?(group: ResolvedChart.Group): boolean;
+    /**
+     * A cartesian kind: what each series plots against its value axis, which the value axis's scale
+     * is fit to (`tops`), and each series' part of it (`own`). By default the series' values, stacked
+     * as the group's grouping says.
+     */
+    stack?(group: ResolvedChart.Group): ChartKind.Stack;
+    /**
+     * A cartesian kind: which of the group's axes carries its categories, `'x'` along the bottom or
+     * top, `'y'` up a side (horizontal bars), or `null` for a group on two value axes (a scatter),
+     * whose x values the horizontal axis's scale is fit to.
+     * @defaultValue `'x'`
+     */
+    categoryAxis?(group: ResolvedChart.Group): 'x' | 'y' | null;
+    /**
+     * A plot kind: the inside the groups of the kind take of the plot's inside (a pie's square).
+     * Asked of the first plot kind among the chart's drawn groups, with every drawn group of it.
+     */
+    plotRect?(groups: ResolvedChart.Group[], inner: Box): Box;
+    /** A cartesian or plot kind: the group's layout. */
+    layout?(group: ResolvedChart.Group, context: ChartKind.LayoutContext): ChartLayout.GroupLayout;
+    /** An own kind: the whole chart's layout, given its chrome, for the chart's groups, which are all of the kind. */
+    layoutChart?(groups: ResolvedChart.Group[], context: ChartKind.ChartContext): ChartLayout;
+    /**
+     * What the group drew at `point`, in px from the chart's top-left as its layout speaks: the
+     * series there and, where one can be told, its point; `null` where the group drew nothing. A
+     * series drawn later covers one drawn before it, as Excel draws them. Without it a press on the
+     * group's drawing selects the plot area.
+     */
+    hitTest?(group: ChartLayout.GroupLayout, point: Point): ChartKind.Hit | null;
+    /**
+     * The box a point of the group is drawn in, in px: a bar, the marker's box about a line's point,
+     * a slice's box; `null` for a point not drawn. A series' box is the union of its points'.
+     */
+    pointBounds?(group: ChartLayout.GroupLayout, series: number, point: number): Bounds | null;
+}
+export declare namespace ChartKind {
+    /** What a kind's {@link ChartKind.hitTest} found. */
+    interface Hit {
+        /** The index of the series in the group's `series`. */
+        series: number;
+        /** The index of the point, or `null` where the series was hit between its points (a line's segment). */
+        point: number | null;
+    }
+    /** A point in the frame, pt. */
+    interface Pt {
+        x: number;
+        y: number;
+    }
+    /** A group's horizontal and vertical axes. */
+    interface Pair {
+        x: ResolvedChart.Axis;
+        y: ResolvedChart.Axis;
+    }
+    /** A category group's category and value axes. */
+    interface Roles {
+        category: ResolvedChart.Axis;
+        value: ResolvedChart.Axis;
+    }
+    /**
+     * What each series of a group plots against its value axis: its values; stacked, the running sum
+     * of the series before it (positive and negative values summed apart, a blank adding nothing); 100%
+     * stacked, the running share of the category's total of absolute values. `own` is each series'
+     * part of that sum, what a painter that stacks for itself receives.
+     */
+    interface Stack {
+        own: (number | null)[][];
+        tops: (number | null)[][];
+    }
+    /** Text measured in the chart's fonts, pt. */
+    interface TextContext {
+        lineHeight(font: ResolvedChart.Font): number;
+        width(text: string, font: ResolvedChart.Font): number;
+    }
+    /** Data labels placed about what a kind drew, as Excel places them, pt in and px out. */
+    interface LabelsContext {
+        /** A label beside each point (lines, scatters). */
+        points(series: ResolvedChart.Series, points: (Pt | null)[]): (ChartLayout.DataLabelLayout | null)[] | undefined;
+        /** A label at each bar's end, inside or out. */
+        bars(series: ResolvedChart.Series, bars: ({
+            box: Box;
+            base: number;
+            end: number;
+        } | null)[], horizontal: boolean): (ChartLayout.DataLabelLayout | null)[] | undefined;
+        /** A label in each area's span. */
+        areas(series: ResolvedChart.Series, spans: ({
+            x: number;
+            top: number;
+            bottom: number;
+        } | null)[]): (ChartLayout.DataLabelLayout | null)[] | undefined;
+        /** A label about a pie's slice. */
+        pie(series: ResolvedChart.Series, k: number, slice: PieSlice): ChartLayout.DataLabelLayout | null;
+    }
+    /** A series' error bars: where each point is, and how a value along each direction becomes a frame coordinate. */
+    type ErrorBarAxis = (direction: 'x' | 'y') => {
+        horizontal: boolean;
+        toPt: (value: number) => number;
+        plotted: readonly (number | null)[];
+    } | null;
+    /**
+     * What a cartesian or plot kind is given to lay a group out: the plot's inside, the group's axes
+     * and their scales, and the layout's own helpers for what every kind shares (labels, trendlines,
+     * error bars, analysis lines).
+     */
+    interface LayoutContext {
+        readonly chart: ResolvedChart;
+        /** The group's index among the chart's drawn groups. */
+        readonly index: number;
+        /** The plot's inside, pt: where the axes cross and the series are drawn. */
+        readonly inner: Box;
+        /** The plot area's outer rect, pt. */
+        readonly outer: Box;
+        /** A frame coordinate as px from the chart's top-left, which the layout speaks. */
+        at(pt: number): number;
+        /** A length in pt as px. */
+        px(pt: number): number;
+        /** The group's axes; `null` for a plot kind, or a group whose axes the chart lacks. */
+        readonly pair: Pair | null;
+        /** The group's category and value axes; `null` on two value axes, or with no pair. */
+        readonly roles: Roles | null;
+        readonly stack: Stack;
+        /** A value axis's scale. */
+        scale(axis: ResolvedChart.Axis): ValueScale;
+        /** How many categories a category axis has. */
+        categoryCount(axis: ResolvedChart.Axis): number;
+        /** The value on `scale` at which `axis` crosses the axis the scale belongs to. */
+        crossValue(axis: ResolvedChart.Axis, scale: ValueScale): number;
+        /** A date axis's slots, `null` for any other axis. */
+        slotsOf(axis: ResolvedChart.Axis): DateSlots | null;
+        /** The category point `k` of a series is drawn in: its index, or its date's slot; `null` for a point with no place. */
+        pointSlot(axis: ResolvedChart.Axis, k: number): number | null;
+        /** The center of a category on a horizontal category axis. */
+        xOf(axis: ResolvedChart.Axis, index: number): number;
+        /** The center of a category on a vertical category axis. */
+        yOfCategory(axis: ResolvedChart.Axis, index: number): number;
+        /** The y of a value on a vertical value axis. */
+        yOf(scale: ValueScale, axis: ResolvedChart.Axis, value: number): number;
+        /** The x of a value on a horizontal value axis. */
+        xOfValue(scale: ValueScale, axis: ResolvedChart.Axis, value: number): number;
+        /** The series layout every kind states: id, name, values, slots, fill, stroke and trendlines. */
+        base(series: ResolvedChart.Series): Omit<ChartLayout.SeriesLayout, 'marker'>;
+        /** A line or area group's up/down bars, high-low lines and drop lines (DESIGN-CHART §4.7). */
+        analysisLines(scale: ValueScale, tops: (number | null)[][], baseValue: number): Pick<ChartLayout.LineGroupLayout, 'upDownBars' | 'hiLowLines' | 'dropLines'>;
+        /** Lines in the frame cut to the plot, in px. */
+        segments(lines: Pt[][]): ChartLayout.Segment[];
+        /** A series' error bars about its points. */
+        errorBars(series: ResolvedChart.Series, place: (k: number) => Pt | null, axisOf: ErrorBarAxis): ChartLayout.ErrorBarsLayout[] | undefined;
+        readonly text: TextContext;
+        readonly labels: LabelsContext;
+    }
+    /**
+     * What an own kind is given: the chart's chrome as laid out, and the frame to finish the layout in.
+     */
+    interface ChartContext {
+        readonly chart: ResolvedChart;
+        /** The frame's width and height, pt. */
+        readonly width: number;
+        readonly height: number;
+        /** The plot area's outer rect, pt: what the chrome left for the plot. */
+        readonly outer: Box;
+        /** A frame coordinate as px from the chart's top-left, which the layout speaks. */
+        at(pt: number): number;
+        /** A length in pt as px. */
+        px(pt: number): number;
+        readonly title: ChartLayout.TextLayout | null;
+        readonly legend: ChartLayout.LegendLayout | null;
+        readonly text: TextContext;
+        readonly labels: LabelsContext;
+        /** An axis's label for a tick value. */
+        label(axis: ResolvedChart.Axis, tick: number): string;
+        /** The layout with the chrome: the chart area, title and legend about the plot the kind laid out. */
+        frame(plot: {
+            inner: Box;
+            axes: ChartLayout.AxisLayout[];
+            groups: ChartLayout.GroupLayout[];
+            legend?: ChartLayout.LegendLayout | null;
+        }): ChartLayout;
+    }
+}
+/**
+ * The kinds of chart group, by group type: the built-ins, and any a host registers.
+ *
+ * @remarks
+ * The built-in kinds register when the chart module loads (with the first chart, DESIGN-CHART §7),
+ * so before that {@link get} answers `undefined` for `'bar'`; a host's kind registered under a
+ * built-in type keeps its place when they do. A registration is a call, never a side effect of an
+ * import: the package declares no side effects, so a bundler drops a module imported only for one.
+ *
+ * @beta
+ */
+export declare namespace ChartKinds {
+    /**
+     * Registers a kind under each of its types, replacing any earlier registration of them.
+     *
+     * @returns A function that removes the registration.
+     */
+    function register(kind: ChartKind): () => void;
+    /** The kind registered under a group type, or `undefined`. */
+    function get(type: string): ChartKind | undefined;
+    function has(type: string): boolean;
+    /** The registered types. */
+    function getTypes(): string[];
+    /**
+     * Registers the SDK's own kinds, once, under the types no host has taken. The layout calls it when
+     * its module loads.
+     * @hidden
+     */
+    function registerBuiltIns(builtInKinds: (register: (kind: ChartKind) => () => void) => void): void;
+    /** The type a group is registered under: its type, or `custom:<kind>` for a custom group. */
+    function typeOf(group: Pick<ChartModel.Group, 'type' | 'custom'>): string;
+    /** The kind that lays `group` out, or `undefined` when none is registered for it. */
+    function of(group: Pick<ChartModel.Group, 'type' | 'custom'>): ChartKind | undefined;
+}
+//# sourceMappingURL=ChartKind.d.ts.map

package/types/src/chart/kinds/_Area.d.ts

@@ -0,0 +1,3 @@
+import { ChartKind } from './ChartKind';
+export declare const AreaKind: ChartKind;
+//# sourceMappingURL=_Area.d.ts.map

package/types/src/chart/kinds/_Bar.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Columns and horizontal bars, clustered, stacked and 100% stacked. A `standard` grouping is not drawn. */
+export declare const BarKind: ChartKind;
+//# sourceMappingURL=_Bar.d.ts.map

package/types/src/chart/kinds/_BoxWhisker.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Box and whisker plots: each series' values by category as a box, whiskers and outliers. */
+export declare const BoxWhiskerKind: ChartKind;
+//# sourceMappingURL=_BoxWhisker.d.ts.map

package/types/src/chart/kinds/_Bubble.d.ts

@@ -0,0 +1,3 @@
+import { ChartKind } from './ChartKind';
+export declare const BubbleKind: ChartKind;
+//# sourceMappingURL=_Bubble.d.ts.map

package/types/src/chart/kinds/_Funnel.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Funnels: centered bars, the first at the top, beside a category axis the kind lays out. */
+export declare const FunnelKind: ChartKind;
+//# sourceMappingURL=_Funnel.d.ts.map

package/types/src/chart/kinds/_Hierarchy.d.ts

@@ -0,0 +1,31 @@
+import { ResolvedChart } from '../resolve/_ResolvedChart';
+/**
+ * What the sunburst and the treemap share: a series' points as a hierarchy of its categories, and
+ * text wrapped to a width the way Excel wraps a label in a segment or a tile.
+ */
+/** A node of the hierarchy: a category, with the points and categories under it in their order. */
+export interface HierarchyNode {
+    name: string;
+    level: number;
+    value: number;
+    /** The point it is, for a leaf. */
+    point: number | null;
+    /** The top-level category it is under. */
+    branch: string;
+    children: HierarchyNode[];
+}
+/**
+ * The hierarchy of a series' points: each point's categories, the outermost level first, down to
+ * the point; a blank at the end of a point's path ends it there (a leaf a level up). A point with no
+ * positive value is left out, as Excel leaves it out.
+ */
+export declare const hierarchyOf: (series: ResolvedChart.Series) => {
+    roots: HierarchyNode[];
+    depth: number;
+};
+/**
+ * Text wrapped to `width`: at spaces, and within a word too long for a line, between its letters
+ * (S01: "Europ"/"e", "Germ"/"any" in a ring 22.8 pt deep; T01: "Osa"/"ka" in a tile 22.5 pt wide).
+ */
+export declare const wrapText: (text: string, width: number, measure: (text: string) => number) => string[];
+//# sourceMappingURL=_Hierarchy.d.ts.map

package/types/src/chart/kinds/_Histogram.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Histograms, and paretos: a histogram whose series draws its running share. */
+export declare const HistogramKind: ChartKind;
+//# sourceMappingURL=_Histogram.d.ts.map

package/types/src/chart/kinds/_HitKinds.d.ts

@@ -0,0 +1,23 @@
+import { Bounds, Point } from '@sheetxl/utils';
+import { ChartLayout } from '../layout/ChartLayout';
+import { ChartKind } from './ChartKind';
+/** A series drawn as points joined by a line: a line's, a scatter's, a radar's. */
+export interface LineLikeSeries {
+    points: readonly (Point | null)[];
+    marker: ChartLayout.MarkerLayout | null;
+    stroke: ChartLayout.SeriesLayout['stroke'];
+}
+/** How far across a point's box is: its marker's size, or enough to press a bare point. */
+export declare const pointBoxSize: (series: Pick<LineLikeSeries, "marker">) => number;
+/** The box about a line-like series' point `k`; `null` for a gap. */
+export declare const linePointBounds: (series: LineLikeSeries | undefined, k: number) => Bounds | null;
+/**
+ * What a group of line-like series drew at `point`: a marker first (they are drawn over the lines),
+ * the last series' first, as the point; then a line within {@link LINE_TOLERANCE}, as the series
+ * alone. A series with no line is hit at its markers alone.
+ *
+ * @param span Whether each line runs across a gap (`dispBlanksAs span`) rather than breaking at it.
+ * @param closed Whether each line returns to its first point (a radar's).
+ */
+export declare const lineLikeHit: (series: readonly LineLikeSeries[], point: Point, span?: boolean, closed?: boolean) => ChartKind.Hit | null;
+//# sourceMappingURL=_HitKinds.d.ts.map

package/types/src/chart/kinds/_Line.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Lines, standard, stacked and 100% stacked, and stock charts, which are drawn as lines. */
+export declare const LineKind: ChartKind;
+//# sourceMappingURL=_Line.d.ts.map

package/types/src/chart/kinds/_OfPie.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Pie of pie and bar of pie. The plot area is not made square for them. */
+export declare const OfPieKind: ChartKind;
+//# sourceMappingURL=_OfPie.d.ts.map

package/types/src/chart/kinds/_Pie.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Pies and doughnuts. */
+export declare const PieKind: ChartKind;
+//# sourceMappingURL=_Pie.d.ts.map

package/types/src/chart/kinds/_Placeholder.d.ts

@@ -0,0 +1,6 @@
+import { ChartKind } from './ChartKind';
+/** The 2016 types not drawn: the region map, laid out as a placeholder (PLAN-CHART §4). */
+export declare const PLACEHOLDER_TYPES: readonly ["regionMap"];
+/** A region map: a label in the plot saying the type is not drawn. */
+export declare const PlaceholderKind: ChartKind;
+//# sourceMappingURL=_Placeholder.d.ts.map

package/types/src/chart/kinds/_Radar.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Radars: the categories around a circle, each series a polygon or a line through its values up the spokes. The kind lays out the axes. */
+export declare const RadarKind: ChartKind;
+//# sourceMappingURL=_Radar.d.ts.map

package/types/src/chart/kinds/_Scatter.d.ts

@@ -0,0 +1,8 @@
+import { ChartLayout } from '../layout/ChartLayout';
+import { ResolvedChart } from '../resolve/_ResolvedChart';
+import { ChartKind } from './ChartKind';
+/** A scatter group: each point at its x value along the horizontal value axis and its value up the vertical one. */
+export declare const scatterLayout: (group: ResolvedChart.Group, context: ChartKind.LayoutContext) => ChartLayout.ScatterGroupLayout;
+/** Scatters: points on two value axes, with lines straight or smooth, or markers alone. */
+export declare const ScatterKind: ChartKind;
+//# sourceMappingURL=_Scatter.d.ts.map

package/types/src/chart/kinds/_Sunburst.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Sunbursts: a hierarchy of categories as rings. */
+export declare const SunburstKind: ChartKind;
+//# sourceMappingURL=_Sunburst.d.ts.map

package/types/src/chart/kinds/_Surface.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Surfaces, drawn as contours from above. The kind lays out the axes. */
+export declare const SurfaceKind: ChartKind;
+//# sourceMappingURL=_Surface.d.ts.map

package/types/src/chart/kinds/_Treemap.d.ts

@@ -0,0 +1,4 @@
+import { ChartKind } from './ChartKind';
+/** Treemaps: a hierarchy of categories as nested tiles. */
+export declare const TreemapKind: ChartKind;
+//# sourceMappingURL=_Treemap.d.ts.map

package/types/src/chart/kinds/_Waterfall.d.ts

@@ -0,0 +1,18 @@
+import { ChartLayout } from '../layout/ChartLayout';
+import { Box } from '../layout/_LayoutUtils';
+import { ResolvedChart } from '../resolve/_ResolvedChart';
+import { ChartKind } from './ChartKind';
+/**
+ * A 2016 chart's bar labels, a waterfall's (W01, W02 COM rects, the pictures' ink) and a
+ * histogram's (H11, P07): each a line tall with no insets, centered on its bar, touching the bar's
+ * end: above a bar that ends higher than it starts, below one that ends lower. Where a label states
+ * another position it is placed there by belief, at the bar's end inside, its center or its base.
+ */
+export declare const chartExBarLabels: (series: ResolvedChart.Series, bars: ({
+    box: Box;
+    base: number;
+    end: number;
+} | null)[], context: ChartKind.LayoutContext) => (ChartLayout.DataLabelLayout | null)[] | undefined;
+/** Waterfalls: steps up and down from a running total, and totals. */
+export declare const WaterfallKind: ChartKind;
+//# sourceMappingURL=_Waterfall.d.ts.map

package/types/src/chart/kinds/_builtIns.d.ts

@@ -0,0 +1,11 @@
+import { ChartKind } from './ChartKind';
+/**
+ * Registers the kinds the SDK ships, through the same door a host's kind comes in by, the region
+ * map's placeholder among them. Called by the registry before its first use.
+ *
+ * @remarks
+ * A call, not an import for its effect: the package declares no side effects, so a bundler drops
+ * a module imported only for one.
+ */
+export declare function registerBuiltInKinds(register: (kind: ChartKind) => () => void): void;
+//# sourceMappingURL=_builtIns.d.ts.map