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

package/types/src/chart/model/_ModelFacts.d.ts

@@ -0,0 +1,112 @@
+import { ChartModel } from './ChartModel';
+/** One formula of a chart's model, as it states it. */
+export interface ChartFormulaSlot {
+    text: string;
+}
+/** A piece of chart text: written in the chart, or read from a cell. */
+export interface ChartTextFacts {
+    /** The literal text, or what the cell held when the file was saved. */
+    text: string | null;
+    /** The {@link ChartFacts.slots} index of the formula naming the cell, or `null` for a literal. */
+    slot: number | null;
+}
+/** A series dimension: the cells it reads, or the values written into the chart. */
+export interface ChartSourceFacts {
+    slot: number | null;
+    /** `{1,2,3}`: a dimension with no cells behind it. */
+    literal: string | null;
+}
+export interface ChartSeriesFacts {
+    /**
+     * What names the series in the model: its `idx`, a derived line its owner's `idx` and `-line`, a
+     * series that states no `idx` its place in the list (`#2`).
+     */
+    key: string;
+    type: string;
+    name: ChartTextFacts;
+    values: ChartSourceFacts;
+    categories: ChartSourceFacts;
+    /** A bubble series' sizes. */
+    sizes: ChartSourceFacts;
+    secondary: boolean;
+    /** The place of the series' group among the plot area's groups, from 0. */
+    group: number;
+}
+export interface ChartAxisFacts {
+    axId: number;
+    /** A deleted axis still scales its series; the read API lists the others. */
+    deleted: boolean;
+    kind: 'category' | 'value' | 'date' | 'series';
+    title: ChartTextFacts;
+    numberFormat: string | null;
+}
+/** What the read API of a chart answers from. */
+export interface ChartFacts {
+    type: string;
+    title: ChartTextFacts;
+    series: ChartSeriesFacts[];
+    axes: ChartAxisFacts[];
+    /** `c:pivotSource/c:name`: the pivot table a pivot chart draws, as the part names it. */
+    pivotSource: string | null;
+    slots: ChartFormulaSlot[];
+}
+/** The slot of each reference in a model, by the reference object. */
+export type ReferenceSlots = ReadonlyMap<object, number>;
+/** A model's formulas: each its slot. */
+export interface ModelSlots {
+    slots: ChartFormulaSlot[];
+    /** The slot of each reference (every element holding an `f`). */
+    referenceSlots: ReferenceSlots;
+    /** The slots no reference takes, those of kept markup: their text, and their slot. */
+    kept: {
+        text: string;
+        slot: number;
+    }[];
+}
+/**
+ * Every formula of `model`, in the order the model states them: each reference's `f`, and every
+ * `f` in markup the model keeps as is.
+ */
+export declare const collectSlots: (model: object) => ModelSlots;
+/** The 2016 types: what a `cx:chartSpace` holds. */
+export declare const CHARTEX_TYPES: ReadonlySet<string>;
+/**
+ * Whether every group is a classic type, or a custom one: the classic model (a `c:chartSpace`'s
+ * axes and series channels) is what the API edits in full. A 2016 type takes its title, legend and
+ * type edits, and is laid out as a placeholder ({@link isLaidOutChart}).
+ */
+export declare const isClassicChart: (model: ChartModel.ChartSpace) => boolean;
+/** Whether every group is of a type the layout lays out: a classic or custom one, or a 2016 type, as a placeholder. */
+export declare const isLaidOutChart: (model: ChartModel.ChartSpace) => boolean;
+/** The type `getChartType` answers for `model`, by Office Scripts' names. */
+export declare const chartTypeOf: (model: ChartModel.ChartSpace) => string;
+/** The plain text of a text body: its paragraphs joined by a newline, blank ones trimmed from the ends. */
+export declare const readBodyText: (body: ChartModel.TextBody) => string;
+/** What the read API answers from a model, and the slot of each of its formulas. */
+export declare const readModelFacts: (model: ChartModel.ChartSpace) => {
+    facts: ChartFacts;
+    slots: ModelSlots;
+};
+/** The cache a reference holds: `numCache` under a `numRef`, `strCache` under a `strRef`, `multiLvlStrCache` under a `multiLvlStrRef`. */
+export type CacheKind = 'num' | 'str' | 'multiLvlStr';
+/** What {@link restateModel} asks of the chart. */
+export interface ModelRestate {
+    /** The engine's text for `slot` once something has moved what it names, else `null`. */
+    movedAt(slot: number): string | null;
+    /** The cache `reference` would hold read now, or `null` where its cells cannot be read and the cache it has stands. */
+    cacheOf?(reference: ChartModel.DataReference, kind: CacheKind): ChartModel.DataCache | null;
+}
+/**
+ * `model` restated for a save, in one pass: the formulas `movedAt` names, and each cache
+ * `cacheOf` reads anew. A new model where something differs, sharing every element that does
+ * not; `model` itself when nothing does.
+ *
+ * @param slots What {@link collectSlots} answered for `model`.
+ *
+ * @remarks
+ * A cache that holds the same points as the one read keeps the one read, and so its spelling. A
+ * cache that differs keeps whatever markup the model kept for the old one. Without `cacheOf` the
+ * caches stand as they are.
+ */
+export declare const restateModel: <T extends object>(model: T, slots: ModelSlots, restate: ModelRestate) => T;
+//# sourceMappingURL=_ModelFacts.d.ts.map

