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

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

@@ -1,17 +1,20 @@
+import { Bounds, Point, Size } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IModel } from '../model';
 import { IMovable } from '../movable';
 import { IEmbeddedPart } from '../io';
-import { ICellRange } from '../cellRange';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IAnchored } from '../anchored';
+import { IShapeStyle, ITextBoxStyle } from '../shape';
+import { ChartModel } from './model/ChartModel';
+import { ChartLayout } from './layout/ChartLayout';
 /**
  * Interface for working with a chart.
  *
  * @remarks
  * A chart is the content of a movable, which places it — see {@link IChart.getMovable}.
- * Until the chart is modeled it is carried as the markup it was read from and written back
- * unchanged; {@link IChart.getXML} is the read-only view of that markup.
  */
 export interface IChart extends IModel, IMovable.IContent {
     /**
@@ -24,14 +27,13 @@ export interface IChart extends IModel, IMovable.IContent {
      */
     getChartTitle(): string | null;
     /**
-     * Returns the chart's type, or `'unknown'`.
+     * Returns the chart's type, by the names of {@link IChart.Type}, or `'unknown'`.
      *
      * @remarks
-     * `'column'`, `'bar'`, `'line'`, `'area'`, `'pie'`, `'doughnut'`, `'scatter'`, `'bubble'`,
-     * `'radar'`, `'stock'`, `'surface'`, `'waterfall'`, `'funnel'`, `'treemap'`, `'sunburst'`,
-     * `'histogram'`, `'boxWhisker'` and so on. A stacked chart says so after the type —
-     * `'columnStacked'`, `'areaPercentStacked'`. A chart whose series are not all drawn the same way
-     * is `'combo'`, and {@link IChart.ISeries.getChartType} says how each one is drawn.
+     * `'columnClustered'`, `'barStacked100'`, `'lineMarkers'`, `'pie'`, `'xyscatter'`,
+     * `'waterfall'`, `'pareto'` and so on. A chart whose groups of series are drawn differently is
+     * `'combo'`, and {@link IChart.ISeries.getChartType} says how each series is drawn. Within one group
+     * series may differ in markers; the chart then answers its first series' type, as Excel does.
      */
     getChartType(): string;
     /**
@@ -43,9 +45,202 @@ export interface IChart extends IModel, IMovable.IContent {
      */
     getSeries(): readonly IChart.ISeries[];
     /**
-     * Returns the axes the chart shows. A pie has none.
+     * Returns the chart's axes. A pie has none.
+     *
+     * @example
+     * ```ts
+     * chart.getAxes().getValueAxis()?.setMinimum(0);
+     * chart.getAxes().getItems().map(axis => axis.getKind());
+     * ```
+     */
+    getAxes(): IChart.IAxes;
+    /**
+     * Returns the chart's title. A chart always has one to set, shown or not.
+     */
+    getTitle(): IChart.ITitle;
+    /**
+     * Returns the chart's legend. A chart always has one to set, shown or not.
+     */
+    getLegend(): IChart.ILegend;
+    /**
+     * Returns whether each series is a row or a column of the chart's cells, as its first series
+     * reads them.
+     */
+    getSeriesBy(): 'rows' | 'columns';
+    /**
+     * Returns the chart's preset style, 1 to 48: the colors and effects Excel's Chart Styles gallery
+     * gives the chart's parts. 2 for a chart that states none, as the file format's default.
+     */
+    getChartStyle(): number;
+    /**
+     * Returns how a blank cell is plotted: as a gap, as zero, or with a line drawn across it.
+     */
+    getDisplayBlanksAs(): IChart.DisplayBlanksAs;
+    /**
+     * Sets how a blank cell is plotted.
+     */
+    setDisplayBlanksAs(value: IChart.DisplayBlanksAs, options?: ITransaction.OperationOptions): this;
+    /**
+     * Draws every series as `type`, in one group on the primary axes, as Excel's Change Chart Type
+     * does: the series keep their colors, and what each type cannot draw with is restated (a bar's
+     * fill becomes a line's color, a pie takes a slice per point).
+     *
+     * @remarks
+     * A combo becomes one group; the secondary axes go. Office Scripts' `setChartType`, VBA's
+     * `Chart.ChartType`. To change one series, see {@link IChart.ISeries.setChartType}.
+     *
+     * @throws ExpectedError for a stock type, which Excel makes only from its own series.
+     */
+    setChartType(type: IChart.Type | string, options?: ITransaction.OperationOptions): this;
+    /**
+     * Adds a series with no data, drawn as a new series of the chart's type is, and returns it.
+     *
+     * @param name The series' name: text, or a cell (`'=Sheet1!$D$1'`).
+     * @param index Where the series goes in the plot order, from 0; at the end when left out.
+     *
+     * @remarks
+     * Office Scripts' `addChartSeries`, VBA's `SeriesCollection.NewSeries`. Give it data with
+     * {@link IChart.ISeries.setValues} and {@link IChart.ISeries.setXAxisValues}, or
+     * {@link IChart.ISeries.setFormula}.
+     */
+    addSeries(name?: string | ICellRange, index?: number, options?: ITransaction.OperationOptions): IChart.ISeries;
+    /**
+     * Office Scripts' name for {@link addSeries}.
+     *
+     * @deprecated Use {@link addSeries}.
+     * @hidden
+     */
+    addChartSeries(name?: string | ICellRange, index?: number, options?: ITransaction.OperationOptions): IChart.ISeries;
+    /**
+     * Returns the chart's groups: each the series drawn one way against one pair of axes, with the
+     * options they share (VBA's `ChartGroups`). A chart of one type has one group; a combo one per
+     * type and axis pair.
+     */
+    getGroups(): readonly IChart.IChartGroup[];
+    /**
+     * VBA's name for {@link getGroups}.
+     *
+     * @deprecated Use {@link getGroups}.
+     * @hidden
+     */
+    getChartGroups(): readonly IChart.IChartGroup[];
+    /**
+     * Reads the chart's cells the other way: each series a row of them, or a column. The same cells,
+     * as {@link IChart.setData} reads them with that direction.
+     *
+     * @throws ExpectedError when the series do not read one block of cells.
+     */
+    setSeriesBy(seriesBy: 'rows' | 'columns', options?: ITransaction.OperationOptions): this;
+    /** Returns whether hidden rows and columns are left out of the chart. */
+    getPlotVisibleOnly(): boolean;
+    /** Sets whether hidden rows and columns are left out of the chart. */
+    setPlotVisibleOnly(plotVisibleOnly: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the data labels of every series at once: reads answer the first series', and each
+     * setter sets every series (Office Scripts' `chart.getDataLabels()`, VBA's `ApplyDataLabels`).
+     */
+    getDataLabels(): IChart.IDataLabels;
+    /** Returns the plot area: where the series are drawn, inside the axes' labels. */
+    getPlotArea(): IChart.IPlotArea;
+    /**
+     * Returns the chart area: the whole chart's fill, border and font, the element every other
+     * element is inside.
+     */
+    getChartArea(): IChart.IChartArea;
+    /**
+     * Returns the element at `path` (see {@link IChart.IElement.getPath}), or `null` where the chart
+     * has none: a path that names nothing, or a part an edit removed.
+     *
+     * @example
+     * ```ts
+     * chart.getElement('axes/primary/value/title')?.getElementType(); // 'axisTitle'
+     * chart.getElement('series/0/points/3');                          // the fourth point of series 0
+     * ```
+     */
+    getElement(path: string): IChart.IElement | null;
+    /**
+     * Returns the elements the chart shows, as Excel's Chart Elements list offers them to choose from:
+     * the chart area, the plot area, each series, and the title, legend, axes, axis titles, gridlines,
+     * data labels, trendlines, error bars, data table and group lines that are shown. Points, markers
+     * and legend entries are left out; a series' {@link IChart.ISeries.getPoints} lists its points.
+     */
+    getElements(): readonly IChart.IElement[];
+    /**
+     * Returns the element drawn at `point`: a hit test of the chart as laid out.
+     *
+     * @param point In px from the chart's top-left, unzoomed, as {@link getLayout} speaks.
+     * @param layout The layout to test, as {@link getLayout} answered it, or the size to lay the chart
+     * out at; by default the chart is laid out at its movable's bounds.
+     * @returns The topmost element there, as Excel stacks them: the title and legend over everything,
+     * then data labels, trendlines and error bars, a series' points, the lines under them, axis titles,
+     * axes and gridlines, the plot area, and the chart area under it all. `null` outside the chart,
+     * or when the chart has no layout.
+     *
+     * @remarks
+     * A press on a bar answers the bar's point; its series is the point's {@link IChart.IElement.getParent | parent}.
+     * Excel selects the series on a first press and the point on the next; which to select is the
+     * caller's.
+     *
+     * @example
+     * ```ts
+     * const layout = chart.getLayout({ width: 480, height: 288 });
+     * chart.getElementAt({ x: 240, y: 12 }, layout)?.getPath(); // 'title'
+     * ```
+     */
+    getElementAt(point: Point, layout?: ChartLayout | Size): IChart.IElement | null;
+    /**
+     * Returns the box `element` is drawn in, in px from the chart's top-left, or `null` where the
+     * chart as laid out draws nothing for it (a hidden part, a point with no value, the data table).
+     *
+     * @param element The element, or its path.
+     * @param layout As for {@link getElementAt}.
+     *
+     * @remarks
+     * The chart area's box is the whole chart's, the plot area's its outer box (with its axes'
+     * labels), an axis's its line and labels together, a series' its points' boxes together.
+     */
+    getElementBounds(element: IChart.IElement | string, layout?: ChartLayout | Size): Bounds | null;
+    /** Returns the data table: the chart's values in a table under the plot area, shown or not. */
+    getDataTable(): IChart.IDataTable;
+    /**
+     * Returns what the chart area is drawn with: its fill, its border and the chart's font (Office
+     * Scripts' `getFormat()`, VBA's `ChartArea.Format`).
+     *
+     * @remarks
+     * The font is what every text takes unless it states its own. Setting it sets every text in the
+     * chart, the title at 1.2 times the size, as Excel's `ChartArea.Font` does.
+     */
+    getStyle(): ITextBoxStyle;
+    /** Returns whether the chart area's corners are rounded. */
+    getRoundedCorners(): boolean;
+    /** Sets whether the chart area's corners are rounded. */
+    setRoundedCorners(rounded: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * Adds, places or removes a chart element by the names of Excel's Add Chart Element menu
+     * (VBA's `SetElement`): `'legendRight'`, `'dataLabelOutsideEnd'`, `'primaryValueAxisTitleRotated'`,
+     * `'primaryValueGridLinesMinorMajor'`, `'trendlineAddLinear'`, `'errorBarStandardDeviation'`…
+     *
+     * @remarks
+     * Each name is one of the setters below, applied as Excel applies it: a data label element to
+     * every series, a trendline or error bar element to every series that takes one.
+     *
+     * @throws ExpectedError for an element the chart has no place for (a secondary axis's on a chart
+     * without one, a 3-D wall), or one Excel refuses on its type.
+     */
+    setElement(element: IChart.Element, options?: ITransaction.OperationOptions): this;
+    /**
+     * Sets several properties of the chart and its parts at once, as one step to undo.
+     *
+     * @example
+     * ```ts
+     * chart.update({
+     *   title: 'Sales by Month',
+     *   legend: { position: 'right' },
+     *   valueAxis: { minimum: 0, numberFormat: '#,##0' }
+     * });
+     * ```
      */
-    getAxes(): readonly IChart.IAxis[];
+    update(update: IChart.Update, options?: ITransaction.OperationOptions): this;
     /**
      * Returns the name of the pivot table the chart draws, or `null` if it is not a pivot chart.
      *
@@ -54,6 +249,50 @@ export interface IChart extends IModel, IMovable.IContent {
      * series name are wherever the table last put them.
      */
     getPivotSource(): string | null;
+    /**
+     * Returns the chart laid out as Excel lays it out: every rect, axis scale, tick label, bar and
+     * point, in px from the chart's top-left, with every color concrete.
+     *
+     * @param size The chart's size in px, unzoomed. Defaults to the movable's bounds.
+     *
+     * @returns `null` when the chart cannot be laid out: it has no size, or it is of a type not yet
+     * laid out (waterfall, histogram, pareto, box and whisker, treemap, sunburst, funnel, map).
+     *
+     * @remarks
+     * Values are those the file cached. Automatic axis bounds and units read back as numbers here,
+     * the way Excel's `MinimumScale` does.
+     *
+     * @example
+     * ```ts
+     * const layout = chart.getLayout({ width: 480, height: 288 });
+     * const valueAxis = layout?.axes.find(axis => axis.kind === 'value');
+     * console.log(valueAxis?.min, valueAxis?.max, valueAxis?.majorUnit);
+     * ```
+     */
+    getLayout(size?: {
+        width: number;
+        height: number;
+    }): ChartLayout | null;
+    /**
+     * Replaces every series with the series Excel makes of `source`, as Insert Chart does.
+     *
+     * @param source The cells: a range, or an address. A bare address is on the chart's sheet; several
+     * areas are separated by commas.
+     * @param seriesBy Whether each series is a row or a column of the cells. `'auto'` lets the cells
+     * decide, as Insert Chart does.
+     *
+     * @remarks
+     * The same as Office Scripts' `setData` and VBA's `SetSourceData`. Series that take the place of
+     * existing ones keep how those are drawn; any more are drawn as a new chart of the type draws them.
+     *
+     * @throws ExpectedError when `source` holds no cells.
+     */
+    setData(source: ICellRange | ICellRanges | string, seriesBy?: IChart.SeriesBy, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IChart.IListeners, options?: IListener.Options): IListener.Remove;
     /**
      * Returns the movable that places the chart on the sheet, or `null` if it is not placed by one.
      *
@@ -66,15 +305,6 @@ export interface IChart extends IModel, IMovable.IContent {
      * Deletes the chart, and with it the movable that places it.
      */
     delete(options?: ITransaction.OperationOptions): void;
-    /**
-     * Returns the chart's own markup, or `null` if none was captured.
-     *
-     * @remarks
-     * Read-only, and the one escape hatch for what the chart does not model yet: it is the
-     * `<c:chartSpace>` the chart was read from, not the parts that markup references, with its
-     * formulas as they are now. It will be removed when the chart is modeled.
-     */
-    getXML(): string | null;
     /** @internal */
     toJSON(toResourceId?: (resource: IResource) => number | null): IChart.JSON | null;
     /** For runtime type checking. */
@@ -88,6 +318,143 @@ export interface IChart extends IModel, IMovable.IContent {
  * {@link IChart}
  */
 export declare namespace IChart {
+    /**
+     * A chart type, by the names Office Scripts gives them (`ExcelScript.ChartType`).
+     *
+     * @remarks
+     * A new chart (`sheet.getCharts().add`), or a chart given a type, can be any type of Excel's
+     * gallery: the column, bar, line, pie, doughnut, area, scatter, bubble and radar forms, flat or
+     * 3-D; the surfaces; and the 2016 types (waterfall, treemap, sunburst, histogram, pareto, box and
+     * whisker, funnel, region map), whose model is made and saved as Excel makes it; every one of
+     * them is drawn but the region map, which is drawn as a placeholder. A series given a type can be any flat type. A new
+     * chart can also be one of the four stock types, made of exactly their series in order
+     * (`stockHLC`: high, low, close; `stockOHLC` with the open first; `stockVHLC` and `stockVOHLC`
+     * with the volume before them), which no series can be given. The read vocabulary of earlier
+     * versions is accepted too: `column` for `columnClustered`, `columnPercentStacked` for
+     * `columnStacked100`, `scatter` for `xyscatter`.
+     *
+     * A kind of the host's own, registered with `ChartKinds`, is `custom:<kind>`: the chart is made
+     * as a column chart is, its categories and values on a pair of axes, and laid out and painted by
+     * the kind. {@link IChart.getChartType} answers it back.
+     */
+    type Type = 'columnClustered' | 'columnStacked' | 'columnStacked100' | 'barClustered' | 'barStacked' | 'barStacked100' | 'line' | 'lineStacked' | 'lineStacked100' | 'lineMarkers' | 'lineMarkersStacked' | 'lineMarkersStacked100' | 'pie' | 'pieExploded' | 'pieOfPie' | 'barOfPie' | 'doughnut' | 'doughnutExploded' | 'area' | 'areaStacked' | 'areaStacked100' | 'xyscatter' | 'xyscatterLines' | 'xyscatterLinesNoMarkers' | 'xyscatterSmooth' | 'xyscatterSmoothNoMarkers' | 'bubble' | 'bubble3DEffect' | 'radar' | 'radarMarkers' | 'radarFilled' | 'stockHLC' | 'stockOHLC' | 'stockVHLC' | 'stockVOHLC' | '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';
+    /**
+     * Whether each series is a row or a column of a chart's cells; `'auto'` lets the cells decide, as
+     * Insert Chart does: series in columns when the data is taller than it is wide.
+     */
+    type SeriesBy = 'auto' | 'rows' | 'columns';
+    /** What an element of a chart is: see {@link IChart.IElement.getElementType}. */
+    type ElementType = 'chartArea' | 'title' | 'legend' | 'legendEntry' | 'plotArea' | 'dataTable' | 'axis' | 'axisTitle' | 'gridlines' | 'series' | 'point' | 'marker' | 'dataLabels' | 'dataLabel' | 'trendline' | 'trendlineLabel' | 'errorBars' | 'chartGroup' | 'upDownBars' | 'hiLoLines' | 'dropLines' | 'seriesLines';
+    /**
+     * A part of a chart: its title, an axis, a series, a point, a trendline… Every part is one, and
+     * each is the same object however often it is asked for, across edits that do not remove it.
+     *
+     * @remarks
+     * Each part's own interface says what it sets; this says where it is. Its type flag
+     * (`isISeries`, `isIAxis`, `isITitle`…) narrows it to that interface.
+     */
+    interface IElement {
+        /** Returns the chart the element is part of. */
+        getChart(): IChart;
+        /**
+         * Returns the element this one is part of: a point's series, a gridline's axis, a legend
+         * entry's legend. The parts at the top (the title, the legend, the plot area, an axis, a
+         * series, a group) are the chart area's; the chart area has none.
+         */
+        getParent(): IChart.IElement | null;
+        /**
+         * Returns what the element is. A series' marker and a point's are both `'marker'`, and the
+         * major and minor gridlines both `'gridlines'`; their paths tell them apart.
+         */
+        getElementType(): IChart.ElementType;
+        /**
+         * Returns where the element is in its chart, as {@link IChart.getElement} takes it.
+         *
+         * @remarks
+         * A path is its parts' names joined by `/`, and does not change while the part is there:
+         * - `chartArea`, `title`, `legend`, `legend/entries/<n>`, `plotArea`, `dataTable`, and
+         *   `dataLabels` (every series' at once);
+         * - `axes/<primary|secondary>/<category|value|series>`, and an axis's `…/title`,
+         *   `…/majorGridlines` and `…/minorGridlines`;
+         * - `series/<key>`, and a series' `…/marker`, `…/dataLabels`, `…/errorBars/<x|y>`,
+         *   `…/trendlines/<n>`, `…/trendlines/<n>/label`, `…/points/<n>`, `…/points/<n>/marker` and
+         *   `…/points/<n>/dataLabel`;
+         * - `groups/<n>`, and a group's `…/upDownBars`, `…/hiLoLines`, `…/dropLines` and `…/seriesLines`.
+         *
+         * A series' key is its index in the file (`c:idx`), which an edit does not change; its place in
+         * the plot order can change. A point, a trendline, a legend entry and a group are named by their
+         * place, from 0: when one before it is removed, the path names the one that took its place.
+         */
+        getPath(): string;
+        /**
+         * Returns what the element is drawn with, where it is drawn with a fill or a line. An element
+         * with text answers an {@link ITextBoxStyle}, which holds its font too.
+         */
+        getStyle?(): IShapeStyle;
+    }
+    /** The chart area: the whole chart, with its fill, border and the font every text takes. */
+    interface IChartArea extends IChart.IElement {
+        /** Returns what the chart area is drawn with: its fill, border and the chart's font (see {@link IChart.getStyle}). */
+        getStyle(): ITextBoxStyle;
+        /** Returns whether the chart area's corners are rounded. */
+        getRoundedCorners(): boolean;
+        /** Sets whether the chart area's corners are rounded. */
+        setRoundedCorners(rounded: boolean, options?: ITransaction.OperationOptions): this;
+        /** Sets several properties of the chart area at once, as one step to undo. */
+        update(update: IChart.IChartArea.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIChartArea: true;
+    }
+    /**
+     * {@inheritDoc IChart.IChartArea}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IChartArea}
+     */
+    namespace IChartArea {
+        /** What {@link IChart.IChartArea.update} sets; each field as its setter takes it. */
+        interface Update {
+            style?: ITextBoxStyle.Update;
+            roundedCorners?: boolean;
+        }
+    }
+    /**
+     * Options for adding a chart: `sheet.getCharts().add(source, options)`.
+     */
+    interface AddOptions extends IMovable.OperationOptions {
+        /**
+         * The chart's type.
+         *
+         * @defaultValue `'columnClustered'`
+         */
+        type?: IChart.Type | string;
+        /**
+         * Whether each series is a row or a column of the cells.
+         *
+         * @defaultValue `'auto'`
+         */
+        seriesBy?: IChart.SeriesBy;
+        /**
+         * The chart's frame in pixels. A size with no position is placed in the middle of the visible
+         * window, or at the selection where there is none.
+         *
+         * @defaultValue Excel's 5 by 3 inches (480 by 288 pixels)
+         */
+        bounds?: Partial<Bounds>;
+        /**
+         * How the chart moves and resizes with the cells under it.
+         *
+         * @defaultValue {@link IAnchored.Type.TwoCell}
+         */
+        anchorType?: IAnchored.Type;
+        /**
+         * The chart's name.
+         *
+         * @defaultValue A name made from the type, such as `Chart 3`.
+         */
+        name?: string;
+    }
     /**
      * One series of a chart: what it is called and the cells it plots.
      *
@@ -96,7 +463,7 @@ export declare namespace IChart {
      * chart's own dialog state it. The formula is the contract: it is what can say `#REF!`, name a
      * defined name, or point at another workbook. The `get…Range` forms resolve the plain case.
      */
-    interface ISeries {
+    interface ISeries extends IChart.IElement {
         /**
          * Returns the series' name, or `null` if it has none.
          *
@@ -141,54 +508,1573 @@ export declare namespace IChart {
          */
         getCategoriesRange(): ICellRange | null;
         /**
-         * Returns how the series is drawn. The same as {@link IChart.getChartType} except in a combo.
+         * Returns the formula for a bubble series' sizes, or `null` if the series states none.
+         */
+        getBubbleSizesFormula(): string | null;
+        /**
+         * Returns how the series is drawn, by the names of {@link IChart.Type}. The same as
+         * {@link IChart.getChartType} except in a combo, or where series of one group differ in markers.
          */
         getChartType(): string;
         /**
          * Returns `true` if the series is plotted against the secondary axes.
          */
         isSecondaryAxis(): boolean;
+        /**
+         * Sets the series' name: text, a cell, or a formula naming one (`=Sales!$C$3`); `null` for none,
+         * which shows as `Series1`.
+         */
+        setName(name: string | ICellRange | null, options?: ITransaction.OperationOptions): this;
+        /**
+         * Sets the values the series plots: cells, a formula naming them, or an array (`{1,2,3}`).
+         */
+        setValues(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Sets the categories the values are plotted against — a scatter or bubble series' x values —
+         * as cells, a formula naming them, or an array; `null` for none, which plots against 1, 2, 3…
+         */
+        setXAxisValues(source: ICellRange | string | null, options?: ITransaction.OperationOptions): this;
+        /**
+         * Sets a bubble series' sizes, as cells, a formula naming them, or an array.
+         */
+        setBubbleSizes(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Draws the series as another type, moving it to the group of that type, as Excel does: on its
+         * own axes where the type can share them, else on the other pair or new secondary axes. The
+         * series is drawn in its own color as a new series of the type is.
+         *
+         * @remarks
+         * Bubble and 3-D types turn every series of the chart into that type. A stock chart's series
+         * given another type leaves the stock group, on the other axes.
+         *
+         * @throws ExpectedError for a stock type, which Excel gives no series, and for a 3-D form, a
+         * surface or a 2016 type, which take the whole chart ({@link IChart.setChartType}).
+         */
+        setChartType(type: IChart.Type | string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the axes the series is plotted against; a pie's are `'primary'`.
+         */
+        getAxisGroup(): IChart.AxisGroup;
+        /**
+         * Moves the series to the primary or secondary axes, keeping how it is drawn. The secondary
+         * axes are made when the first series moves to them, and removed with the last.
+         */
+        setAxisGroup(group: IChart.AxisGroup, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns what the series is drawn with: the fill of its bars, areas or slices and its line.
+         *
+         * @remarks
+         * Reads resolve to the series' automatic color where it states none; `setFill(null)` hands the
+         * fill back to it.
+         */
+        getStyle(): IShapeStyle;
+        /**
+         * Returns the series' marker: on a line, scatter or radar series, what each point is drawn as.
+         */
+        getMarker(): IChart.IMarker;
+        /**
+         * Returns the series' data labels.
+         */
+        getDataLabels(): IChart.IDataLabels;
+        /**
+         * Returns the series' trendlines, in the order the legend lists them.
+         *
+         * @remarks
+         * A trendline is named by its place in the series: after one before it is deleted, a trendline
+         * held from earlier names the one that took its place, as in Office Scripts.
+         */
+        getTrendlines(): readonly IChart.ITrendline[];
+        /** Returns the series' trendline at `index`, from 0, or `null` where it has none there. */
+        getChartTrendline(index: number): IChart.ITrendline | null;
+        /**
+         * Adds a trendline to the series, as Excel adds one: a dotted 1.5 pt line in the series' color,
+         * with no label. A polynomial is of order 2 and a moving average of period 2 until set.
+         *
+         * @param type The fit; `linear` by default.
+         * @throws ExpectedError on a series Excel draws no trendline for: a pie, doughnut, radar,
+         * surface, 3-D or stacked series, or a 2016 chart's.
+         */
+        addChartTrendline(type?: IChart.TrendlineType, options?: ITransaction.OperationOptions): IChart.ITrendline;
+        /**
+         * Returns the error bars of the series' x values: a scatter's or bubble's only. Their setters
+         * throw `ExpectedError` on another series.
+         */
+        getXErrorBars(): IChart.IErrorBars;
+        /** Returns the error bars of the series' values: along the value axis. */
+        getYErrorBars(): IChart.IErrorBars;
+        /**
+         * Returns the up/down bars of the series' group: a line or stock chart's. Their setters throw
+         * `ExpectedError` on another series.
+         */
+        getUpDownBars(): IChart.IUpDownBars;
+        /**
+         * Returns the high-low lines of the series' group: a line or stock chart's. Their setters throw
+         * `ExpectedError` on another series.
+         */
+        getHiLoLines(): IChart.ILines;
+        /**
+         * Returns the drop lines of the series' group: a line, area or stock chart's. Their setters throw
+         * `ExpectedError` on another series.
+         */
+        getDropLines(): IChart.ILines;
+        /**
+         * Returns the series lines of the series' group: stacked or 100% stacked bars', or a pie of
+         * pie's. Their setters throw `ExpectedError` on another series.
+         */
+        getSeriesLines(): IChart.ILines;
+        /**
+         * Returns the gap between clusters of bars, as a percentage of a bar's width; on a line or stock
+         * series, the gap between its group's up/down bars; on a pie of pie or bar of pie, the gap between
+         * its two plots, as a percentage of the second plot's size. `null` for another series, and for a
+         * line or stock series whose group shows no up/down bars.
+         *
+         * @remarks
+         * Every bar of the series' group shares it: setting it sets the group's.
+         */
+        getGapWidth(): number | null;
+        /**
+         * Sets the gap between clusters of bars, 0 to 500, for the series' whole group; on a line or
+         * stock series, the gap between its group's up/down bars; on a pie of pie or bar of pie, the gap
+         * between its plots.
+         *
+         * @throws ExpectedError on a series that is not a bar or an of-pie, and on a line or stock series
+         * whose group shows no up/down bars (see {@link IChart.IUpDownBars.setGapWidth}).
+         */
+        setGapWidth(gapWidth: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns how far bars of one cluster overlap, -100 to 100 percent of a bar's width, or `null`
+         * for a series that is not a bar.
+         */
+        getOverlap(): number | null;
+        /**
+         * Sets how far bars of one cluster overlap, for the series' whole group.
+         */
+        setOverlap(overlap: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the size of a bubble chart's largest bubble, 0 to 300 percent of Excel's default, or
+         * `null` for a series that is not a bubble's.
+         */
+        getBubbleScale(): number | null;
+        /**
+         * Sets the size of a bubble chart's largest bubble, 0 to 300 percent of Excel's default, for the
+         * series' whole group. The bubbles pad the axes in proportion.
+         *
+         * @throws ExpectedError on a series that is not a bubble's, and for a scale outside that.
+         */
+        setBubbleScale(bubbleScale: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether a bubble chart draws a bubble for a negative size, as large as its magnitude, or
+         * `null` for a series that is not a bubble's.
+         */
+        getShowNegativeBubbles(): boolean | null;
+        /**
+         * Sets whether a bubble chart draws a bubble for a negative size, for the series' whole group.
+         *
+         * @throws ExpectedError on a series that is not a bubble's.
+         */
+        setShowNegativeBubbles(show: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether a bubble's size is its area's or its width's, or `null` for a series that is not
+         * a bubble's.
+         */
+        getBubbleSizeRepresents(): IChart.BubbleSizeRepresents | null;
+        /**
+         * Sets whether a bubble's size is its area's or its width's, for the series' whole group.
+         *
+         * @throws ExpectedError on a series that is not a bubble's.
+         */
+        setBubbleSizeRepresents(represents: IChart.BubbleSizeRepresents, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns how a pie of pie or bar of pie chooses the points of its second plot, or `null` for
+         * another series. Excel's automatic split, the last third of the points, reads as by position.
+         */
+        getSplitType(): IChart.SplitType | null;
+        /**
+         * Sets how a pie of pie or bar of pie chooses the points of its second plot. As in Excel, a split
+         * by value starts from a value of 1, and one by position or by hand from the points the second
+         * plot has now.
+         *
+         * @throws ExpectedError on a series that is not a pie of pie or bar of pie.
+         */
+        setSplitType(splitType: IChart.SplitType, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns what a pie of pie or bar of pie splits its points by: how many of the last go to the
+         * second plot, or the value or percentage of the total below which they do. `null` for a split by
+         * hand, and for another series.
+         */
+        getSplitValue(): number | null;
+        /**
+         * Sets what a pie of pie or bar of pie splits its points by; on Excel's automatic split, it
+         * becomes a split by position.
+         *
+         * @throws ExpectedError on a series that is not a pie of pie or bar of pie, on a split by hand,
+         * and for a negative value.
+         */
+        setSplitValue(splitValue: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the size of a pie of pie's or bar of pie's second plot, as a percentage of the first
+         * pie's, or `null` for another series.
+         */
+        getSecondPlotSize(): number | null;
+        /**
+         * Sets the size of a pie of pie's or bar of pie's second plot, 5 to 200 percent of the first pie's.
+         *
+         * @throws ExpectedError on a series that is not a pie of pie or bar of pie, and for a size outside that.
+         */
+        setSecondPlotSize(secondPlotSize: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the indexes of the points in a pie of pie's or bar of pie's second plot, whatever chose
+         * them; empty for another series.
+         *
+         * @remarks
+         * VBA's `Point.SecondaryPlot`, for every point at once.
+         */
+        getSecondPlotPoints(): number[];
+        /**
+         * Puts these points, by index, in a pie of pie's or bar of pie's second plot and the others in
+         * the first: a split by hand.
+         *
+         * @throws ExpectedError on a series that is not a pie of pie or bar of pie, and for an index that
+         * is not a point's.
+         */
+        setSecondPlotPoints(points: readonly number[], options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the series as Excel's `SERIES` formula: `=SERIES(name, categories, values, order)`,
+         * a bubble's with its sizes fifth. Each part is a reference, a literal (`"Total"`, `{1,2,3}`),
+         * or empty.
+         */
+        getFormula(): string;
+        /**
+         * Sets the series from a `SERIES` formula (VBA's `Series.Formula`): its name, categories,
+         * values, place in the plot order (from 1) and, for a bubble, its sizes.
+         *
+         * @throws ExpectedError for text that is not a `SERIES` formula.
+         */
+        setFormula(formula: string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns one dimension of the series as drawn, each point as text (Office Scripts'
+         * `getDimensionValues`): the categories, the values, a scatter's x or y values, or a bubble's
+         * sizes.
+         */
+        getDimensionValues(dimension: IChart.SeriesDimension): string[];
+        /** Returns the series' place in the plot order, from 0. */
+        getPlotOrder(): number;
+        /**
+         * Moves the series to a place in the plot order, from 0: the order it is listed, stacked and
+         * drawn in. Its group's series are relisted in that order.
+         */
+        setPlotOrder(plotOrder: number, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a line or scatter series is drawn as a curve through its points. */
+        getSmooth(): boolean;
+        /**
+         * Sets whether a line or scatter series is drawn as a curve.
+         *
+         * @throws ExpectedError on a series that is not a line's or scatter's, as Excel refuses it.
+         */
+        setSmooth(smooth: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a bar's or bubble's negative points are drawn in the inverse of its fill. */
+        getInvertIfNegative(): boolean;
+        /**
+         * Sets whether a bar's or bubble's negative points are drawn in the inverse of its fill.
+         *
+         * @throws ExpectedError on a series that is not a bar's or bubble's, as Excel refuses it.
+         */
+        setInvertIfNegative(invert: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns how far a pie's or doughnut's slices are pulled out, as a percentage of the radius; 0 for not at all. */
+        getExplosion(): number;
+        /**
+         * Pulls a pie's or doughnut's slices out by a percentage of the radius; 0 puts them back.
+         *
+         * @throws ExpectedError on a series that is not a pie's or doughnut's, as Excel refuses it.
+         */
+        setExplosion(explosion: number, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the series' group colors each point differently, as a pie does. */
+        getVaryByCategories(): boolean;
+        /**
+         * Sets whether the series' group colors each point differently. A single series given it takes a
+         * point per value in the chart's colors, as Excel does; a pie denied it is drawn in one color.
+         */
+        setVaryByCategories(vary: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the series' points, one per value, each with what it states for itself: its fill,
+         * line, marker, explosion and label.
+         */
+        getPoints(): readonly IChart.IPoint[];
+        /** Removes the series from the chart, and its group when it was the group's last. */
+        delete(options?: ITransaction.OperationOptions): void;
+        /**
+         * Sets several properties of the series at once, as one step to undo.
+         */
+        update(update: IChart.ISeries.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isISeries: true;
+    }
+    /**
+     * {@inheritDoc IChart.ISeries}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ISeries}
+     */
+    namespace ISeries {
+        /** What {@link IChart.ISeries.update} sets; each field as its setter takes it. */
+        interface Update {
+            name?: string | ICellRange | null;
+            values?: ICellRange | string;
+            xAxisValues?: ICellRange | string | null;
+            bubbleSizes?: ICellRange | string;
+            chartType?: IChart.Type | string;
+            axisGroup?: IChart.AxisGroup;
+            style?: IShapeStyle.Update;
+            marker?: IChart.IMarker.Update;
+            dataLabels?: IChart.IDataLabels.Update;
+            gapWidth?: number;
+            overlap?: number;
+            bubbleScale?: number;
+            showNegativeBubbles?: boolean;
+            bubbleSizeRepresents?: IChart.BubbleSizeRepresents;
+            /** Set before `splitValue`, as Excel's two writes are. */
+            splitType?: IChart.SplitType;
+            splitValue?: number;
+            secondPlotSize?: number;
+            secondPlotPoints?: readonly number[];
+            formula?: string;
+            plotOrder?: number;
+            smooth?: boolean;
+            invertIfNegative?: boolean;
+            explosion?: number;
+            varyByCategories?: boolean;
+        }
+    }
+    /** One dimension of a series (Office Scripts' `ChartSeriesDimension`). */
+    type SeriesDimension = 'categories' | 'values' | 'xvalues' | 'yvalues' | 'bubbleSizes';
+    /**
+     * One point of a series: what it states for itself, over the series (VBA's `Point`, Office
+     * Scripts' `ChartPoint`).
+     */
+    interface IPoint extends IChart.IElement {
+        /** Returns the point's index in its series, from 0. */
+        getIndex(): number;
+        /**
+         * Returns what the point is drawn with: a bar's or slice's fill and line; on a line series, its
+         * marker's fill and the line and outline at the point. Reads resolve to the series' own.
+         */
+        getStyle(): IShapeStyle;
+        /** Returns the point's marker, over the series' marker. */
+        getMarker(): IChart.IMarker;
+        /** Returns how far a slice is pulled out, as a percentage of the radius. */
+        getExplosion(): number;
+        /** Pulls a slice out by a percentage of the radius; 0 puts it back. @throws ExpectedError off a pie or doughnut. */
+        setExplosion(explosion: number, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a negative bar is drawn in the inverse of its fill, over the series. */
+        getInvertIfNegative(): boolean;
+        /** Sets whether this bar is drawn in the inverse of its fill when negative. @throws ExpectedError off a bar. */
+        setInvertIfNegative(invert: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether a waterfall's point is a total: its bar runs from zero to its value, which the
+         * points after it step from, rather than from the running total before it (VBA's `IsTotal`).
+         * `false` off a waterfall.
+         */
+        getIsTotal(): boolean;
+        /** Makes a waterfall's point a total, or a step again. @throws ExpectedError off a waterfall. */
+        setIsTotal(total: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the point's label. */
+        getDataLabel(): IChart.IDataLabel;
+        /** Returns whether the point's label is shown. */
+        getHasDataLabel(): boolean;
+        /** Shows the point's label with its value, or hides it. */
+        setHasDataLabel(has: boolean, options?: ITransaction.OperationOptions): this;
+        /** Sets several properties of the point at once, as one step to undo. */
+        update(update: IChart.IPoint.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIPoint: true;
+    }
+    /**
+     * {@inheritDoc IChart.IPoint}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IPoint}
+     */
+    namespace IPoint {
+        /** What {@link IChart.IPoint.update} sets; each field as its setter takes it. */
+        interface Update {
+            style?: IShapeStyle.Update;
+            marker?: IChart.IMarker.Update;
+            explosion?: number;
+            invertIfNegative?: boolean;
+            isTotal?: boolean;
+            hasDataLabel?: boolean;
+            dataLabel?: IChart.IDataLabel.Update;
+        }
+    }
+    /** The label of one point, over its series' labels. */
+    interface IDataLabel extends IChart.IElement {
+        /** Returns whether the label is shown. */
+        getVisible(): boolean;
+        /** Shows the label with its value, or hides it. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the label's own text, or `null` when it shows what its flags say. */
+        getText(): string | null;
+        /** Writes text into the label; `null` hands it back to its flags. */
+        setText(text: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns where the label sits, over the series' labels. */
+        getPosition(): IChart.DataLabelPosition;
+        /** Sets where the label sits. */
+        setPosition(position: IChart.DataLabelPosition, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows its point's value. */
+        getShowValue(): boolean;
+        setShowValue(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows its point's category. */
+        getShowCategoryName(): boolean;
+        setShowCategoryName(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows the series' name. */
+        getShowSeriesName(): boolean;
+        setShowSeriesName(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows its point's share of the whole. */
+        getShowPercentage(): boolean;
+        setShowPercentage(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows the series' legend key. */
+        getShowLegendKey(): boolean;
+        setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the label's number format, or `null` when it takes the values'. */
+        getNumberFormat(): string | null;
+        /** Sets the label's number format; `null` for the values' own. */
+        setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns what the label is drawn with: its fill, border and font, over the series' labels'. */
+        getStyle(): ITextBoxStyle;
+        /** Sets several properties of the label at once, as one step to undo. */
+        update(update: IChart.IDataLabel.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIDataLabel: true;
+    }
+    /**
+     * {@inheritDoc IChart.IDataLabel}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IDataLabel}
+     */
+    namespace IDataLabel {
+        /** What {@link IChart.IDataLabel.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            text?: string | null;
+            position?: IChart.DataLabelPosition;
+            showValue?: boolean;
+            showCategoryName?: boolean;
+            showSeriesName?: boolean;
+            showPercentage?: boolean;
+            showLegendKey?: boolean;
+            numberFormat?: string | null;
+            style?: ITextBoxStyle.Update;
+        }
+    }
+    /**
+     * A chart group: the series drawn one way against one pair of axes, and the options they share
+     * (VBA's `ChartGroup`). Office Scripts has no groups; its per-series options set the group's.
+     */
+    interface IChartGroup extends IChart.IElement {
+        /** Returns the group's place among the chart's groups, from 0. */
+        getIndex(): number;
+        /** Returns how the group's series are drawn, by the names of {@link IChart.Type}: its first series' type. */
+        getChartType(): string;
+        /** Returns the axes the group draws against; a pie's are `'primary'`. */
+        getAxisGroup(): IChart.AxisGroup;
+        /** Returns the group's series, in plot order. */
+        getSeries(): readonly IChart.ISeries[];
+        /** Returns the gap between clusters of bars, or `null` where the group has none. */
+        getGapWidth(): number | null;
+        /** Returns how far the group's bars overlap, or `null` where it has none. */
+        getOverlap(): number | null;
+        /** Returns whether the group colors each point differently. */
+        getVaryByCategories(): boolean;
+        /** Sets whether the group colors each point differently (see {@link IChart.ISeries.setVaryByCategories}). */
+        setVaryByCategories(vary: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the group's up/down bars: a line or stock group's (VBA's `UpBars` and `DownBars`). */
+        getUpDownBars(): IChart.IUpDownBars;
+        /** Returns the group's high-low lines: a line or stock group's. */
+        getHiLoLines(): IChart.ILines;
+        /** Returns the group's drop lines: a line, area or stock group's. */
+        getDropLines(): IChart.ILines;
+        /** Returns the group's series lines: stacked bars' or a pie of pie's. */
+        getSeriesLines(): IChart.ILines;
+        /** For runtime type checking. */
+        readonly isIChartGroup: true;
+    }
+    /** The plot area: where the series are drawn. Its place is the layout's; its fill and border are set here. */
+    interface IPlotArea extends IChart.IElement {
+        /** Returns what the plot area is drawn with: its fill and border (Office Scripts' `getFormat()`). */
+        getStyle(): IShapeStyle;
+        /** Returns the left of the plot area, axis labels included, in px from the chart's left; 0 without a layout. */
+        getLeft(): number;
+        getTop(): number;
+        getWidth(): number;
+        getHeight(): number;
+        /** Returns the left of the area inside the axes, in px from the chart's left; 0 without a layout. */
+        getInsideLeft(): number;
+        getInsideTop(): number;
+        getInsideWidth(): number;
+        getInsideHeight(): number;
+        /** Sets several properties of the plot area at once, as one step to undo. */
+        update(update: IChart.IPlotArea.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIPlotArea: true;
+    }
+    /**
+     * {@inheritDoc IChart.IPlotArea}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IPlotArea}
+     */
+    namespace IPlotArea {
+        /** What {@link IChart.IPlotArea.update} sets. */
+        interface Update {
+            style?: IShapeStyle.Update;
+        }
+    }
+    /** The data table: the chart's values in a table under the plot area, a row per series. */
+    interface IDataTable extends IChart.IElement {
+        /** Returns whether the table is shown. */
+        getVisible(): boolean;
+        /** Shows the table as Excel adds it (every border and the legend keys), or removes it. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether each row starts with the series' legend key. */
+        getShowLegendKey(): boolean;
+        /** Sets whether each row starts with the series' legend key, showing the table. */
+        setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the rows are parted by lines. */
+        getShowHorizontalBorder(): boolean;
+        setShowHorizontalBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the columns are parted by lines. */
+        getShowVerticalBorder(): boolean;
+        setShowVerticalBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the table is outlined. */
+        getShowOutlineBorder(): boolean;
+        setShowOutlineBorder(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns what the table is drawn with: its lines, a fill, and its font. */
+        getStyle(): ITextBoxStyle;
+        /** Sets several properties of the table at once, as one step to undo. */
+        update(update: IChart.IDataTable.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIDataTable: true;
+    }
+    /**
+     * {@inheritDoc IChart.IDataTable}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IDataTable}
+     */
+    namespace IDataTable {
+        /** What {@link IChart.IDataTable.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            showLegendKey?: boolean;
+            showHorizontalBorder?: boolean;
+            showVerticalBorder?: boolean;
+            showOutlineBorder?: boolean;
+            style?: ITextBoxStyle.Update;
+        }
+    }
+    /** One entry of the legend: a series', or a slice's (VBA's `LegendEntry`). */
+    interface ILegendEntry extends IChart.IElement {
+        /** Returns the entry's place in the legend, from 0. */
+        getIndex(): number;
+        /** Returns the entry's text. */
+        getText(): string;
+        /** Returns whether the entry is shown. */
+        getVisible(): boolean;
+        /** Hides the entry, or shows it again. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the entry's style: its font, over the legend's. An entry has no fill or line of its
+         * own, so they read the legend's, and setting them throws.
+         */
+        getStyle(): ITextBoxStyle;
+        /** For runtime type checking. */
+        readonly isILegendEntry: true;
+    }
+    /**
+     * An axis's title: a chart title that can be turned.
+     *
+     * @remarks
+     * Its text is `null` when there is no title; setting its text to `null` removes it. A title shown
+     * with no text of its own shows Excel's, `Axis Title`.
+     */
+    interface IAxisTitle extends IChart.ITitle {
+        /** Returns the text's angle in degrees counterclockwise, `'vertical'` for stacked letters, or `'auto'`. */
+        getTextOrientation(): number | 'vertical' | 'auto';
+        /** Turns the text: degrees counterclockwise (90 reads up), `'vertical'` for stacked letters, `'auto'` for Excel's own. */
+        setTextOrientation(orientation: number | 'vertical' | 'auto', options?: ITransaction.OperationOptions): this;
+        /** Sets several properties of the title at once, as one step to undo. */
+        update(update: IChart.IAxisTitle.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIAxisTitle: true;
+    }
+    /**
+     * {@inheritDoc IChart.IAxisTitle}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IAxisTitle}
+     */
+    namespace IAxisTitle {
+        /** What {@link IChart.IAxisTitle.update} sets; each field as its setter takes it. */
+        interface Update extends IChart.ITitle.Update {
+            textOrientation?: number | 'vertical' | 'auto';
+        }
+    }
+    /** How an axis is scaled (Office Scripts' `ChartAxisScaleType`). */
+    type AxisScaleType = 'linear' | 'logarithmic';
+    /** The unit an axis's labels are shown in (Office Scripts' `ChartAxisDisplayUnit`). */
+    type AxisDisplayUnit = 'none' | 'hundreds' | 'thousands' | 'tenThousands' | 'hundredThousands' | 'millions' | 'tenMillions' | 'hundredMillions' | 'billions' | 'trillions' | 'custom';
+    /** Where the crossing axis crosses an axis (Office Scripts' `ChartAxisPosition`). */
+    type AxisCrosses = 'automatic' | 'maximum' | 'minimum' | 'custom';
+    /** An axis's tick marks (Office Scripts' `ChartAxisTickMark`). */
+    type AxisTickMark = 'none' | 'inside' | 'outside' | 'cross';
+    /** Where an axis's labels sit (Office Scripts' `ChartAxisTickLabelPosition`). */
+    type AxisTickLabelPosition = 'nextToAxis' | 'high' | 'low' | 'none';
+    /** A date axis's unit (Office Scripts' `ChartAxisTimeUnit`). */
+    type AxisTimeUnit = 'days' | 'months' | 'years';
+    /** What a category axis reads its categories as (Office Scripts' `ChartAxisCategoryType`). */
+    type AxisCategoryType = 'automatic' | 'textAxis' | 'dateAxis';
+    /**
+     * A chart element, by the names of VBA's `MsoChartElementType` without its prefix, in lower camel
+     * case: what {@link IChart.setElement} adds, places or removes.
+     */
+    type Element = 'chartTitleNone' | 'chartTitleCenteredOverlay' | 'chartTitleAboveChart' | 'legendNone' | 'legendRight' | 'legendTop' | 'legendLeft' | 'legendBottom' | 'legendRightOverlay' | 'legendLeftOverlay' | 'dataLabelNone' | 'dataLabelShow' | 'dataLabelCenter' | 'dataLabelInsideEnd' | 'dataLabelInsideBase' | 'dataLabelOutsideEnd' | 'dataLabelLeft' | 'dataLabelRight' | 'dataLabelTop' | 'dataLabelBottom' | 'dataLabelBestFit' | 'dataLabelCallout' | 'primaryCategoryAxisTitleNone' | 'primaryCategoryAxisTitleAdjacentToAxis' | 'primaryCategoryAxisTitleBelowAxis' | 'primaryCategoryAxisTitleRotated' | 'primaryCategoryAxisTitleVertical' | 'primaryCategoryAxisTitleHorizontal' | 'primaryValueAxisTitleNone' | 'primaryValueAxisTitleAdjacentToAxis' | 'primaryValueAxisTitleBelowAxis' | 'primaryValueAxisTitleRotated' | 'primaryValueAxisTitleVertical' | 'primaryValueAxisTitleHorizontal' | 'secondaryCategoryAxisTitleNone' | 'secondaryCategoryAxisTitleAdjacentToAxis' | 'secondaryCategoryAxisTitleBelowAxis' | 'secondaryCategoryAxisTitleRotated' | 'secondaryCategoryAxisTitleVertical' | 'secondaryCategoryAxisTitleHorizontal' | 'secondaryValueAxisTitleNone' | 'secondaryValueAxisTitleAdjacentToAxis' | 'secondaryValueAxisTitleBelowAxis' | 'secondaryValueAxisTitleRotated' | 'secondaryValueAxisTitleVertical' | 'secondaryValueAxisTitleHorizontal' | 'seriesAxisTitleNone' | 'seriesAxisTitleRotated' | 'seriesAxisTitleVertical' | 'seriesAxisTitleHorizontal' | 'primaryValueGridLinesNone' | 'primaryValueGridLinesMinor' | 'primaryValueGridLinesMajor' | 'primaryValueGridLinesMinorMajor' | 'primaryCategoryGridLinesNone' | 'primaryCategoryGridLinesMinor' | 'primaryCategoryGridLinesMajor' | 'primaryCategoryGridLinesMinorMajor' | 'secondaryValueGridLinesNone' | 'secondaryValueGridLinesMinor' | 'secondaryValueGridLinesMajor' | 'secondaryValueGridLinesMinorMajor' | 'secondaryCategoryGridLinesNone' | 'secondaryCategoryGridLinesMinor' | 'secondaryCategoryGridLinesMajor' | 'secondaryCategoryGridLinesMinorMajor' | 'seriesAxisGridLinesNone' | 'seriesAxisGridLinesMinor' | 'seriesAxisGridLinesMajor' | 'seriesAxisGridLinesMinorMajor' | 'primaryCategoryAxisNone' | 'primaryCategoryAxisShow' | 'primaryCategoryAxisWithoutLabels' | 'primaryCategoryAxisReverse' | 'primaryCategoryAxisThousands' | 'primaryCategoryAxisMillions' | 'primaryCategoryAxisBillions' | 'primaryCategoryAxisLogScale' | 'primaryValueAxisNone' | 'primaryValueAxisShow' | 'primaryValueAxisThousands' | 'primaryValueAxisMillions' | 'primaryValueAxisBillions' | 'primaryValueAxisLogScale' | 'secondaryCategoryAxisNone' | 'secondaryCategoryAxisShow' | 'secondaryCategoryAxisWithoutLabels' | 'secondaryCategoryAxisReverse' | 'secondaryCategoryAxisThousands' | 'secondaryCategoryAxisMillions' | 'secondaryCategoryAxisBillions' | 'secondaryCategoryAxisLogScale' | 'secondaryValueAxisNone' | 'secondaryValueAxisShow' | 'secondaryValueAxisThousands' | 'secondaryValueAxisMillions' | 'secondaryValueAxisBillions' | 'secondaryValueAxisLogScale' | 'seriesAxisNone' | 'seriesAxisShow' | 'seriesAxisWithoutLabeling' | 'seriesAxisReverse' | 'dataTableNone' | 'dataTableShow' | 'dataTableWithLegendKeys' | 'trendlineNone' | 'trendlineAddLinear' | 'trendlineAddExponential' | 'trendlineAddLinearForecast' | 'trendlineAddTwoPeriodMovingAverage' | 'errorBarNone' | 'errorBarStandardError' | 'errorBarPercentage' | 'errorBarStandardDeviation' | 'lineNone' | 'lineDropLine' | 'lineHiLoLine' | 'lineSeriesLine' | 'lineDropHiLoLine' | 'upDownBarsNone' | 'upDownBarsShow' | 'plotAreaNone' | 'plotAreaShow' | 'chartWallNone' | 'chartWallShow' | 'chartFloorNone' | 'chartFloorShow';
+    /** What a bubble's size is: its area's or its width's (VBA's `XlSizeRepresents`). */
+    type BubbleSizeRepresents = 'area' | 'width';
+    /**
+     * How a pie of pie or bar of pie chooses the points of its second plot: the last so many, those
+     * below a value or a percentage of the total, or those chosen by hand (Office Scripts'
+     * `ChartSplitType`).
+     */
+    type SplitType = 'splitByPosition' | 'splitByValue' | 'splitByPercentValue' | 'splitByCustomSplit';
+    /** The primary axes, or the secondary ones a combo plots some series against. */
+    type AxisGroup = 'primary' | 'secondary';
+    /**
+     * How a blank cell is plotted: not at all (a gap), as zero, or with the line drawn across it,
+     * by Office Scripts' names (`ChartDisplayBlanksAs`).
+     */
+    type DisplayBlanksAs = 'notPlotted' | 'zero' | 'interplotted';
+    /** Where a legend sits: on a side of the chart, or in its top right corner. */
+    type LegendPosition = 'top' | 'bottom' | 'left' | 'right' | 'corner';
+    /** What a marker is drawn as; `'automatic'` lets the series' place in the chart choose. */
+    type MarkerSymbol = 'automatic' | 'none' | 'square' | 'diamond' | 'triangle' | 'x' | 'star' | 'dot' | 'dash' | 'circle' | 'plus';
+    /** Where a data label sits by its point, by Office Scripts' names (`ChartDataLabelPosition`). */
+    type DataLabelPosition = 'center' | 'insideEnd' | 'insideBase' | 'outsideEnd' | 'left' | 'right' | 'top' | 'bottom' | 'bestFit';
+    /**
+     * The chart's axes.
+     */
+    interface IAxes {
+        /**
+         * Returns the axes the chart shows, in the order the chart lists them; a hidden axis is left out.
+         */
+        getItems(): readonly IChart.IAxis[];
+        /**
+         * Returns the axis the values are measured along, shown or hidden: a scatter's vertical one.
+         * `null` when the chart has none on those axes.
+         *
+         * @param group The primary axes, by default, or the secondary ones.
+         */
+        getValueAxis(group?: IChart.AxisGroup): IChart.IAxis | null;
+        /**
+         * Returns the axis the categories run along, shown or hidden: a scatter's horizontal one.
+         * `null` when the chart has none on those axes.
+         */
+        getCategoryAxis(group?: IChart.AxisGroup): IChart.IAxis | null;
+        /**
+         * Returns the series axis of a 3-D or surface chart, or `null`.
+         */
+        getSeriesAxis(): IChart.IAxis | null;
+        /**
+         * Returns the axis of `type` on `group`'s axes, or `null`.
+         */
+        getChartAxis(type: 'category' | 'value' | 'series', group?: IChart.AxisGroup): IChart.IAxis | null;
     }
     /**
      * One axis of a chart.
      */
-    interface IAxis {
+    interface IAxis extends IChart.IElement {
         /**
          * Returns what the axis measures: categories, values, dates, or — on a surface or 3-D chart —
          * the series themselves.
          */
         getKind(): 'category' | 'value' | 'date' | 'series';
         /**
-         * Returns the axis title, or `null` if it has none.
+         * Returns the axes the axis belongs to.
+         */
+        getAxisGroup(): IChart.AxisGroup;
+        /**
+         * Returns the axis's title: its text, font, fill and orientation. An axis always has one
+         * to set, shown or not.
          *
          * @remarks
-         * Often the only place the units of a chart are stated.
+         * Often the only place the units of a chart are stated. A formula (`=Sheet1!$B$1`) as its text
+         * shows a cell's text.
+         *
+         * @example
+         * ```ts
+         * axis.getTitle().getText();        // 'Units', or null
+         * axis.getTitle().setText('Units');
+         * ```
          */
-        getTitle(): string | null;
+        getTitle(): IChart.IAxisTitle;
         /**
          * Returns the number format of the axis labels, or `null` if the axis states none.
          */
         getNumberFormat(): string | null;
+        /**
+         * Sets the number format of the axis labels, no longer taking the format of the cells.
+         */
+        setNumberFormat(formatCode: string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether the labels take the number format of the cells the chart plots.
+         */
+        getLinkNumberFormat(): boolean;
+        /**
+         * Sets whether the labels take the number format of the cells the chart plots.
+         */
+        setLinkNumberFormat(linked: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether the axis is shown. A hidden axis still scales its series.
+         */
+        getVisible(): boolean;
+        /**
+         * Shows or hides the axis.
+         */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the least value the axis shows: the one set, or the one the chart chose. `null` for an
+         * axis of categories that states none.
+         *
+         * @remarks
+         * An automatic value is the one the chart is drawn with at its size, as Excel's `MinimumScale`
+         * reads.
+         */
+        getMinimum(): number | null;
+        /**
+         * Sets the least value the axis shows, or `'auto'` to let the chart choose.
+         */
+        setMinimum(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether the chart chooses the least value.
+         */
+        isMinimumAuto(): boolean;
+        /**
+         * Returns the greatest value the axis shows: the one set, or the one the chart chose.
+         *
+         * @see {@link getMinimum}
+         */
+        getMaximum(): number | null;
+        /**
+         * Sets the greatest value the axis shows, or `'auto'` to let the chart choose.
+         */
+        setMaximum(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether the chart chooses the greatest value.
+         */
+        isMaximumAuto(): boolean;
+        /**
+         * Returns the interval between the axis's labeled ticks: the one set, or the one the chart chose.
+         *
+         * @see {@link getMinimum}
+         */
+        getMajorUnit(): number | null;
+        /**
+         * Sets the interval between labeled ticks, or `'auto'` to let the chart choose.
+         */
+        setMajorUnit(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns whether the chart chooses the interval between labeled ticks.
+         */
+        isMajorUnitAuto(): boolean;
+        /**
+         * Returns the lines across the plot area at the axis's labeled ticks.
+         */
+        getMajorGridlines(): IChart.IGridlines;
+        /**
+         * Returns the lines across the plot area between the labeled ticks.
+         */
+        getMinorGridlines(): IChart.IGridlines;
+        /**
+         * Returns whether the axis draws categories two or more levels deep a level at a time, each
+         * outer label spanning its group. `false` for an axis of values or dates.
+         *
+         * @remarks
+         * `true` by default, and on an axis whose categories have one level, where it changes nothing
+         * drawn. Off, each category has one label of all its levels.
+         */
+        getMultiLevel(): boolean;
+        /**
+         * Sets whether the axis draws categories two or more levels deep a level at a time. An axis of
+         * dates keeps no such setting, and is left as it is.
+         *
+         * @throws ExpectedError for an axis of values.
+         */
+        setMultiLevel(multiLevel: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Sets the categories of every series plotted on the axis: a range, an address, a defined name,
+         * or an array constant (`{"Q1","Q2"}`). A range two or more columns deep gives categories that
+         * many levels deep. Categories that are all dates make the axis a date axis, unless its type
+         * was set.
+         *
+         * @throws ExpectedError for an axis of values.
+         */
+        setCategoryNames(source: ICellRange | string, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the interval between the axis's minor ticks: the one set, or the one the chart chose
+         * (a fifth of the major unit, by belief). `null` for an axis of categories.
+         */
+        getMinorUnit(): number | null;
+        /** Sets the interval between minor ticks, or `'auto'` to let the chart choose. @throws ExpectedError on an axis of categories. */
+        setMinorUnit(value: number | 'auto', options?: ITransaction.OperationOptions): this;
+        /** Returns whether the chart chooses the minor unit. */
+        isMinorUnitAuto(): boolean;
+        /** Returns whether the axis is linear or logarithmic. */
+        getScaleType(): IChart.AxisScaleType;
+        /** Makes the axis linear or logarithmic (base 10). @throws ExpectedError on an axis of categories. */
+        setScaleType(scaleType: IChart.AxisScaleType, options?: ITransaction.OperationOptions): this;
+        /** Returns a logarithmic axis's base; 10 for a linear axis. */
+        getLogBase(): number;
+        /** Sets the base of a logarithmic axis, making it one. @throws ExpectedError for a base of 2 or less, or on an axis of categories. */
+        setLogBase(logBase: number, options?: ITransaction.OperationOptions): this;
+        /** Returns the unit the axis's labels are shown in: `'thousands'`, `'custom'`, or `'none'`. */
+        getDisplayUnit(): IChart.AxisDisplayUnit;
+        /** Shows the labels in a unit, with Excel's label for it, or `'none'`. @throws ExpectedError on an axis of categories. */
+        setDisplayUnit(unit: IChart.AxisDisplayUnit, options?: ITransaction.OperationOptions): this;
+        /** Returns the divisor of a custom display unit, or the built-in unit's; 1 for none. */
+        getCustomDisplayUnit(): number;
+        /** Shows the labels divided by `unit`, with Excel's label. */
+        setCustomDisplayUnit(unit: number, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the display unit's label is shown beside the axis. */
+        getShowDisplayUnitLabel(): boolean;
+        /** Shows or hides the display unit's label. Nothing changes on an axis with no display unit. */
+        setShowDisplayUnitLabel(show: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns where the crossing axis crosses this one: automatically (at zero), at this axis's
+         * maximum or minimum, or at a value ({@link getCrossesAt}).
+         */
+        getCrosses(): IChart.AxisCrosses;
+        /**
+         * Sets where the crossing axis crosses this one. At the maximum, the crossing axis moves to the
+         * far side of the plot (the top, or the right), as in Excel.
+         */
+        setCrosses(crosses: IChart.AxisCrosses, options?: ITransaction.OperationOptions): this;
+        /** Returns the value the crossing axis crosses this one at, when one is set; else `null`. */
+        getCrossesAt(): number | null;
+        /** Makes the crossing axis cross this one at `value` (a category's number from 1 on an axis of categories). */
+        setCrossesAt(value: number, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the axis runs from its maximum to its minimum. */
+        getReversePlotOrder(): boolean;
+        /** Reverses the axis. The crossing axis moves to the other side of the plot, as in Excel. */
+        setReversePlotOrder(reverse: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the axis's major tick marks. */
+        getMajorTickMark(): IChart.AxisTickMark;
+        setMajorTickMark(mark: IChart.AxisTickMark, options?: ITransaction.OperationOptions): this;
+        /** Returns the axis's minor tick marks. */
+        getMinorTickMark(): IChart.AxisTickMark;
+        setMinorTickMark(mark: IChart.AxisTickMark, options?: ITransaction.OperationOptions): this;
+        /** Returns where the labels sit: next to the axis, at the high or low end of the crossing axis, or nowhere. */
+        getTickLabelPosition(): IChart.AxisTickLabelPosition;
+        setTickLabelPosition(position: IChart.AxisTickLabelPosition, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the labels' angle in degrees counterclockwise (90 reads up), `'vertical'` for stacked
+         * letters, or `'auto'` for Excel's own.
+         */
+        getTextOrientation(): number | 'vertical' | 'auto';
+        /** Turns the labels: degrees from -90 to 90 counterclockwise, `'vertical'`, or `'auto'`. */
+        setTextOrientation(orientation: number | 'vertical' | 'auto', options?: ITransaction.OperationOptions): this;
+        /** Returns what the axis is drawn with: its line (a fill does not apply) and the labels' font. */
+        getStyle(): ITextBoxStyle;
+        /** Returns how many categories apart the labels are, or `null` when the chart chooses. */
+        getTickLabelSpacing(): number | null;
+        /** Labels every n-th category; `null` lets the chart choose. @throws ExpectedError off an axis of categories. */
+        setTickLabelSpacing(spacing: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns how many categories apart the tick marks are, or `null` when the chart chooses. */
+        getTickMarkSpacing(): number | null;
+        setTickMarkSpacing(spacing: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns a date axis's base unit: what one category spans. `null` for another axis. */
+        getBaseTimeUnit(): IChart.AxisTimeUnit | null;
+        /** Sets a date axis's base unit, or `'auto'` for the one its dates decide. @throws ExpectedError off a date axis. */
+        setBaseTimeUnit(unit: IChart.AxisTimeUnit | 'auto', options?: ITransaction.OperationOptions): this;
+        /** Returns the unit of a date axis's major unit, or `null` for another axis. */
+        getMajorTimeUnitScale(): IChart.AxisTimeUnit | null;
+        /** Sets a date axis's major unit with its time unit: `setMajorUnit(2)` and `setMajorTimeUnitScale('months')` label every two months. */
+        setMajorTimeUnitScale(unit: IChart.AxisTimeUnit, options?: ITransaction.OperationOptions): this;
+        /** Returns the unit of a date axis's minor unit, or `null` for another axis. */
+        getMinorTimeUnitScale(): IChart.AxisTimeUnit | null;
+        setMinorTimeUnitScale(unit: IChart.AxisTimeUnit, options?: ITransaction.OperationOptions): this;
+        /** Returns what a category axis reads its categories as: text, dates, or whichever the cells are. */
+        getCategoryType(): IChart.AxisCategoryType;
+        /** Makes a category axis read its categories as text or as dates, or as the cells decide. @throws ExpectedError on a value axis. */
+        setCategoryType(type: IChart.AxisCategoryType, options?: ITransaction.OperationOptions): this;
+        /**
+         * Sets several properties of the axis at once, as one step to undo.
+         */
+        update(update: IChart.IAxis.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIAxis: true;
+    }
+    /**
+     * {@inheritDoc IChart.IAxis}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IAxis}
+     */
+    namespace IAxis {
+        /** What {@link IChart.IAxis.update} sets; each field as its setter takes it. */
+        interface Update {
+            /** The title's properties, or its text; `null` removes it. */
+            title?: IChart.IAxisTitle.Update | string | null;
+            numberFormat?: string;
+            linkNumberFormat?: boolean;
+            visible?: boolean;
+            minimum?: number | 'auto';
+            maximum?: number | 'auto';
+            majorUnit?: number | 'auto';
+            majorGridlines?: boolean;
+            minorGridlines?: boolean;
+            multiLevel?: boolean;
+            categoryNames?: ICellRange | string;
+            minorUnit?: number | 'auto';
+            scaleType?: IChart.AxisScaleType;
+            logBase?: number;
+            displayUnit?: IChart.AxisDisplayUnit;
+            customDisplayUnit?: number;
+            showDisplayUnitLabel?: boolean;
+            crosses?: IChart.AxisCrosses;
+            crossesAt?: number;
+            reversePlotOrder?: boolean;
+            majorTickMark?: IChart.AxisTickMark;
+            minorTickMark?: IChart.AxisTickMark;
+            tickLabelPosition?: IChart.AxisTickLabelPosition;
+            textOrientation?: number | 'vertical' | 'auto';
+            style?: ITextBoxStyle.Update;
+            tickLabelSpacing?: number | null;
+            tickMarkSpacing?: number | null;
+            baseTimeUnit?: IChart.AxisTimeUnit | 'auto';
+            majorTimeUnitScale?: IChart.AxisTimeUnit;
+            minorTimeUnitScale?: IChart.AxisTimeUnit;
+            categoryType?: IChart.AxisCategoryType;
+        }
+    }
+    /**
+     * Lines across the plot area at an axis's ticks.
+     */
+    interface IGridlines extends IChart.IElement {
+        /** Returns whether the lines are drawn. */
+        getVisible(): boolean;
+        /** Draws or removes the lines. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns what the lines are drawn with; only its line applies. Setting it shows the lines.
+         */
+        getStyle(): IShapeStyle;
+        /** For runtime type checking. */
+        readonly isIGridlines: true;
+    }
+    /**
+     * A title: the chart's ({@link IChart.getTitle}), or an axis's ({@link IChart.IAxisTitle}).
+     */
+    interface ITitle extends IChart.IElement {
+        /**
+         * Returns the text the title shows, or `null` when it is not shown. A chart title that states
+         * no text of its own shows the name of a chart's only series, else `Chart Title`.
+         */
+        getText(): string | null;
+        /**
+         * Sets the title's text and shows it. A formula (`=Sheet1!$A$1`) shows a cell's text. `null`
+         * hands a chart title back to the automatic text, and removes an axis title.
+         */
+        setText(text: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the title is shown. */
+        getVisible(): boolean;
+        /** Shows or removes the title. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the title is drawn over the plot area rather than taking room above it. */
+        getOverlay(): boolean;
+        /** Sets whether the title is drawn over the plot area, and shows it. */
+        setOverlay(overlay: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns what the title is drawn with: its fill, border and font. Setting it shows the title. */
+        getStyle(): ITextBoxStyle;
+        /** Sets several properties of the title at once, as one step to undo. */
+        update(update: IChart.ITitle.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isITitle: true;
+    }
+    /**
+     * {@inheritDoc IChart.ITitle}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ITitle}
+     */
+    namespace ITitle {
+        /** What {@link IChart.ITitle.update} sets; each field as its setter takes it. */
+        interface Update {
+            text?: string | null;
+            visible?: boolean;
+            overlay?: boolean;
+            style?: ITextBoxStyle.Update;
+        }
+    }
+    /**
+     * The chart's legend.
+     */
+    interface ILegend extends IChart.IElement {
+        /** Returns whether the legend is shown. */
+        getVisible(): boolean;
+        /** Shows or removes the legend. A legend shown anew is at the right, as in Excel. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns where the legend sits. */
+        getPosition(): IChart.LegendPosition;
+        /** Moves the legend, and shows it. */
+        setPosition(position: IChart.LegendPosition, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the legend is drawn over the plot area rather than taking room beside it. */
+        getOverlay(): boolean;
+        /** Sets whether the legend is drawn over the plot area, and shows it. */
+        setOverlay(overlay: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns what the legend is drawn with: its fill, border and font. Setting it shows the legend. */
+        getStyle(): ITextBoxStyle;
+        /**
+         * Returns the legend's entries, as drawn: one per series, or per slice of a single pie; a
+         * hidden entry is listed too.
+         */
+        getLegendEntries(): readonly IChart.ILegendEntry[];
+        /** Sets several properties of the legend at once, as one step to undo. */
+        update(update: IChart.ILegend.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isILegend: true;
+    }
+    /**
+     * {@inheritDoc IChart.ILegend}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ILegend}
+     */
+    namespace ILegend {
+        /** What {@link IChart.ILegend.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            position?: IChart.LegendPosition;
+            overlay?: boolean;
+            style?: ITextBoxStyle.Update;
+        }
+    }
+    /**
+     * What each point of a line, scatter or radar series is drawn as.
+     */
+    interface IMarker extends IChart.IElement {
+        /** Returns the marker's symbol; `'none'` when the series draws none. */
+        getSymbol(): IChart.MarkerSymbol;
+        /**
+         * Sets the marker's symbol. A line series given one shows markers; given `'none'`, it shows none.
+         */
+        setSymbol(symbol: IChart.MarkerSymbol, options?: ITransaction.OperationOptions): this;
+        /** Returns the marker's size in points, 2 to 72. */
+        getSize(): number;
+        /** Sets the marker's size in points, 2 to 72. */
+        setSize(size: number, options?: ITransaction.OperationOptions): this;
+        /** Returns what the marker is drawn with: its fill, and its outline as the line. */
+        getStyle(): IShapeStyle;
+        /** Sets several properties of the marker at once, as one step to undo. */
+        update(update: IChart.IMarker.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIMarker: true;
+    }
+    /**
+     * {@inheritDoc IChart.IMarker}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IMarker}
+     */
+    namespace IMarker {
+        /** What {@link IChart.IMarker.update} sets; each field as its setter takes it. */
+        interface Update {
+            symbol?: IChart.MarkerSymbol;
+            size?: number;
+            style?: IShapeStyle.Update;
+        }
+    }
+    /**
+     * The labels of a series' points.
+     */
+    interface IDataLabels extends IChart.IElement {
+        /** Returns whether the series' points are labeled. */
+        getVisible(): boolean;
+        /**
+         * Labels the series' points with their values, as Excel's "Data Labels" does, or removes the
+         * labels.
+         */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a label shows its point's value. */
+        getShowValue(): boolean;
+        /** Sets whether a label shows its point's value; showing it shows the labels. */
+        setShowValue(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a label shows its point's category. */
+        getShowCategoryName(): boolean;
+        /** Sets whether a label shows its point's category. */
+        setShowCategoryName(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a label shows the series' name. */
+        getShowSeriesName(): boolean;
+        /** Sets whether a label shows the series' name. */
+        setShowSeriesName(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a label shows its point's share of the whole. */
+        getShowPercentage(): boolean;
+        /**
+         * Sets whether a label shows its point's share of the whole.
+         *
+         * @throws ExpectedError for a series that is not a pie or doughnut, as in Excel.
+         */
+        setShowPercentage(show: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns where the labels sit: the one set, or the type's own (outside the end of a clustered
+         * bar, the center of a stacked bar or an area, right of a line's or a scatter's point).
+         */
+        getPosition(): IChart.DataLabelPosition;
+        /** Sets where the labels sit. */
+        setPosition(position: IChart.DataLabelPosition, options?: ITransaction.OperationOptions): this;
+        /** Returns what separates the parts of a label. */
+        getSeparator(): string;
+        /** Sets what separates the parts of a label. */
+        setSeparator(separator: string, options?: ITransaction.OperationOptions): this;
+        /** Returns the labels' number format, or `null` when they take the values'. */
+        getNumberFormat(): string | null;
+        /** Sets the labels' number format; `null` for the values' own. */
+        setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the labels take the values' number format. */
+        getLinkNumberFormat(): boolean;
+        /** Sets whether the labels take the values' number format. */
+        setLinkNumberFormat(linked: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether each label shows the series' legend key. */
+        getShowLegendKey(): boolean;
+        /** Sets whether each label shows the series' legend key; showing it shows the labels. */
+        setShowLegendKey(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether a bubble's label shows its size. */
+        getShowBubbleSize(): boolean;
+        /** Sets whether a bubble's label shows its size. @throws ExpectedError on a series that is not a bubble's, as Excel refuses it. */
+        setShowBubbleSize(show: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the formula of the cells the labels show (Excel's "Value From Cells"), or `null`.
+         */
+        getValueFromCellsFormula(): string | null;
+        /**
+         * Shows each label's text from a cell: cells, a formula naming them, or `null` for none. The
+         * labels show them with whatever else they show.
+         */
+        setValueFromCells(source: ICellRange | string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns what the labels are drawn with: their fill, border and font. Setting it shows the labels. */
+        getStyle(): ITextBoxStyle;
+        /** Returns the labels' angle in degrees counterclockwise, or `'vertical'` for stacked letters. */
+        getTextOrientation(): number | 'vertical';
+        /** Turns the labels: degrees from -90 to 90 counterclockwise, or `'vertical'`. */
+        setTextOrientation(orientation: number | 'vertical', options?: ITransaction.OperationOptions): this;
+        /** Sets several properties of the labels at once, as one step to undo. */
+        update(update: IChart.IDataLabels.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIDataLabels: true;
+    }
+    /**
+     * {@inheritDoc IChart.IDataLabels}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IDataLabels}
+     */
+    namespace IDataLabels {
+        /** What {@link IChart.IDataLabels.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            showValue?: boolean;
+            showCategoryName?: boolean;
+            showSeriesName?: boolean;
+            showPercentage?: boolean;
+            position?: IChart.DataLabelPosition;
+            separator?: string;
+            numberFormat?: string | null;
+            linkNumberFormat?: boolean;
+            showLegendKey?: boolean;
+            showBubbleSize?: boolean;
+            valueFromCells?: ICellRange | string | null;
+            style?: ITextBoxStyle.Update;
+            textOrientation?: number | 'vertical';
+        }
+    }
+    /** The kind of line a trendline fits to its series, by Office Scripts' names (`ChartTrendlineType`). */
+    type TrendlineType = 'linear' | 'exponential' | 'logarithmic' | 'polynomial' | 'power' | 'movingAverage';
+    /**
+     * A line fitted to a series' points, or their moving average, with the fit's equation and R² as
+     * an optional label.
+     */
+    interface ITrendline extends IChart.IElement {
+        /** Returns the kind of line. */
+        getType(): IChart.TrendlineType;
+        /**
+         * Sets the kind of line. A polynomial starts at order 2 and a moving average at period 2; the
+         * other kind's option goes, and a set intercept stays only on a type that takes one.
+         */
+        setType(type: IChart.TrendlineType, options?: ITransaction.OperationOptions): this;
+        /** Returns a polynomial's order, 2 to 6; 2 for another type. */
+        getPolynomialOrder(): number;
+        /**
+         * Sets a polynomial's order, 2 to 6. On another type it changes nothing, as in Excel.
+         *
+         * @throws ExpectedError for an order outside 2 to 6.
+         */
+        setPolynomialOrder(order: number, options?: ITransaction.OperationOptions): this;
+        /** Returns a moving average's period, in points; 2 for another type. */
+        getMovingAveragePeriod(): number;
+        /**
+         * Sets a moving average's period: 2 to one fewer than the series' points.
+         *
+         * @throws ExpectedError for a period outside that, or on a trendline that is not a moving average.
+         */
+        setMovingAveragePeriod(period: number, options?: ITransaction.OperationOptions): this;
+        /** Returns how far the line runs past the last point, in x: in categories on a category axis. */
+        getForwardPeriod(): number;
+        /**
+         * Sets how far the line runs past the last point; 0 for not at all. On a category axis a run adds
+         * unlabeled categories.
+         *
+         * @throws ExpectedError for a negative run.
+         */
+        setForwardPeriod(period: number, options?: ITransaction.OperationOptions): this;
+        /** Returns how far the line runs before the first point. */
+        getBackwardPeriod(): number;
+        /**
+         * Sets how far the line runs before the first point.
+         *
+         * @throws ExpectedError for a negative run, and on a category axis for one past half a category,
+         * as in Excel.
+         */
+        setBackwardPeriod(period: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the y the line is drawn through at x = 0: the one set, else a linear, exponential or
+         * polynomial fit's (`null` for the other types, which have none, or where the points allow no
+         * fit).
+         */
+        getIntercept(): number | null;
+        /** Returns whether the intercept is the fit's own rather than set. */
+        isInterceptAuto(): boolean;
+        /**
+         * Holds the fit to `intercept` at x = 0, or `'auto'` to let it go. Excel keeps an intercept on
+         * a linear, exponential or polynomial fit and a moving average; on a logarithmic or power fit
+         * it changes nothing, as in Excel.
+         */
+        setIntercept(intercept: number | 'auto', options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows the fit's equation. */
+        getShowEquation(): boolean;
+        /** Sets whether the label shows the fit's equation; showing either part shows the label. */
+        setShowEquation(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the label shows the fit's R². */
+        getShowRSquared(): boolean;
+        /** Sets whether the label shows the fit's R². */
+        setShowRSquared(show: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the trendline's entry in the legend: the one set, else Excel's, `Linear (Sales)`. */
+        getName(): string;
+        /** Returns whether the name is Excel's own rather than set. */
+        isNameAuto(): boolean;
+        /** Sets the trendline's entry in the legend; `null` for Excel's own. */
+        setName(name: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns the label of the fit's equation and R². */
+        getLabel(): IChart.ITrendlineLabel;
+        /**
+         * Returns what the line is drawn with (Office Scripts' `getFormat().getLine()`): reads resolve to
+         * Excel's dotted 1.5 pt line in the series' color where it states none.
+         */
+        getStyle(): IShapeStyle;
+        /**
+         * Returns the fit: the numbers the label shows, unrounded. `null` for a moving average, or where
+         * the points allow no fit.
+         */
+        getFit(): IChart.TrendlineFit | null;
+        /** Removes the trendline from its series. */
+        delete(options?: ITransaction.OperationOptions): void;
+        /** Sets several properties of the trendline at once, as one step to undo. */
+        update(update: IChart.ITrendline.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isITrendline: true;
+    }
+    /**
+     * {@inheritDoc IChart.ITrendline}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ITrendline}
+     */
+    namespace ITrendline {
+        /**
+         * What {@link IChart.ITrendline.update} sets; each field as its setter takes it. The type is set
+         * before the options that depend on it.
+         */
+        interface Update {
+            type?: IChart.TrendlineType;
+            polynomialOrder?: number;
+            movingAveragePeriod?: number;
+            forwardPeriod?: number;
+            backwardPeriod?: number;
+            intercept?: number | 'auto';
+            showEquation?: boolean;
+            showRSquared?: boolean;
+            name?: string | null;
+            style?: IShapeStyle.Update;
+            label?: IChart.ITrendlineLabel.Update;
+        }
+    }
+    /** A fitted trendline's numbers. */
+    interface TrendlineFit {
+        type: Exclude<IChart.TrendlineType, 'movingAverage'>;
+        /**
+         * - `linear` and `polynomial`: the coefficients from x⁰ up, `[c0, c1, …]`;
+         * - `exponential`: `[a, b]` of y = a·e^(b·x);
+         * - `logarithmic`: `[a, b]` of y = a·ln(x) + b;
+         * - `power`: `[a, b]` of y = a·x^b.
+         *
+         * x is the series' x on a scatter, else the category's number from 1.
+         */
+        coefficients: number[];
+        /** Excel's R²: the square of the correlation between the series' y and the fit's. */
+        rSquared: number;
+    }
+    /** The label of a trendline's equation and R². */
+    interface ITrendlineLabel extends IChart.IElement {
+        /** Returns the label's text as drawn, its lines parted by `\n`; `null` when it shows nothing. */
+        getText(): string | null;
+        /** Returns the format of the label's numbers: `General` unless set. */
+        getNumberFormat(): string;
+        /** Sets the format of the label's numbers; `null` for `General`. */
+        setNumberFormat(formatCode: string | null, options?: ITransaction.OperationOptions): this;
+        /** Sets several properties of the label at once, as one step to undo. */
+        update(update: IChart.ITrendlineLabel.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isITrendlineLabel: true;
+    }
+    /**
+     * {@inheritDoc IChart.ITrendlineLabel}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ITrendlineLabel}
+     */
+    namespace ITrendlineLabel {
+        /** What {@link IChart.ITrendlineLabel.update} sets. */
+        interface Update {
+            numberFormat?: string | null;
+        }
+    }
+    /**
+     * How far error bars reach, by Office Scripts' names (`ChartErrorBarsType`): a fixed value, a
+     * percentage of each value, standard deviations of the series' values (the bars then about their
+     * mean), their standard error, or each point's own amounts.
+     */
+    type ErrorBarsType = 'fixedValue' | 'percent' | 'stDev' | 'stError' | 'custom';
+    /** Which way from each point error bars run (`ChartErrorBarsInclude`). */
+    type ErrorBarsInclude = 'both' | 'minusValues' | 'plusValues';
+    /** A series' error bars, of its values or of a scatter's x values. */
+    interface IErrorBars extends IChart.IElement {
+        /** Returns whether the bars are drawn. */
+        getVisible(): boolean;
+        /**
+         * Shows the bars, as Excel's `HasErrorBars` adds them (a fixed 5 both ways, capped), or removes
+         * them.
+         */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns how far the bars reach; `fixedValue` where there are none. */
+        getType(): IChart.ErrorBarsType;
+        /**
+         * Sets how far the bars reach, showing them. A new type takes Excel's amount for it: 5 for a
+         * fixed value and a percentage, 1 for standard deviations. For `custom`, see
+         * {@link IChart.IErrorBars.setCustomValues}.
+         */
+        setType(type: IChart.ErrorBarsType, options?: ITransaction.OperationOptions): this;
+        /** Returns the amount of a fixed value, a percentage or standard deviations; `null` for the other types. */
+        getAmount(): number | null;
+        /**
+         * Sets the amount, showing the bars.
+         *
+         * @throws ExpectedError for a negative amount, or for bars of standard error or custom values.
+         */
+        setAmount(amount: number, options?: ITransaction.OperationOptions): this;
+        /** Returns which way from each point the bars run. */
+        getInclude(): IChart.ErrorBarsInclude;
+        /** Sets which way from each point the bars run, showing them. */
+        setInclude(include: IChart.ErrorBarsInclude, options?: ITransaction.OperationOptions): this;
+        /** Returns whether the bars' ends are capped. */
+        getEndStyleCap(): boolean;
+        /** Sets whether the bars' ends are capped, showing them. */
+        setEndStyleCap(cap: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the formula of custom bars' amounts above each point, an array constant such as
+         * `{1,2,3}` where they are written into the chart; `null` for other bars.
+         */
+        getPlusValuesFormula(): string | null;
+        /** Returns the formula of custom bars' amounts below each point, as {@link IChart.IErrorBars.getPlusValuesFormula}. */
+        getMinusValuesFormula(): string | null;
+        /**
+         * Makes the bars custom: each point's amount above from `plus` and below from `minus`, each
+         * cells, a formula or an array constant (`{1,2,3}`), as VBA's `ErrorBar` takes them.
+         */
+        setCustomValues(plus: ICellRange | string, minus: ICellRange | string, options?: ITransaction.OperationOptions): this;
+        /** Returns what the bars are drawn with (Office Scripts' `getFormat().getLine()`). */
+        getStyle(): IShapeStyle;
+        /** Sets several properties of the bars at once, as one step to undo; the type before the amount. */
+        update(update: IChart.IErrorBars.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIErrorBars: true;
+    }
+    /**
+     * {@inheritDoc IChart.IErrorBars}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IErrorBars}
+     */
+    namespace IErrorBars {
+        /** What {@link IChart.IErrorBars.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            type?: IChart.ErrorBarsType;
+            amount?: number;
+            include?: IChart.ErrorBarsInclude;
+            endStyleCap?: boolean;
+            customValues?: {
+                plus: ICellRange | string;
+                minus: ICellRange | string;
+            };
+            style?: IShapeStyle.Update;
+        }
+    }
+    /**
+     * A line or stock chart's up/down bars: in each category a bar from the first series' value to the
+     * last's, an up bar where the last is higher and a down bar where it is not (VBA's
+     * `ChartGroup.UpBars` and `DownBars`). The series of the group share them.
+     */
+    interface IUpDownBars extends IChart.IElement {
+        /** Returns whether the bars are drawn. */
+        getVisible(): boolean;
+        /** Shows the bars as Excel adds them, or removes them. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns the gap between the bars, as a percentage of a bar's width; Excel's 150 where there are none. */
+        getGapWidth(): number;
+        /** Sets the gap between the bars, 0 to 500, showing them. */
+        setGapWidth(gapWidth: number, options?: ITransaction.OperationOptions): this;
+        /** Returns what the up bars are drawn with: fill and line. Setting it shows the bars. */
+        getUpBarsStyle(): IShapeStyle;
+        /** Returns what the down bars are drawn with: fill and line. Setting it shows the bars. */
+        getDownBarsStyle(): IShapeStyle;
+        /** Sets several properties of the bars at once, as one step to undo. */
+        update(update: IChart.IUpDownBars.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isIUpDownBars: true;
+    }
+    /**
+     * {@inheritDoc IChart.IUpDownBars}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.IUpDownBars}
+     */
+    namespace IUpDownBars {
+        /** What {@link IChart.IUpDownBars.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            gapWidth?: number;
+            upBars?: IShapeStyle.Update;
+            downBars?: IShapeStyle.Update;
+        }
+    }
+    /**
+     * A chart group's high-low lines (from each category's lowest value to its highest), drop lines
+     * (from each category's values to the category axis) or series lines (joining each stacked
+     * series' ends from one category to the next). The series of the group share them.
+     */
+    interface ILines extends IChart.IElement {
+        /** Returns whether the lines are drawn. */
+        getVisible(): boolean;
+        /** Shows the lines as Excel adds them, or removes them. */
+        setVisible(visible: boolean, options?: ITransaction.OperationOptions): this;
+        /** Returns what the lines are drawn with; only its line applies. Setting it shows the lines. */
+        getStyle(): IShapeStyle;
+        /** Sets several properties of the lines at once, as one step to undo. */
+        update(update: IChart.ILines.Update, options?: ITransaction.OperationOptions): this;
+        /** For runtime type checking. */
+        readonly isILines: true;
+    }
+    /**
+     * {@inheritDoc IChart.ILines}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IChart.ILines}
+     */
+    namespace ILines {
+        /** What {@link IChart.ILines.update} sets; each field as its setter takes it. */
+        interface Update {
+            visible?: boolean;
+            style?: IShapeStyle.Update;
+        }
+    }
+    /** What {@link IChart.update} sets; each field as its part's setter takes it. */
+    interface Update {
+        /** The title's properties, or its text. */
+        title?: IChart.ITitle.Update | string | null;
+        legend?: IChart.ILegend.Update;
+        displayBlanksAs?: IChart.DisplayBlanksAs;
+        /** The primary value axis's properties. */
+        valueAxis?: IChart.IAxis.Update;
+        /** The primary category axis's properties. */
+        categoryAxis?: IChart.IAxis.Update;
+        /** Set first: the type every series is drawn as. */
+        chartType?: IChart.Type | string;
+        plotVisibleOnly?: boolean;
+        roundedCorners?: boolean;
+        /** The chart area's fill and border, and the chart's font: every text's. */
+        style?: ITextBoxStyle.Update;
+        plotArea?: IChart.IPlotArea.Update;
+        dataTable?: IChart.IDataTable.Update;
+        /** Every series' data labels. */
+        dataLabels?: IChart.IDataLabels.Update;
     }
     interface JSON {
-        /** Opaque source XML fragment, captured verbatim from the source file and replayed as-is on
-         * save, for whatever this chart doesn't (yet) model structurally. */
-        xml?: string;
-        /** Original `cNvPr` id from the captured source fragment, if any; used to avoid id collisions
-         * with freshly-generated ids on write. */
+        /**
+         * The id the chart's frame had in the file it was read from. A writer keeps it where it is
+         * free in the drawing, so references to the frame by id still find it.
+         */
         sourceId?: number;
         /**
          * The chart's own document part, and the parts that part references.
          *
          * @remarks
-         * The chart is carried as the markup it was read from until it is modeled; this is that markup
-         * and everything it needs to stay valid — its style and color definitions, the shapes drawn
-         * over it, an embedded workbook holding its data. {@link IChart.getXML} is the readable view
-         * of the chart's own markup; the rest is for writing the chart back out.
+         * The parts the chart needs to be written back: its style and color definitions, the shapes
+         * drawn over it, an embedded workbook holding its data. The part's own markup is kept only while
+         * the chart still states what it was read from, so an untouched chart is written back as it was.
          */
         part?: IEmbeddedPart.JSON;
+        /**
+         * The chart: every chart type, its data, axes, text and formatting.
+         */
+        model?: ChartModel.ChartSpace;
     }
     interface Events extends IMovable.ContentEvents {
+        /**
+         * Called when what {@link IChart.getLayout} returns may have changed: the chart changed, a
+         * cell it plots changed (its value, or whether its row or column is hidden), its movable was
+         * resized, its theme changed, or a font it is measured with arrived. Call `getLayout` again
+         * to see the new layout.
+         *
+         * @remarks
+         * Cell changes are announced once per commit, after every cell of it has landed, so a
+         * `getLayout` from the listener reads the new values; a recalculation that changes plotted
+         * cells announces again when its results land.
+         */
+        onLayoutChange?(source: IChart): void;
     }
     interface IListeners extends IListener.Callbacks<IChart, IChart.Events> {
     }