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

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

@@ -0,0 +1,1066 @@
+import { Properties as CSSProperties } from 'csstype';
+import { ITransaction } from '../transaction';
+import { ICellRange } from '../cellRange';
+import { IWorksheet } from '../sheet/IWorksheet';
+import { IMovable } from '../movable/IMovable';
+import { IStyleCollection } from '../style/IStyleCollection';
+import { IFill } from '../fill/IFill';
+import { IStroke } from '../fill/IStroke';
+import { IShapeStyle } from '../shape/IShapeStyle';
+import { ITextBoxStyle } from '../shape/ITextBoxStyle';
+import { IColor } from '../color/IColor';
+import { IFont } from '../font/IFont';
+import { IFontStyle } from '../font/IFontStyle';
+import { IChart } from './IChart';
+import { ChartModel } from './model/ChartModel';
+import { ChartFacts, ChartSourceFacts, ChartTextFacts } from './model/_ModelFacts';
+import { ModelEdit, FontPatch } from './model/_Edits';
+import { ResolvedChart } from './resolve/_ResolvedChart';
+import { ChartTheme } from './resolve/_Resolve';
+import { ChartLayout } from './layout/ChartLayout';
+import * as Edits from './model/_Edits';
+/**
+ * The parts of a chart its API sets: title, legend, axes, series, markers and data labels. Each is a
+ * view onto the chart's model, named by what does not change (a series' `idx`, an axis' `axId`), so
+ * one held across edits stays good. Every setter is one model edit (`model/_Edits.ts`), and every
+ * `update` the edits of its fields, as one step to undo.
+ */
+/** What the parts read and write through: the chart. */
+export interface ChartPartsHost {
+    /** The chart the parts are of. */
+    chart(): IChart;
+    /** The chart area: the parent of the parts at the top. */
+    chartArea(): IChart.IElement;
+    /** The group part at `index`, held across edits. */
+    group(index: number): ChartGroup;
+    model(): ChartModel.ChartSpace | null;
+    facts(): ChartFacts | null;
+    /**
+     * Applies `edit` to the model as one step, or throws where the chart cannot be edited: a pivot
+     * chart, or a 2016 type unless `anyType` (the title and legend are edited on every type).
+     */
+    edit(description: string, edit: ModelEdit, options?: ITransaction.OperationOptions, anyType?: boolean): void;
+    /** The chart resolved against its theme and cells; `null` without a model. */
+    resolved(): ResolvedChart | null;
+    /** The chart laid out at its size, or Excel's default where it has none. */
+    layout(): ChartLayout | null;
+    theme(): ChartTheme;
+    styles(): IStyleCollection | null;
+    movable(): IMovable | null;
+    /** The sheet a bare address in a setter is on. */
+    sheet(): IWorksheet | null;
+    /** The series part for the series keyed `key` (its `idx`), held across edits. */
+    seriesPart(key: string): IChart.ISeries | null;
+    text(facts: ChartTextFacts): string | null;
+    formula(slot: number | null): string | null;
+    formulaOf(source: ChartSourceFacts): string | null;
+    range(slot: number | null): ICellRange | null;
+}
+/** Excel's text color where a chart states none: its gray, and its default size and weight. */
+export interface FontDefaults {
+    size: number;
+    bold: boolean;
+    color?: string;
+}
+/**
+ * An {@link IFontStyle} over the default run of an element's text (`txPr`, or rich text): reads
+ * fall back to the chart's own font, then to Excel's; writes go to `write` as one edit.
+ */
+export declare class ChartFont implements IFontStyle {
+    private readonly _host;
+    private readonly _run;
+    private readonly _write;
+    private readonly _description;
+    private readonly _defaults;
+    constructor(_host: ChartPartsHost, _run: () => ChartModel.RunProperties | undefined, _write: (patch: FontPatch) => ModelEdit, _description: string, _defaults: FontDefaults);
+    private _pick;
+    getFamily(): string;
+    setFamily(family: string | null, options?: ITransaction.OperationOptions): this;
+    getName(): string;
+    setName(name: string | null, options?: ITransaction.OperationOptions): this;
+    getThemeFamily(): IFontStyle.ThemeFamily | null;
+    getFallbacks(): string[];
+    setFallbacks(fallbacks: string[] | null, options?: ITransaction.OperationOptions): this;
+    getSize(): number;
+    setSize(size: number | null, options?: ITransaction.OperationOptions): this;
+    getWeight(): number;
+    setWeight(weight: number | null, options?: ITransaction.OperationOptions): this;
+    getBold(): boolean;
+    setBold(bold: boolean | null, options?: ITransaction.OperationOptions): this;
+    getItalic(): boolean;
+    setItalic(italic: boolean | null, options?: ITransaction.OperationOptions): this;
+    getUnderline(): IFont.UnderlineStyle;
+    setUnderline(underline: IFont.UnderlineStyle | null, options?: ITransaction.OperationOptions): this;
+    getStrike(): IFont.StrikeStyle;
+    setStrike(strike: IFont.StrikeStyle | null, options?: ITransaction.OperationOptions): this;
+    getColor(): IColor;
+    setColor(color: IColor | string | null, options?: ITransaction.OperationOptions): this;
+    getLetterSpacing(): number;
+    setLetterSpacing(letterSpacing: number | null, options?: ITransaction.OperationOptions): this;
+    getBaseline(): number;
+    setBaseline(baseline: number | null, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    edit(update: IFontStyle.Update): ModelEdit;
+    update(update: IFontStyle.Update, options?: ITransaction.OperationOptions): this;
+    /** @internal What the element's own text states of its font; `null` when it states nothing. */
+    stated(): IFontStyle.JSON | null;
+    /** @internal The edit that removes what the element states of its font; `null` when it states nothing. */
+    clearEdit(): ModelEdit | null;
+    isEqualMeasure(other: IFontStyle): boolean;
+    toCSS(mode?: IColor.CSSMode, zoom?: number): CSSProperties;
+    toJSON(): IFontStyle.JSON;
+    get isIFontStyle(): true;
+}
+type ShapePatch = {
+    fill?: IFill.JSON;
+    stroke?: IStroke.JSON;
+};
+/**
+ * An {@link ITextBoxStyle} for a chart part with text: the part's fill and line (`spPr`) and its
+ * font (`txPr`, or rich text), written together as one edit.
+ */
+export declare class ChartTextBoxStyle implements ITextBoxStyle {
+    private readonly _host;
+    private readonly _styleOf;
+    private readonly _write;
+    private readonly _font;
+    private readonly _description;
+    private readonly _ownShape;
+    private readonly _shape;
+    /**
+     * @param style Makes the part's shape style over a write; reads go to one made over `write`, an
+     * update's fill and line are captured from one made over a capturing write.
+     * @param write The edit a fill or line patch makes; a part with no fill or line of its own throws.
+     * @param ownShape `false` where the fill and line read another part's and are not the part's to write.
+     */
+    constructor(_host: ChartPartsHost, _styleOf: (write: (patch: ShapePatch) => ModelEdit) => IShapeStyle, _write: (patch: ShapePatch) => ModelEdit, _font: ChartFont, _description: string, _ownShape?: boolean);
+    getFont(): IFontStyle;
+    getFill(): ReturnType<IShapeStyle['getFill']>;
+    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): this;
+    setFillSolid(options?: ITransaction.OperationOptions): IFill.ISolid;
+    setFillGradient(options?: ITransaction.OperationOptions): IFill.IGradient;
+    setFillPattern(options?: ITransaction.OperationOptions): IFill.IPattern;
+    setFillNone(options?: ITransaction.OperationOptions): IFill.INone;
+    getStroke(): IStroke;
+    setStroke(stroke: IStroke.Update, options?: ITransaction.OperationOptions): this;
+    setStrokeNone(options?: ITransaction.OperationOptions): IStroke;
+    /** @internal The edits of `update`: fill and line as the shape style writes them, then the font. */
+    edits(update: ITextBoxStyle.Update): ModelEdit[];
+    /** @internal {@link edits}, as one edit. */
+    edit(update: ITextBoxStyle.Update): ModelEdit;
+    update(update: ITextBoxStyle.Update, options?: ITransaction.OperationOptions): this;
+    clear(options?: ITransaction.OperationOptions): this;
+    isThemed(): boolean;
+    toJSON(): ITextBoxStyle.JSON | null;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    get isIShapeStyle(): true;
+    get isITextBoxStyle(): true;
+}
+/** The chart area: the chart's own fill, border and text style. */
+export declare class ChartArea implements IChart.IChartArea {
+    private readonly _host;
+    private _styleCache;
+    constructor(_host: ChartPartsHost);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    getStyle(): ChartTextBoxStyle;
+    /** The chart area's style: reads resolve to Excel's white fill and hairline border. */
+    private _style;
+    getRoundedCorners(): boolean;
+    setRoundedCorners(rounded: boolean, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    edits(update: IChart.IChartArea.Update): ModelEdit[];
+    update(update: IChart.IChartArea.Update, options?: ITransaction.OperationOptions): this;
+    get isIChartArea(): true;
+}
+export declare class ChartTitle implements IChart.ITitle {
+    private readonly _host;
+    private _styleCache;
+    constructor(_host: ChartPartsHost);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    getText(): string | null;
+    setText(text: string | null, options?: ITransaction.OperationOptions): this;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getOverlay(): boolean;
+    setOverlay(overlay: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.ITitle.Update): ModelEdit[];
+    update(update: IChart.ITitle.Update, options?: ITransaction.OperationOptions): this;
+    get isITitle(): true;
+}
+/** A style's write, as an edit: `style` is built over a write that captures the patch, and `update` applied to it. */
+export declare const captureShapeEdit: (style: (write: (patch: {
+    fill?: IFill.JSON;
+    stroke?: IStroke.JSON;
+}) => ModelEdit) => IShapeStyle, make: (patch: {
+    fill?: IFill.JSON;
+    stroke?: IStroke.JSON;
+}) => ModelEdit, update: IShapeStyle.Update) => ModelEdit;
+export declare class ChartLegend implements IChart.ILegend {
+    private readonly _host;
+    private _styleCache;
+    private readonly _entries;
+    constructor(_host: ChartPartsHost);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getPosition(): IChart.LegendPosition;
+    setPosition(position: IChart.LegendPosition, options?: ITransaction.OperationOptions): this;
+    getOverlay(): boolean;
+    setOverlay(overlay: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    /** @internal The legend's shape style over `write`: what an entry's fill and line read. */
+    _style(write: (patch: {
+        fill?: IFill.JSON;
+        stroke?: IStroke.JSON;
+    }) => ModelEdit): IShapeStyle;
+    getLegendEntries(): readonly IChart.ILegendEntry[];
+    /**
+     * @internal The entries' texts as drawn, hidden ones too: the resolved legend leaves those out, so
+     * they are listed from the model's own count, by what they would show.
+     */
+    entryTexts(): string[];
+    /** @internal The entry at `index`, while the legend has one there. */
+    entry(index: number): ChartLegendEntry | null;
+    /** @internal */
+    edits(update: IChart.ILegend.Update): ModelEdit[];
+    update(update: IChart.ILegend.Update, options?: ITransaction.OperationOptions): this;
+    get isILegend(): true;
+}
+export declare class ChartLegendEntry implements IChart.ILegendEntry {
+    private readonly _host;
+    private readonly _legend;
+    private readonly _index;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _legend: ChartLegend, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    private _entry;
+    getIndex(): number;
+    getText(): string;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    get isILegendEntry(): true;
+}
+export declare class ChartGridlines implements IChart.IGridlines {
+    private readonly _host;
+    private readonly _axis;
+    private readonly _which;
+    private _styleCache;
+    private readonly _axId;
+    constructor(_host: ChartPartsHost, _axis: ChartAxis, _which: 'majorGridlines' | 'minorGridlines');
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIGridlines(): true;
+    private _lines;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+}
+export declare class ChartAxis implements IChart.IAxis {
+    private readonly _host;
+    private readonly _axId;
+    private _title;
+    private _major;
+    private _minor;
+    private _styleCache;
+    /** The path the axis was last found at, kept for when it is gone. */
+    private _path;
+    constructor(_host: ChartPartsHost, _axId: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    /** @internal */
+    axId(): number;
+    get isIAxis(): true;
+    private _axis;
+    /** The axis as laid out: what an automatic bound or unit reads back as. */
+    private _laidOut;
+    getKind(): 'category' | 'value' | 'date' | 'series';
+    getAxisGroup(): IChart.AxisGroup;
+    getTitle(): IChart.IAxisTitle;
+    getNumberFormat(): string | null;
+    setNumberFormat(formatCode: string, options?: ITransaction.OperationOptions): this;
+    getLinkNumberFormat(): boolean;
+    setLinkNumberFormat(linked: boolean, options?: ITransaction.OperationOptions): this;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getMinimum(): number | null;
+    setMinimum(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+    isMinimumAuto(): boolean;
+    getMaximum(): number | null;
+    setMaximum(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+    isMaximumAuto(): boolean;
+    getMajorUnit(): number | null;
+    setMajorUnit(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+    isMajorUnitAuto(): boolean;
+    getMajorGridlines(): IChart.IGridlines;
+    getMinorGridlines(): IChart.IGridlines;
+    getMultiLevel(): boolean;
+    setMultiLevel(multiLevel: boolean, options?: ITransaction.OperationOptions): this;
+    setCategoryNames(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+    getMinorUnit(): number | null;
+    setMinorUnit(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+    isMinorUnitAuto(): boolean;
+    getScaleType(): IChart.AxisScaleType;
+    setScaleType(scaleType: IChart.AxisScaleType, options?: ITransaction.OperationOptions): this;
+    getLogBase(): number;
+    setLogBase(logBase: number, options?: ITransaction.OperationOptions): this;
+    getDisplayUnit(): IChart.AxisDisplayUnit;
+    setDisplayUnit(unit: IChart.AxisDisplayUnit, options?: ITransaction.OperationOptions): this;
+    getCustomDisplayUnit(): number;
+    setCustomDisplayUnit(unit: number, options?: ITransaction.OperationOptions): this;
+    getShowDisplayUnitLabel(): boolean;
+    setShowDisplayUnitLabel(show: boolean, options?: ITransaction.OperationOptions): this;
+    /** The axis crossing this one: where VBA's `Crosses` is written (DESIGN-CHART §3.6). */
+    private _crossing;
+    getCrosses(): IChart.AxisCrosses;
+    setCrosses(crosses: IChart.AxisCrosses, options?: ITransaction.OperationOptions): this;
+    getCrossesAt(): number | null;
+    setCrossesAt(value: number, options?: ITransaction.OperationOptions): this;
+    getReversePlotOrder(): boolean;
+    setReversePlotOrder(reverse: boolean, options?: ITransaction.OperationOptions): this;
+    getMajorTickMark(): IChart.AxisTickMark;
+    setMajorTickMark(mark: IChart.AxisTickMark, options?: ITransaction.OperationOptions): this;
+    getMinorTickMark(): IChart.AxisTickMark;
+    setMinorTickMark(mark: IChart.AxisTickMark, options?: ITransaction.OperationOptions): this;
+    getTickLabelPosition(): IChart.AxisTickLabelPosition;
+    setTickLabelPosition(position: IChart.AxisTickLabelPosition, options?: ITransaction.OperationOptions): this;
+    getTextOrientation(): number | 'vertical' | 'auto';
+    setTextOrientation(orientation: number | 'vertical' | 'auto', options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    getTickLabelSpacing(): number | null;
+    setTickLabelSpacing(spacing: number | null, options?: ITransaction.OperationOptions): this;
+    getTickMarkSpacing(): number | null;
+    setTickMarkSpacing(spacing: number | null, options?: ITransaction.OperationOptions): this;
+    getBaseTimeUnit(): IChart.AxisTimeUnit | null;
+    setBaseTimeUnit(unit: IChart.AxisTimeUnit | 'auto', options?: ITransaction.OperationOptions): this;
+    getMajorTimeUnitScale(): IChart.AxisTimeUnit | null;
+    setMajorTimeUnitScale(unit: IChart.AxisTimeUnit, options?: ITransaction.OperationOptions): this;
+    getMinorTimeUnitScale(): IChart.AxisTimeUnit | null;
+    setMinorTimeUnitScale(unit: IChart.AxisTimeUnit, options?: ITransaction.OperationOptions): this;
+    getCategoryType(): IChart.AxisCategoryType;
+    setCategoryType(type: IChart.AxisCategoryType, options?: ITransaction.OperationOptions): this;
+    /** The dates of the first series on the axis, as numbers; `null` where its categories are not all dates. */
+    private _dates;
+    /** The base unit Excel chooses for the axis's dates (DESIGN-CHART §4.2), `days` without any. */
+    private _automaticBaseUnit;
+    /** The axis's categories from a setter's input. @throws ExpectedError where the axis has none. */
+    private _categoriesEdit;
+    /** The axis, which must be one of categories or dates (Excel refuses `MultiLevel` elsewhere, N46). */
+    private _categoryAxis;
+    /** @internal */
+    edits(update: IChart.IAxis.Update): ModelEdit[];
+    update(update: IChart.IAxis.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartAxes implements IChart.IAxes {
+    private readonly _host;
+    private readonly _axes;
+    constructor(_host: ChartPartsHost);
+    /** @internal */
+    axis(axId: number): ChartAxis;
+    /** Lets go of the axes the plot area no longer has: the secondary pair, once its last series left it. */
+    private _prune;
+    getItems(): readonly IChart.IAxis[];
+    getChartAxis(type: 'category' | 'value' | 'series', group?: IChart.AxisGroup): IChart.IAxis | null;
+    getValueAxis(group?: IChart.AxisGroup): IChart.IAxis | null;
+    getCategoryAxis(group?: IChart.AxisGroup): IChart.IAxis | null;
+    getSeriesAxis(): IChart.IAxis | null;
+}
+export declare class ChartAxisTitle implements IChart.IAxisTitle {
+    private readonly _host;
+    private readonly _axis;
+    private readonly _axId;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _axis: ChartAxis, _axId: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isITitle(): true;
+    get isIAxisTitle(): true;
+    private _title;
+    getText(): string | null;
+    setText(text: string | null, options?: ITransaction.OperationOptions): this;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getOverlay(): boolean;
+    setOverlay(overlay: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    getTextOrientation(): number | 'vertical' | 'auto';
+    setTextOrientation(orientation: number | 'vertical' | 'auto', options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    edits(update: IChart.IAxisTitle.Update): ModelEdit[];
+    update(update: IChart.IAxisTitle.Update, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    axis(): ChartAxis;
+}
+export declare class ChartSeries implements IChart.ISeries {
+    private readonly _host;
+    private readonly _key;
+    private _marker;
+    private _labels;
+    private _xErrorBars;
+    private _yErrorBars;
+    private _styleCache;
+    private readonly _trendlines;
+    private readonly _points;
+    /** The group the series was last in, kept for when it is gone. */
+    private _group;
+    constructor(_host: ChartPartsHost, _key: string);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isISeries(): true;
+    /** @internal The key the chart names the series by. */
+    key(): string;
+    /** @internal The series' group: what its up/down bars and its group's lines belong to. */
+    groupPart(): ChartGroup;
+    private _facts;
+    /**
+     * The series' `idx`, which names it in the model.
+     * @throws ExpectedError for a series that states none (a 2016 chart's), which is not edited.
+     * @internal
+     */
+    idx(): number;
+    /** @internal */
+    found(): {
+        group: ChartModel.Group;
+        series: ChartModel.Series;
+    } | null;
+    /** @internal */
+    resolved(): ResolvedChart.Series | null;
+    getName(): string | null;
+    getNameFormula(): string | null;
+    getValuesFormula(): string | null;
+    getCategoriesFormula(): string | null;
+    getBubbleSizesFormula(): string | null;
+    getNameRange(): ICellRange | null;
+    getValuesRange(): ICellRange | null;
+    getCategoriesRange(): ICellRange | null;
+    getChartType(): string;
+    isSecondaryAxis(): boolean;
+    setName(name: string | ICellRange | null, options?: ITransaction.OperationOptions): this;
+    setValues(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+    setXAxisValues(source: ICellRange | string | null, options?: ITransaction.OperationOptions): this;
+    setBubbleSizes(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+    setChartType(type: IChart.Type | string, options?: ITransaction.OperationOptions): this;
+    getAxisGroup(): IChart.AxisGroup;
+    setAxisGroup(group: IChart.AxisGroup, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+    private _style;
+    getMarker(): IChart.IMarker;
+    getDataLabels(): IChart.IDataLabels;
+    getTrendlines(): readonly IChart.ITrendline[];
+    getChartTrendline(index: number): IChart.ITrendline | null;
+    getXErrorBars(): IChart.IErrorBars;
+    getYErrorBars(): IChart.IErrorBars;
+    getUpDownBars(): IChart.IUpDownBars;
+    getHiLoLines(): IChart.ILines;
+    getDropLines(): IChart.ILines;
+    getSeriesLines(): IChart.ILines;
+    addChartTrendline(type?: IChart.TrendlineType, options?: ITransaction.OperationOptions): IChart.ITrendline;
+    getGapWidth(): number | null;
+    setGapWidth(gapWidth: number, options?: ITransaction.OperationOptions): this;
+    getOverlap(): number | null;
+    setOverlap(overlap: number, options?: ITransaction.OperationOptions): this;
+    getBubbleScale(): number | null;
+    setBubbleScale(bubbleScale: number, options?: ITransaction.OperationOptions): this;
+    getShowNegativeBubbles(): boolean | null;
+    setShowNegativeBubbles(showNegativeBubbles: boolean, options?: ITransaction.OperationOptions): this;
+    getBubbleSizeRepresents(): IChart.BubbleSizeRepresents | null;
+    setBubbleSizeRepresents(bubbleSizeRepresents: IChart.BubbleSizeRepresents, options?: ITransaction.OperationOptions): this;
+    /** A bubble group's option, checked against what Excel takes (a scale of 0 to 300). */
+    private _bubbleEdit;
+    getSplitType(): IChart.SplitType | null;
+    setSplitType(splitType: IChart.SplitType, options?: ITransaction.OperationOptions): this;
+    getSplitValue(): number | null;
+    setSplitValue(splitValue: number, options?: ITransaction.OperationOptions): this;
+    getSecondPlotSize(): number | null;
+    setSecondPlotSize(secondPlotSize: number, options?: ITransaction.OperationOptions): this;
+    getSecondPlotPoints(): number[];
+    setSecondPlotPoints(points: readonly number[], options?: ITransaction.OperationOptions): this;
+    /** An of-pie's split changed, checked against what Excel takes. */
+    private _splitEdit;
+    /**
+     * A bar group's option, checked against Excel's range (gap 0-500, overlap -100-100); the gap of a
+     * line or stock group's up/down bars, where it shows them; an of-pie's gap (0-500) and second plot
+     * size (5-200).
+     */
+    private _groupOption;
+    /**
+     * The series given `type`, as one edit: moved to its group by `_Grouping`'s measured moves, and
+     * drawn as a series of the type is (`drawSeriesAsType`). Every series whose group changed type is
+     * drawn anew, as Excel does when bubble or 3-D types take the whole chart; one that stays in its
+     * group changes its markers, and a scatter its line, keeping its own fill and line otherwise. A
+     * series that becomes a scatter's states its categories and values as x and y values, and the
+     * other way round. No series can be given a stock type: Excel refuses one
+     * (`probe-chart-stock-refusals.ps1`); nor an of-pie, which is not measured; nor a 3-D form, a
+     * surface or a 2016 type, which take the whole chart (`IChart.setChartType`).
+     */
+    private _typeEdit;
+    private _axisGroupEdit;
+    getFormula(): string;
+    setFormula(formula: string, options?: ITransaction.OperationOptions): this;
+    getDimensionValues(dimension: IChart.SeriesDimension): string[];
+    getPlotOrder(): number;
+    setPlotOrder(plotOrder: number, options?: ITransaction.OperationOptions): this;
+    getSmooth(): boolean;
+    setSmooth(smooth: boolean, options?: ITransaction.OperationOptions): this;
+    getInvertIfNegative(): boolean;
+    setInvertIfNegative(invert: boolean, options?: ITransaction.OperationOptions): this;
+    getExplosion(): number;
+    setExplosion(explosion: number, options?: ITransaction.OperationOptions): this;
+    getVaryByCategories(): boolean;
+    setVaryByCategories(vary: boolean, options?: ITransaction.OperationOptions): this;
+    getPoints(): readonly IChart.IPoint[];
+    /** @internal The point at `index`, while the series has one there. */
+    point(index: number): ChartPoint | null;
+    delete(options?: ITransaction.OperationOptions): void;
+    /** The number of points the series plots now. */
+    pointCount(): number;
+    /**
+     * The edits of a `SERIES` formula (S01-S06): each part set as its setter sets it, the name as text
+     * (`"Total"`) or a cell, the categories and values as cells or array constants, the order as the
+     * plot order, the sizes for a bubble.
+     */
+    private _formulaEdits;
+    /**
+     * The categories set through this series: a scatter's or bubble's x values are its own; a
+     * category chart's categories are shared by every series on its axis, so each takes them, and
+     * `null` clears them all (measured 2026-10-18, `probe-chart-api.ps1` S01-S04).
+     */
+    private _categoriesEdit;
+    /** A dimension's source, from a setter's input. */
+    private _source;
+    /** @internal */
+    edits(update: IChart.ISeries.Update): {
+        description: string;
+        edits: ModelEdit[];
+    };
+    /** What `update`'s style writes, as an edit: the style's own update, captured. */
+    private _styleEdit;
+    update(update: IChart.ISeries.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartMarker implements IChart.IMarker {
+    private readonly _host;
+    private readonly _series;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIMarker(): true;
+    private _check;
+    getSymbol(): IChart.MarkerSymbol;
+    setSymbol(symbol: IChart.MarkerSymbol, options?: ITransaction.OperationOptions): this;
+    getSize(): number;
+    setSize(size: number, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.IMarker.Update): ModelEdit[];
+    update(update: IChart.IMarker.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartDataLabels implements IChart.IDataLabels {
+    private readonly _host;
+    private readonly _series;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIDataLabels(): true;
+    /** @internal What the series' labels state, over its group's. */
+    stated(): ChartModel.DataLabelOptions & {
+        delete?: boolean;
+    };
+    /** What the series' labels state, over its group's. */
+    private _options;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    private _flag;
+    getShowValue(): boolean;
+    setShowValue(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowCategoryName(): boolean;
+    setShowCategoryName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowSeriesName(): boolean;
+    setShowSeriesName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowPercentage(): boolean;
+    setShowPercentage(show: boolean, options?: ITransaction.OperationOptions): this;
+    getPosition(): IChart.DataLabelPosition;
+    setPosition(position: IChart.DataLabelPosition, options?: ITransaction.OperationOptions): this;
+    getSeparator(): string;
+    setSeparator(separator: string, options?: ITransaction.OperationOptions): this;
+    getNumberFormat(): string | null;
+    setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+    getLinkNumberFormat(): boolean;
+    setLinkNumberFormat(linked: boolean, options?: ITransaction.OperationOptions): this;
+    getShowLegendKey(): boolean;
+    setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowBubbleSize(): boolean;
+    setShowBubbleSize(show: boolean, options?: ITransaction.OperationOptions): this;
+    getValueFromCellsFormula(): string | null;
+    setValueFromCells(source: ICellRange | string | null, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    getTextOrientation(): number | 'vertical';
+    setTextOrientation(orientation: number | 'vertical', options?: ITransaction.OperationOptions): this;
+    /** @internal `chartLevel`: shown for the whole chart, which states a pie's leader lines. */
+    edits(update: IChart.IDataLabels.Update, chartLevel?: boolean): ModelEdit[];
+    /** The cells the labels show, as a reference (cells, an address or a name). */
+    private _rangeSource;
+    update(update: IChart.IDataLabels.Update, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Whether Excel draws trendlines for the series of `group`: 2-D bars, lines and areas that are not
+ * stacked, scatters, bubbles and stock (measured T31, T36, T62; refused on a pie, a stacked column
+ * and a stacked line, T40, T41, T56; the rest believed).
+ */
+export declare const takesTrendlines: (group: ChartModel.Group) => boolean;
+export declare class ChartTrendline implements IChart.ITrendline {
+    private readonly _host;
+    private readonly _series;
+    private readonly _index;
+    private _label;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isITrendline(): true;
+    /** @internal */
+    model(): ChartModel.Trendline | null;
+    /** @internal */
+    resolved(): ResolvedChart.Trendline | null;
+    /** The trendline's model. @throws ExpectedError where it is gone. */
+    private _check;
+    private _onCategories;
+    getType(): IChart.TrendlineType;
+    setType(type: IChart.TrendlineType, options?: ITransaction.OperationOptions): this;
+    getPolynomialOrder(): number;
+    setPolynomialOrder(order: number, options?: ITransaction.OperationOptions): this;
+    getMovingAveragePeriod(): number;
+    setMovingAveragePeriod(period: number, options?: ITransaction.OperationOptions): this;
+    getForwardPeriod(): number;
+    setForwardPeriod(period: number, options?: ITransaction.OperationOptions): this;
+    getBackwardPeriod(): number;
+    setBackwardPeriod(period: number, options?: ITransaction.OperationOptions): this;
+    getIntercept(): number | null;
+    isInterceptAuto(): boolean;
+    setIntercept(intercept: number | 'auto', options?: ITransaction.OperationOptions): this;
+    getShowEquation(): boolean;
+    setShowEquation(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowRSquared(): boolean;
+    setShowRSquared(show: boolean, options?: ITransaction.OperationOptions): this;
+    getName(): string;
+    isNameAuto(): boolean;
+    setName(name: string | null, options?: ITransaction.OperationOptions): this;
+    getLabel(): IChart.ITrendlineLabel;
+    getStyle(): IShapeStyle;
+    private _style;
+    getFit(): IChart.TrendlineFit | null;
+    delete(options?: ITransaction.OperationOptions): void;
+    /** @internal */
+    edits(update: IChart.ITrendline.Update): ModelEdit[];
+    update(update: IChart.ITrendline.Update, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    index(): number;
+    /** @internal */
+    series(): ChartSeries;
+}
+export declare class ChartTrendlineLabel implements IChart.ITrendlineLabel {
+    private readonly _host;
+    private readonly _trendline;
+    constructor(_host: ChartPartsHost, _trendline: ChartTrendline);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isITrendlineLabel(): true;
+    getText(): string | null;
+    getNumberFormat(): string;
+    setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    edits(update: IChart.ITrendlineLabel.Update): ModelEdit[];
+    update(update: IChart.ITrendlineLabel.Update, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Whether Excel draws error bars of `direction` for the series of `group`: of the values on 2-D
+ * bars (stacked too, K01), lines and areas, scatters and bubbles; of x on scatters and bubbles
+ * only (measured R01-C04, H01, A01, K01, S01-S06; the rest by belief).
+ */
+export declare const takesErrorBars: (group: ChartModel.Group, direction: Edits.ErrorBarsDirection) => boolean;
+export declare class ChartErrorBars implements IChart.IErrorBars {
+    private readonly _host;
+    private readonly _series;
+    private readonly _direction;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries, _direction: Edits.ErrorBarsDirection);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIErrorBars(): true;
+    private _model;
+    /** The series' `idx`. @throws ExpectedError where Excel draws no such bars. */
+    private _check;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getType(): IChart.ErrorBarsType;
+    setType(type: IChart.ErrorBarsType, options?: ITransaction.OperationOptions): this;
+    getAmount(): number | null;
+    setAmount(amount: number, options?: ITransaction.OperationOptions): this;
+    getInclude(): IChart.ErrorBarsInclude;
+    setInclude(include: IChart.ErrorBarsInclude, options?: ITransaction.OperationOptions): this;
+    getEndStyleCap(): boolean;
+    setEndStyleCap(cap: boolean, options?: ITransaction.OperationOptions): this;
+    private _formulaOf;
+    getPlusValuesFormula(): string | null;
+    getMinusValuesFormula(): string | null;
+    setCustomValues(plus: ICellRange | string, minus: ICellRange | string, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+    private _style;
+    /** A source of custom amounts from a setter's input: cells, a formula or an array constant. */
+    private _source;
+    /** @internal */
+    edits(update: IChart.IErrorBars.Update): ModelEdit[];
+    update(update: IChart.IErrorBars.Update, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Whether Excel draws up/down bars and high-low lines for a group: a 2-D line or stock group
+ * (`probe-chart-lines.ps1`; 3-D lines refused by belief).
+ */
+export declare const takesUpDownBars: (group: ChartModel.Group) => boolean;
+/**
+ * Whether Excel draws a group's lines of `kind` (`probe-chart-lines.ps1`): high-low lines on a line
+ * or stock group; drop lines on a line, area or stock group (D09: COM takes them on a scatter and
+ * writes none); series lines on stacked and 100% stacked bars and pie of pie (V06: COM takes them on
+ * clustered columns and writes none). 3-D groups are refused by belief.
+ */
+export declare const takesLines: (group: ChartModel.Group, kind: Edits.GroupLinesKind) => boolean;
+export declare class ChartGroupLines implements IChart.ILines {
+    private readonly _host;
+    private readonly _group;
+    private readonly _kind;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _group: ChartGroup, _kind: Edits.GroupLinesKind);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isILines(): true;
+    private _model;
+    /** The series' `idx`. @throws ExpectedError where Excel draws no such lines. */
+    private _check;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.ILines.Update): ModelEdit[];
+    update(update: IChart.ILines.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartUpDownBars implements IChart.IUpDownBars {
+    private readonly _host;
+    private readonly _group;
+    private _upStyle;
+    private _downStyle;
+    constructor(_host: ChartPartsHost, _group: ChartGroup);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIUpDownBars(): true;
+    private _model;
+    /** The series' `idx`. @throws ExpectedError where Excel draws no up/down bars. */
+    private _check;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getGapWidth(): number;
+    setGapWidth(gapWidth: number, options?: ITransaction.OperationOptions): this;
+    getUpBarsStyle(): IShapeStyle;
+    getDownBarsStyle(): IShapeStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.IUpDownBars.Update): ModelEdit[];
+    update(update: IChart.IUpDownBars.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartPoint implements IChart.IPoint {
+    private readonly _host;
+    private readonly _series;
+    private readonly _index;
+    private _styleCache;
+    private _marker;
+    private _label;
+    constructor(_host: ChartPartsHost, _series: ChartSeries, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIPoint(): true;
+    private _point;
+    getIndex(): number;
+    getStyle(): IShapeStyle;
+    private _style;
+    getMarker(): IChart.IMarker;
+    getExplosion(): number;
+    setExplosion(explosion: number, options?: ITransaction.OperationOptions): this;
+    getInvertIfNegative(): boolean;
+    setInvertIfNegative(invert: boolean, options?: ITransaction.OperationOptions): this;
+    getIsTotal(): boolean;
+    setIsTotal(total: boolean, options?: ITransaction.OperationOptions): this;
+    getDataLabel(): IChart.IDataLabel;
+    getHasDataLabel(): boolean;
+    setHasDataLabel(has: boolean, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    edits(update: IChart.IPoint.Update): ModelEdit[];
+    update(update: IChart.IPoint.Update, options?: ITransaction.OperationOptions): this;
+}
+/** A point's marker, over its series' (T04, T05). */
+export declare class ChartPointMarker implements IChart.IMarker {
+    private readonly _host;
+    private readonly _series;
+    private readonly _point;
+    private readonly _index;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries, _point: ChartPoint, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIMarker(): true;
+    private _marker;
+    private _check;
+    getSymbol(): IChart.MarkerSymbol;
+    setSymbol(symbol: IChart.MarkerSymbol, options?: ITransaction.OperationOptions): this;
+    getSize(): number;
+    setSize(size: number, options?: ITransaction.OperationOptions): this;
+    getStyle(): IShapeStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.IMarker.Update): ModelEdit[];
+    update(update: IChart.IMarker.Update, options?: ITransaction.OperationOptions): this;
+}
+/** The label of one point, over its series' labels (T07-T13, T18, T19). */
+export declare class ChartPointLabel implements IChart.IDataLabel {
+    private readonly _host;
+    private readonly _series;
+    private readonly _point;
+    private readonly _index;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _series: ChartSeries, _point: ChartPoint, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIDataLabel(): true;
+    private _label;
+    /** What the label states, over the series' labels and the group's. */
+    private _options;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getText(): string | null;
+    setText(text: string | null, options?: ITransaction.OperationOptions): this;
+    getPosition(): IChart.DataLabelPosition;
+    setPosition(position: IChart.DataLabelPosition, options?: ITransaction.OperationOptions): this;
+    private _flag;
+    getShowValue(): boolean;
+    setShowValue(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowCategoryName(): boolean;
+    setShowCategoryName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowSeriesName(): boolean;
+    setShowSeriesName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowPercentage(): boolean;
+    setShowPercentage(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowLegendKey(): boolean;
+    setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+    getNumberFormat(): string | null;
+    setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.IDataLabel.Update): ModelEdit[];
+    update(update: IChart.IDataLabel.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartPlotArea implements IChart.IPlotArea {
+    private readonly _host;
+    private _styleCache;
+    constructor(_host: ChartPartsHost);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIPlotArea(): true;
+    getStyle(): IShapeStyle;
+    private _style;
+    private _rect;
+    getLeft(): number;
+    getTop(): number;
+    getWidth(): number;
+    getHeight(): number;
+    getInsideLeft(): number;
+    getInsideTop(): number;
+    getInsideWidth(): number;
+    getInsideHeight(): number;
+    /** @internal */
+    edits(update: IChart.IPlotArea.Update): ModelEdit[];
+    update(update: IChart.IPlotArea.Update, options?: ITransaction.OperationOptions): this;
+}
+export declare class ChartDataTable implements IChart.IDataTable {
+    private readonly _host;
+    private _styleCache;
+    constructor(_host: ChartPartsHost);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIDataTable(): true;
+    private _table;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getShowLegendKey(): boolean;
+    setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowHorizontalBorder(): boolean;
+    setShowHorizontalBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowVerticalBorder(): boolean;
+    setShowVerticalBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowOutlineBorder(): boolean;
+    setShowOutlineBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+    getStyle(): ChartTextBoxStyle;
+    private _style;
+    /** @internal */
+    edits(update: IChart.IDataTable.Update): ModelEdit[];
+    update(update: IChart.IDataTable.Update, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * A chart group, by its place among the chart's groups. What its series share (up/down bars and the
+ * group's lines) is set through its first series, as the series' own setters set it.
+ */
+export declare class ChartGroup implements IChart.IChartGroup {
+    private readonly _host;
+    private readonly _index;
+    private _upDownBars;
+    private readonly _lines;
+    constructor(_host: ChartPartsHost, _index: number);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIChartGroup(): true;
+    private _group;
+    /** The group's first series in plot order, which its shared parts are set through. */
+    private _first;
+    /** @internal The group and its first series, as a series' `found` answers. */
+    found(): {
+        group: ChartModel.Group;
+        series: ChartModel.Series;
+    } | null;
+    /** @internal The first series' `idx`. @throws ExpectedError for a group with none. */
+    idx(): number;
+    getUpDownBars(): IChart.IUpDownBars;
+    getHiLoLines(): IChart.ILines;
+    getDropLines(): IChart.ILines;
+    getSeriesLines(): IChart.ILines;
+    getIndex(): number;
+    getChartType(): string;
+    getAxisGroup(): IChart.AxisGroup;
+    getSeries(): readonly IChart.ISeries[];
+    getGapWidth(): number | null;
+    getOverlap(): number | null;
+    getVaryByCategories(): boolean;
+    setVaryByCategories(vary: boolean, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Every series' data labels at once (Office Scripts' `chart.getDataLabels()`, VBA's
+ * `ApplyDataLabels`, `probe-chart-api.ps1` L01): reads answer the first series', each setter sets
+ * every series as one step.
+ */
+export declare class ChartAllLabels implements IChart.IDataLabels {
+    private readonly _host;
+    private readonly _all;
+    private _styleCache;
+    constructor(_host: ChartPartsHost, _all: () => readonly ChartSeries[]);
+    getChart(): IChart;
+    getParent(): IChart.IElement | null;
+    getElementType(): IChart.ElementType;
+    getPath(): string;
+    get isIDataLabels(): true;
+    private _first;
+    getVisible(): boolean;
+    setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+    getShowValue(): boolean;
+    setShowValue(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowCategoryName(): boolean;
+    setShowCategoryName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowSeriesName(): boolean;
+    setShowSeriesName(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowPercentage(): boolean;
+    setShowPercentage(show: boolean, options?: ITransaction.OperationOptions): this;
+    getPosition(): IChart.DataLabelPosition;
+    setPosition(position: IChart.DataLabelPosition, options?: ITransaction.OperationOptions): this;
+    getSeparator(): string;
+    setSeparator(separator: string, options?: ITransaction.OperationOptions): this;
+    getNumberFormat(): string | null;
+    setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+    getLinkNumberFormat(): boolean;
+    setLinkNumberFormat(linked: boolean, options?: ITransaction.OperationOptions): this;
+    getShowLegendKey(): boolean;
+    setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+    getShowBubbleSize(): boolean;
+    setShowBubbleSize(show: boolean, options?: ITransaction.OperationOptions): this;
+    getValueFromCellsFormula(): string | null;
+    setValueFromCells(source: ICellRange | string | null, options?: ITransaction.OperationOptions): this;
+    getTextOrientation(): number | 'vertical';
+    setTextOrientation(orientation: number | 'vertical', options?: ITransaction.OperationOptions): this;
+    /** The first series' labels, which reads answer. */
+    private _stated;
+    getStyle(): ChartTextBoxStyle;
+    /** @internal The edits of `update` on every series, shown as the whole chart's labels are. */
+    edits(update: IChart.IDataLabels.Update): ModelEdit[];
+    update(update: IChart.IDataLabels.Update, options?: ITransaction.OperationOptions): this;
+}
+/** The parts an element is set through. */
+export interface ChartElementParts {
+    host: ChartPartsHost;
+    title: ChartTitle;
+    legend: ChartLegend;
+    axes: ChartAxes;
+    series(): readonly ChartSeries[];
+    plotArea: ChartPlotArea;
+    dataTable: ChartDataTable;
+}
+/**
+ * The edits of a chart element (VBA's `SetElement`, measured 2026-10-18, `probe-chart-elements.ps1`):
+ * each `msoElement…` as the setters above make it. A data label element sets every series; a
+ * trendline, error bar, line or up/down bar element every series or group that takes one. What
+ * Excel refuses (an element of axes the chart has none of, a label position its type has none of,
+ * a trendline on a pie) throws `ExpectedError`.
+ */
+export declare const elementEdits: (parts: ChartElementParts, element: IChart.Element) => ModelEdit[];
+export {};
+//# sourceMappingURL=_ChartParts.d.ts.map