package/types/src/chart/model/_NewChart.d.ts

@@ -0,0 +1,208 @@
+import { IRange } from '@sheetxl/primitives';
+import { IFill } from '../../fill/IFill';
+import { IStroke } from '../../fill/IStroke';
+import { ChartModel } from './ChartModel';
+import { CellKind, Inference, InferenceFamily } from './_Inference';
+/**
+ * The model Excel makes for a new chart (measured 2026-10-17, `probe-chart-insert.ps1`: the part
+ * Excel 16 writes for each gallery type through `AddChart2`, `fixtures/insert/parts/`; held to them by
+ * io-xlsx's `chart.insert.node.test.ts`). Excel's chart style for the type (`c14:style` 102, the
+ * series fills of `colors10`, the text sizes of T1) is stated on every element, as Excel states it.
+ */
+/** The gallery types a new chart can be, by Office Scripts' names. */
+export type NewChartType = 'columnClustered' | 'columnStacked' | 'columnStacked100' | 'barClustered' | 'barStacked' | 'barStacked100' | 'line' | 'lineStacked' | 'lineStacked100' | 'lineMarkers' | 'lineMarkersStacked' | 'lineMarkersStacked100' | 'pie' | 'pieExploded' | 'doughnut' | 'pieOfPie' | 'barOfPie' | 'area' | 'areaStacked' | 'areaStacked100' | 'xyscatter' | 'xyscatterLines' | 'xyscatterLinesNoMarkers' | 'xyscatterSmooth' | 'xyscatterSmoothNoMarkers' | 'bubble' | 'bubble3DEffect' | 'radar' | 'radarMarkers' | 'radarFilled' | 'stockHLC' | 'stockOHLC' | 'stockVHLC' | 'stockVOHLC' | 'doughnutExploded' | 'surface' | 'surfaceWireframe' | 'surfaceTopView' | 'surfaceTopViewWireframe' | '3DColumn' | '3DColumnClustered' | '3DColumnStacked' | '3DColumnStacked100' | '3DBarClustered' | '3DBarStacked' | '3DBarStacked100' | '3DLine' | '3DPie' | '3DPieExploded' | '3DArea' | '3DAreaStacked' | '3DAreaStacked100' | 'waterfall' | 'treemap' | 'sunburst' | 'histogram' | 'pareto' | 'boxwhisker' | 'funnel' | 'regionMap';
+/** What the builder reads of the cells the series name. */
+export interface NewChartCells {
+    /** The formula of `areas`, sheet-qualified and absolute; several areas in parentheses. */
+    formula(areas: readonly IRange.Coords[]): string;
+    kindAt(rowIndex: number, colIndex: number): CellKind;
+    /** The cell's number, or `null` when it holds none. */
+    numberAt(rowIndex: number, colIndex: number): number | null;
+    /** The cell's number format. */
+    formatAt(rowIndex: number, colIndex: number): string;
+    date1904: boolean;
+}
+export interface TypeSpec {
+    group: ChartModel.GroupType;
+    family: InferenceFamily;
+    barDir?: 'col' | 'bar';
+    grouping?: ChartModel.Group['grouping'];
+    markers?: boolean;
+    smooth?: boolean;
+    /** A scatter with markers and no line. */
+    noLine?: boolean;
+    exploded?: boolean;
+    filled?: boolean;
+    /** An of-pie: what its second plot is. */
+    of?: 'pie' | 'bar';
+    /** A stock chart: whether it shows its open (up/down bars), and whether its first series is the volume. */
+    stock?: {
+        open: boolean;
+        volume: boolean;
+    };
+    /** A 3-D form (`bar3DChart`, `line3DChart`, `area3DChart`, `pie3DChart`, `surface3DChart`). */
+    is3D?: boolean;
+    /** Excel's view of a 3-D form, or of a surface seen from above; the chart states its floor and walls with it. */
+    view?: ChartModel.View3D;
+    /**
+     * A series axis of the chart's own (`c:serAx`): a 3-D column, line or area whose series stand
+     * one behind another, and a surface. The other 3-D forms state a third axis id of 0.
+     */
+    seriesAxis?: boolean;
+    /** A surface drawn as lines. */
+    wireframe?: boolean;
+    /** A surface seen from above (`surfaceChart`, which Excel still gives a view). */
+    topView?: boolean;
+    /** A bubble chart with a 3-D effect. */
+    bubble3D?: boolean;
+    /** A 2016 type, written to a `cx:chartSpace`. */
+    chartEx?: boolean;
+    /** A pareto: a histogram whose series sum by category and draw their running totals. */
+    pareto?: boolean;
+    /** How the cells are read when the caller leaves it to them: a region map reads its series by rows. */
+    seriesBy?: 'rows' | 'columns';
+}
+/** What a gallery type is made of: its group type, how its series are read and drawn. */
+export declare const typeSpec: (type: NewChartType) => TypeSpec;
+/** Whether `type` is a gallery type a new chart can be. */
+export declare const isNewChartType: (type: string) => type is NewChartType;
+/** A stock type, which no series can be given (Excel refuses one, `probe-chart-stock-refusals.ps1`). */
+export declare const isStockType: (type: NewChartType) => boolean;
+/**
+ * How many series a new chart of a stock type is made of: its volume, open, high, low and close as
+ * it has them. Excel makes a stock chart of no other count (`probe-chart-stock-refusals.ps1`);
+ * `null` for any other type.
+ */
+export declare const stockSeriesCount: (type: NewChartType) => number | null;
+/** How a type takes its series from the cells. */
+export declare const familyOf: (type: NewChartType) => InferenceFamily;
+/** How a type reads its series when the caller leaves it to the cells; `undefined` lets the cells decide. */
+export declare const seriesByOf: (type: NewChartType) => "rows" | "columns" | undefined;
+/** A 2016 type, which a `cx:chartSpace` holds. */
+export declare const isChartExType: (type: NewChartType) => boolean;
+/**
+ * A type one series can be given on its own. The 3-D forms, the surfaces and the 2016 types take
+ * the whole chart (as Excel's 3-D and bubble types do), and are given to it, not to a series.
+ */
+export declare const isSeriesType: (type: NewChartType) => boolean;
+/** `<a:sp3d/>`, which Excel states on every 3-D shape; kept as markup the model does not read. */
+export declare const SP3D: ChartModel.Unknown;
+/** `spPr` with `<a:sp3d/>` after it. */
+export declare const with3D: (spPr: ChartModel.ShapeProperties) => ChartModel.ShapeProperties;
+/** No fill and no line, as Excel states it on the title, legend and plot area. */
+export declare const NO_SHAPE: () => ChartModel.ShapeProperties;
+export declare const solid: (color: string) => IFill.JSON;
+/** The light line of gridlines, borders and a category axis. */
+export declare const thinLine: (color?: string) => IStroke.JSON;
+export declare const GRIDLINES: () => ChartModel.ChartLines;
+/**
+ * A text body of the chart's gray text at `size` points (T1: title 14, axis titles 10, the rest 9),
+ * in `color` (data labels' is darker).
+ */
+export declare const textBody: (size: number, rotation: number, spaced?: boolean, color?: string) => ChartModel.TextBody;
+/** `rot="-60000000"`: the element's own rotation. */
+export declare const AXIS_ROTATION = -1000;
+export declare const NO_LABELS: () => ChartModel.DataLabels;
+/**
+ * The color of series (or pie point) `index`: series 1-24 measured (S3), the rest the colors part's
+ * own cycle.
+ */
+export declare const colorOf: (index: number) => string;
+export declare const marker: (color: string) => ChartModel.Marker;
+export declare const lineShape: (color: string | null, width: number) => ChartModel.ShapeProperties;
+export declare const fillShape: (color: string) => ChartModel.ShapeProperties;
+/**
+ * States on `out` how a series of `spec`'s type is drawn in `color`, as Excel states it on a new
+ * chart: a fill for bars and areas, a line and a marker for lines and scatters, a color per point
+ * for pies. `index` is the series' place in the chart, `count` its points.
+ */
+export declare const drawSeriesAs: (spec: TypeSpec, out: ChartModel.Series, color: string, index: number, count: number) => void;
+/** A surface's series or value band in `color`: a fill with a line that states nothing, or a 0.75 pt line of a wireframe. */
+export declare const surfaceShape: (spec: TypeSpec, color: string) => ChartModel.ShapeProperties;
+/** The color a series is drawn in: its fill's, else its line's, else its automatic color. */
+export declare const colorOfSeries: (series: ChartModel.Series) => string;
+/** What a series of gallery type `type` is moved into: its group's type and options. */
+export interface SeriesTypeTarget {
+    type: ChartModel.GroupType;
+    barDir?: 'bar' | 'col';
+    grouping?: ChartModel.Group['grouping'];
+    /** A line, scatter or radar series shows markers. */
+    markers: boolean;
+}
+/** The group a series of `type` is drawn in, as `_Grouping` takes it. */
+export declare const seriesTypeTarget: (type: NewChartType) => SeriesTypeTarget;
+/**
+ * `series` drawn as a series of `type` in its own color, as Excel restates it when one series of a
+ * chart changes type (measured 2026-10-17, `probe-chart-edits.ps1` SD5: a column series made a line
+ * with markers states a 2.25 pt line of its fill's color, a 5 pt circle marker of it, `smooth 0`, and
+ * no `invertIfNegative`). The other directions restate what a new chart of `type` states: believed.
+ * A series whose drawing already belongs to `type` is returned as it is.
+ */
+export declare const drawSeriesAsType: (series: ChartModel.Series, type: NewChartType, valueCount: number) => ChartModel.Series;
+/** What a category axis states of its categories. */
+export type CategoryAxisFields = Pick<ChartModel.Axis, 'type' | 'numFmt' | 'lblAlgn' | 'lblOffset' | 'noMultiLvlLbl' | 'baseTimeUnit'>;
+/**
+ * What a category axis states of the categories in `areas`: a date axis with Excel's base unit when
+ * every one that holds anything is a date (I10-I13), else a text axis, and the first cell's format,
+ * linked, where there are categories (I03).
+ */
+export declare function categoryAxisOf(areas: readonly IRange.Coords[] | null, cells: NewChartCells): CategoryAxisFields;
+/**
+ * The model of a new chart of `type` over the series `inference` found.
+ *
+ * @remarks
+ * Every series states its fill (Excel's `colors10` in order), the axes and text state Excel's
+ * style, a chart of two series or more or a pie has a legend at the bottom (at the top for radar), and the
+ * title is automatic: it shows a single series' name, else "Chart Title" (I01-B23). Categories that
+ * are all dates make a date axis with the base unit Excel chooses (DESIGN-CHART §4.2). The caches
+ * are left out: a save restates them from the cells.
+ */
+export declare function createChartModel(type: NewChartType, inference: Inference, cells: NewChartCells): ChartModel.ChartSpace;
+/**
+ * The series axis of a 3-D column, line or area, or of a surface: along the bottom, crossing the
+ * value axis. A 3-D column's draws no line and no tick marks (`bare`); the others draw both.
+ */
+export declare const seriesAxis: (bare: boolean) => ChartModel.Axis;
+/**
+ * What a chart states with a 3-D view: the view, and a floor and two walls of no thickness, drawn
+ * with nothing (a 3-D area's floor with the chart's thin line), each a 3-D shape.
+ */
+export declare const view3D: (view: ChartModel.View3D, linedFloor: boolean) => Pick<ChartModel.Chart, "view3D" | "floor" | "sideWall" | "backWall">;
+/** What a 2016 chart's series is made of: its name, categories and values as references, and the cell naming its categories. */
+export interface ChartExEntry {
+    tx?: ChartModel.SeriesText;
+    cat?: ChartModel.DataSource;
+    val?: ChartModel.DataSource;
+    /** The formula of the cell at the categories' head: what a region map names its categories by. */
+    catName?: string;
+}
+/**
+ * A 2016 chart's model, as Excel makes it for the type (measured 2026-10-22, `probe-chart-insert.ps1`,
+ * the gallery; `chart-insert-gallery.xlsx`): one series drawn and the rest hidden (a box and
+ * whisker draws them all), each with the type's labels and layout options; a treemap's and a
+ * sunburst's values are their tiles' sizes, and a region map colors its regions by its values.
+ * Only a waterfall, a histogram and a box and whisker state a value axis; a treemap, a sunburst
+ * and a region map no axis at all. A pareto's series sum by category and each draws its running
+ * total on a percentage axis. Its title and legend are Excel's; the part's style and colors are the
+ * writer's.
+ *
+ * @param rows Whether the series read their cells along rows, which each reference says.
+ */
+export declare function chartExModel(spec: TypeSpec, entries: readonly ChartExEntry[], rows: boolean): ChartModel.ChartSpace;
+/** A value axis: a scatter's two, or a category chart's one. `formatCode` `null` states no number format. */
+export declare function valueAxis(axId: number, crossAx: number, axPos: 'b' | 'l' | 'r', formatCode: string | null, xy: boolean): ChartModel.Axis;
+/**
+ * The gallery type a chart's first group draws as, which decides how `setData` reads its cells and
+ * draws any series it adds; `null` for a group no gallery type makes (stock, surface, the 2016 types).
+ */
+export declare function newChartTypeOf(model: ChartModel.ChartSpace): NewChartType | null;
+/**
+ * `model` with the series of `fresh` (a new chart's model over the new cells) in place of its own:
+ * the n-th series in plot order takes the n-th new series' name and data and keeps how it is drawn;
+ * new series beyond them join the last series' group drawn as `fresh` draws them; series beyond the
+ * new ones go, and a group left empty with them. A category axis that reads dates as dates (`auto`)
+ * becomes a date axis, or stops being one, as the new categories are dates or not (believed: what
+ * Excel's `SetSourceData` does to formatting is not measured).
+ */
+export declare function replaceSeries(model: ChartModel.ChartSpace, fresh: ChartModel.ChartSpace): ChartModel.ChartSpace;
+//# sourceMappingURL=_NewChart.d.ts.map

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

@@ -0,0 +1,18 @@
+import { ChartModel } from './ChartModel';
+/** How a pie of pie or bar of pie chooses the points of its second plot. */
+export interface OfPieSplit {
+    splitType?: ChartModel.Group['splitType'];
+    splitPos?: number;
+    custSplit?: readonly number[];
+}
+/** How many points Excel's automatic split puts in the second plot: the last third, rounded up. */
+export declare const automaticSplitCount: (count: number) => number;
+/**
+ * By point, whether it is in an of-pie's second plot (measured 2026-10-18, `probe-chart-ofpie.ps1`):
+ * the last `splitPos` by position, those of a value less than `splitPos`, or less than `splitPos`
+ * percent of the total, or those listed (`custSplit`). Excel's automatic split takes the last third
+ * by position, rounded up (O01, O17, O21-O24: 3 of 7, 2 of 4, 4 of 10, 2 of 6, 1 of 3 and of 2; COM
+ * reads it as a split by position).
+ */
+export declare const secondPlotPoints: (split: OfPieSplit, values: readonly (number | null)[]) => boolean[];
+//# sourceMappingURL=_OfPie.d.ts.map

package/types/src/chart/resolve/_LegacyStyles.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The legacy chart styles (`c:style` 1-48): the colors Excel draws for what a chart does not state.
+ *
+ * @remarks
+ * Measured (DESIGN-CHART §3.4, S3): a series with no fill of its own takes its color from these
+ * tables, not from the chart's `colorsN.xml`, even when that part is present. With more series than
+ * a style has colors, the colors repeat in bands, and the bands fade: the middle band is the plain
+ * color, bands before it are shaded and bands after it tinted, by a step that shrinks as bands are
+ * added. Rescued from exhibit-master's `ChartStyles.js`.
+ *
+ * Colors are written as the shapes model writes them (`accent1 shade 54`), for the theme to resolve.
+ */
+/**
+ * The fill of series `offset` (its `c:idx`) of `total` in a chart drawn in a legacy style, as a
+ * color string for the theme.
+ *
+ * @remarks
+ * A `pattern` style cycles its colors and fades by band: series 7 of 7 in style 2 is `accent1 tint 77`.
+ * A `fade` style shades and tints one accent across all the series.
+ */
+export declare function legacySeriesColor(style: number | undefined, offset: number, total: number): string;
+/** The line and fill defaults of a legacy style for the chart's own elements. */
+export interface LegacyElementDefaults {
+    /** Axis lines. */
+    axis: string;
+    gridLineMajor: string;
+    gridLineMinor: string;
+    /** The plot area's fill, `null` for none. */
+    plotArea: string | null;
+}
+/**
+ * The colors of a legacy style for axes, gridlines and the plot area.
+ *
+ * @remarks
+ * In Excel (not PowerPoint) the chart area is always `bg1` with a `tx1 lumMod 15 lumOff 85`
+ * border, and gridlines take that border's color too; the resolver states those itself.
+ */
+export declare function legacyElementDefaults(style: number | undefined): LegacyElementDefaults;
+/**
+ * The width of a line series that states none, in pt, by the style's row of Excel's gallery (1-8,
+ * 9-16, ... 41-48): 3 in the first, 7 in the fourth, 5 in the others.
+ *
+ * @remarks
+ * Measured on lines and scatters in styles 2, 7, 10, 18, 26, 34 and 42 (DESIGN-CHART §3.4,
+ * `probe-chart-markers.ps1`).
+ */
+export declare function legacyLineWidth(style: number | undefined): number;
+//# sourceMappingURL=_LegacyStyles.d.ts.map

package/types/src/chart/resolve/_Resolve.d.ts

@@ -0,0 +1,51 @@
+import { IColor } from '../../color/IColor';
+import { IStyleCollection } from '../../style/IStyleCollection';
+import { ChartModel } from '../model/ChartModel';
+import { ResolvedChart } from './_ResolvedChart';
+/**
+ * What a chart's colors and fonts resolve against: its workbook's theme.
+ */
+export interface ChartTheme {
+    /** A color as the shapes model writes it: `accent1`, `tx1 lumMod 65 lumOff 35`, `#156082`. */
+    parseColor(color: string): IColor;
+    /** The theme's minor (body) font, `+mn-lt`. */
+    minorFont(): string;
+    /** The theme's major (heading) font, `+mj-lt`. */
+    majorFont(): string;
+}
+/** The theme of a workbook's styles. */
+export declare function chartThemeOf(styles: IStyleCollection): ChartTheme;
+/**
+ * What the cells a chart plots hold now, asked for each reference of the model (DESIGN-CHART
+ * §3.3). Each read answers `null` where the cells cannot be read - the reference is not one plain
+ * range of this workbook, its cells are deleted, or the chart is outside a workbook - and the
+ * reference's cache answers then.
+ */
+export interface ChartDataReader {
+    /** The numbers the reference names, by point; `null` is a blank. */
+    values(reference: ChartModel.DataReference): (number | null)[] | null;
+    /** The text the reference names, by point: each cell as it is displayed. */
+    categories(reference: ChartModel.DataReference): string[] | null;
+    /**
+     * A multi-level reference's text, by level and then by point, the innermost level first: each
+     * cell as it is displayed, `''` for a blank.
+     */
+    levels?(reference: ChartModel.DataReference): string[][] | null;
+    /** The one cell's displayed text, for a series name or a title. */
+    text(reference: ChartModel.DataReference): string | null;
+    /** The number format of the reference's first cell. */
+    formatCode(reference: ChartModel.DataReference): string | null;
+}
+/** Formats `value` in `formatCode` the way cells are formatted. */
+export declare const formatValue: (formatCode: string, value: number, date1904: boolean) => string;
+/**
+ * Where a type puts its data labels when they state no position (measured 2026-10-17,
+ * `probe-chart-labels.ps1` D01-D15; Excel states no `dLblPos` for these): outside the end of a
+ * clustered bar, the center of a stacked bar, an area or a doughnut's slice, right of a line's or a
+ * scatter's point, best fit on a pie. A bubble's and a radar's are believed.
+ */
+export declare const defaultLabelPosition: (group: Pick<ChartModel.Group, "type" | "grouping">) => ResolvedChart.LabelPosition;
+/** A series' automatic color, `#RRGGBB`: what it is drawn in where it states no color (the legacy style's, S3). */
+export declare function automaticSeriesColor(model: ChartModel.ChartSpace, theme: ChartTheme, idx: number): string;
+export declare function resolveChart(model: ChartModel.ChartSpace, theme: ChartTheme, data?: ChartDataReader | null): ResolvedChart;
+//# sourceMappingURL=_Resolve.d.ts.map