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

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

@@ -0,0 +1,681 @@
+import { IFill } from '../../fill/IFill';
+import { IStroke } from '../../fill/IStroke';
+import { IEffect } from '../../fill/IEffect';
+import { IText } from '../../text/IText';
+/**
+ * A chart as plain JSON: a chart space holding one plot area of chart groups, each a list of series.
+ *
+ * @remarks
+ * The shape is DrawingML's `c:chartSpace` wherever DrawingML has a shape for the thing, and every
+ * chart type is stated in it: the classic types, the 2016 types (waterfall, histogram, box and
+ * whisker, treemap, sunburst, funnel, region map) as group types of their own, and types Excel has
+ * none of. A series is what is drawn: its group says how, its sources are the data it plots (one
+ * per channel: categories, values, x, y, sizes, colors), and its options say how its values are
+ * turned into what is drawn. A point states what is particular to it, and a line derived from a
+ * series is that series' child.
+ *
+ * Every field is what the chart states, and nothing else. An absent field is a real value: it means
+ * the application's default applies, and a writer leaves it out. Names are DrawingML's own
+ * (`gapWidth`, `dLbls`, `crossBetween`), except the collections, which are named for what they hold
+ * (`groups`, `axes`, `series`, `points`).
+ *
+ * Values keep DrawingML's units unless a field says otherwise: percentages as whole numbers
+ * (`gapWidth: 150`), angles in degrees, sizes of lines in points, and the `x`, `y`, `w`, `h` of a
+ * manual layout as fractions of the chart.
+ *
+ * Anything a reader does not model is kept, as the markup it was, in the {@link ChartModel.Unknown}
+ * bag of the element that held it. Such markup is in the vocabulary of the file it was read from,
+ * and is written back only to a part of that vocabulary.
+ */
+export declare namespace ChartModel {
+    /**
+     * What an element holds that the model does not.
+     *
+     * @remarks
+     * `elements` are child elements, each as the markup the file had and placed by the modeled child
+     * it followed: `after` is that child's DrawingML name (`''` before the first one), and `at`, for a
+     * child that repeats (`ser`, `dPt`), how many of them came before. Writing them back at those
+     * places puts them where the schema wants them, whatever was edited around them.
+     *
+     * A fragment's namespace prefixes are the ones in force in the file: those declared on the
+     * fragment itself, or on the chart space ({@link ChartSpace.unknown}'s `attributes`).
+     */
+    interface Unknown {
+        elements?: UnknownElement[];
+        /** Attributes, by the name the file spells them with. */
+        attributes?: Record<string, string>;
+    }
+    interface UnknownElement {
+        after: string;
+        at?: number;
+        xml: string;
+    }
+    /** Any element of the model. */
+    interface Element {
+        unknown?: Unknown;
+    }
+    /** `c:chartSpace`, the root of a chart part. */
+    interface ChartSpace extends Element {
+        date1904?: boolean;
+        lang?: string;
+        roundedCorners?: boolean;
+        /** The legacy chart style, 1-48: `c:style`. Excel states its own style in an `mc:AlternateContent` the model does not read. */
+        style?: number;
+        pivotSource?: PivotSource;
+        chart: Chart;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+    }
+    interface PivotSource extends Element {
+        name: string;
+        fmtId?: number;
+    }
+    /** `c:chart`. */
+    interface Chart extends Element {
+        title?: Title;
+        autoTitleDeleted?: boolean;
+        view3D?: View3D;
+        floor?: Surface;
+        sideWall?: Surface;
+        backWall?: Surface;
+        plotArea: PlotArea;
+        legend?: Legend;
+        plotVisOnly?: boolean;
+        dispBlanksAs?: 'gap' | 'span' | 'zero';
+        showDLblsOverMax?: boolean;
+    }
+    /** `c:plotArea`: one or more chart groups, and the axes they draw against. */
+    interface PlotArea extends Element {
+        layout?: Layout;
+        /** In the order the file lists them. */
+        groups: Group[];
+        /** In the order the file lists them. */
+        axes: Axis[];
+        dTable?: DataTable;
+        spPr?: ShapeProperties;
+        /** The area inside the axes, where a 2016 chart states it (`cx:plotSurface`). */
+        plotSurface?: Surface;
+    }
+    /**
+     * A classic chart type: the DrawingML element is this name plus `Chart`, or `3DChart` when
+     * {@link Group.is3D} is set.
+     */
+    type ClassicGroupType = 'area' | 'bar' | 'line' | 'pie' | 'doughnut' | 'ofPie' | 'scatter' | 'bubble' | 'radar' | 'stock' | 'surface';
+    /**
+     * A 2016 chart type. A histogram's series bin their values, or sum them by category when
+     * {@link LayoutProperties.aggregation} says so (a pareto chart, with a {@link Series.cumulativeLine}).
+     */
+    type ChartExGroupType = 'waterfall' | 'histogram' | 'boxWhisker' | 'treemap' | 'sunburst' | 'funnel' | 'regionMap';
+    /**
+     * A group of a kind the host registered (`ChartKinds`), laid out and painted by that kind. Its
+     * series keep the standard channels (categories, values), so data, formulas and caches work as
+     * for any group. Not an Excel type: see {@link CustomGroup} for what reaches a file.
+     */
+    type CustomGroupType = 'custom';
+    /** The kind of a chart group. */
+    type GroupType = ClassicGroupType | ChartExGroupType | CustomGroupType;
+    /** What a custom group states: its kind, as registered, and the kind's own options. */
+    interface CustomGroup {
+        /** The kind's name, registered as `custom:<kind>`. */
+        kind: string;
+        /** Whatever the kind stores for the group; JSON. */
+        options?: Record<string, unknown>;
+    }
+    /**
+     * A chart group (`c:barChart`, `c:lineChart`…): series of one type that share one pair of axes and
+     * the options of the group.
+     *
+     * @remarks
+     * Which options a group may state depends on its type; the reader keeps whatever the file states.
+     * A group of a 2016 type states no options: its series' {@link Series.layoutPr} hold them.
+     */
+    interface Group extends Element {
+        type: GroupType;
+        /** A custom group's kind and options; only on a `custom` group. */
+        custom?: CustomGroup;
+        /** `bar3DChart`, `line3DChart`, `area3DChart`, `pie3DChart`, `surface3DChart`. */
+        is3D?: boolean;
+        barDir?: 'bar' | 'col';
+        grouping?: 'clustered' | 'stacked' | 'percentStacked' | 'standard';
+        ofPieType?: 'pie' | 'bar';
+        scatterStyle?: 'none' | 'line' | 'lineMarker' | 'marker' | 'smooth' | 'smoothMarker';
+        radarStyle?: 'standard' | 'marker' | 'filled';
+        wireframe?: boolean;
+        varyColors?: boolean;
+        series: Series[];
+        dLbls?: DataLabels;
+        dropLines?: ChartLines;
+        hiLowLines?: ChartLines;
+        upDownBars?: UpDownBars;
+        /** `lineChart`: whether the group's series show markers. */
+        marker?: boolean;
+        smooth?: boolean;
+        gapWidth?: number;
+        overlap?: number;
+        gapDepth?: number;
+        shape?: BarShape;
+        firstSliceAng?: number;
+        holeSize?: number;
+        splitType?: 'auto' | 'cust' | 'percent' | 'pos' | 'val';
+        splitPos?: number;
+        /** `custSplit`: the indexes of the points drawn in the second pie. */
+        custSplit?: number[];
+        secondPieSize?: number;
+        serLines?: ChartLines[];
+        bubble3D?: boolean;
+        bubbleScale?: number;
+        showNegBubbles?: boolean;
+        sizeRepresents?: 'area' | 'w';
+        /** A surface's formats of its value bands, by band (`c:bandFmts`). */
+        bandFmts?: BandFormat[];
+        /**
+         * The `axId`s of the axes the group draws against: two, or three for a series axis. None for a
+         * pie, and none where a 2016 chart's series name none.
+         */
+        axIds: number[];
+    }
+    type BarShape = 'cone' | 'coneToMax' | 'box' | 'cylinder' | 'pyramid' | 'pyramidToMax';
+    /** How a surface draws one band of values, from one major tick of its value axis to the next. */
+    interface BandFormat {
+        idx: number;
+        spPr?: ShapeProperties;
+    }
+    /** `c:ser`. The fields a series may state depend on its group's type. */
+    interface Series extends Element {
+        /**
+         * Picks the series' automatic color and marker. Numbered across the whole chart; a classic
+         * chart's series always state it.
+         */
+        idx?: number;
+        /**
+         * The order the series is plotted, listed and stacked in. Numbered across the whole chart; a
+         * classic chart's series always state it, and a 2016 chart's are in the order listed.
+         */
+        order?: number;
+        /** A series of a 2016 chart that is not drawn. */
+        hidden?: boolean;
+        /** What identifies the series to the application that wrote it. */
+        uniqueId?: string;
+        tx?: SeriesText;
+        spPr?: ShapeProperties;
+        invertIfNegative?: boolean;
+        marker?: Marker;
+        explosion?: number;
+        points?: DataPoint[];
+        dLbls?: DataLabels;
+        /** Lines fitted to the series' points, or their moving average. */
+        trendlines?: Trendline[];
+        /** How uncertain the series' values are, as a bar about each point: one, or a scatter's x and y. */
+        errBars?: ErrorBars[];
+        /** Categories: the labels of the points, in as many levels as the range has. */
+        cat?: DataSource;
+        val?: DataSource;
+        xVal?: DataSource;
+        yVal?: DataSource;
+        /** Sizes: a bubble's, or a treemap's or sunburst's tile. */
+        bubbleSize?: DataSource;
+        /** What a region map colors each region by: values (`numRef`) or text (`strRef`). */
+        color?: DataSource;
+        /** The ids that name a region map's regions. */
+        entityId?: DataSource;
+        shape?: BarShape;
+        smooth?: boolean;
+        bubble3D?: boolean;
+        /** How a 2016 chart's series turns its values into what is drawn: binning, totals, statistics… */
+        layoutPr?: LayoutProperties;
+        /**
+         * A line of the series' running total, as a percentage of its sum, over its points in the order
+         * drawn, against axes of its own (`axIds`): the line of a pareto chart.
+         */
+        cumulativeLine?: DerivedLine;
+        extLst?: ExtensionList;
+    }
+    /** A line drawn from its series' values rather than from data of its own. */
+    interface DerivedLine extends Element {
+        idx?: number;
+        hidden?: boolean;
+        uniqueId?: string;
+        tx?: SeriesText;
+        spPr?: ShapeProperties;
+        points?: DataPoint[];
+        dLbls?: DataLabels;
+        layoutPr?: LayoutProperties;
+        /** The axes the line draws against, when not its series'. */
+        axIds?: number[];
+    }
+    /**
+     * `cx:layoutPr`: a 2016 series' options. Which apply depends on its group's type: binning or
+     * aggregation to a histogram, statistics and the visibility flags to a box and whisker, the
+     * connector lines to a waterfall, the parent label layout to a treemap. A region map's map data
+     * (`cx:geography`, cached from the service that drew it) is kept as markup.
+     */
+    interface LayoutProperties extends Element {
+        parentLabelLayout?: 'none' | 'banner' | 'overlapping';
+        regionLabelLayout?: 'none' | 'bestFitOnly' | 'showAll';
+        visibility?: SeriesElementVisibility;
+        /** The series sums its values by category instead of binning them. Present when stated. */
+        aggregation?: Element;
+        binning?: Binning;
+        statistics?: Statistics;
+    }
+    /** Which parts of a box and whisker or a waterfall are drawn. */
+    interface SeriesElementVisibility extends Element {
+        connectorLines?: boolean;
+        meanLine?: boolean;
+        meanMarker?: boolean;
+        nonoutliers?: boolean;
+        outliers?: boolean;
+    }
+    /** How a histogram bins its values. A bound or size not stated is automatic. */
+    interface Binning extends Element {
+        intervalClosed?: 'l' | 'r';
+        /** The value at or below which values fall in one bin; `'auto'` as stated. */
+        underflow?: number | 'auto';
+        overflow?: number | 'auto';
+        binSize?: number;
+        binCount?: number;
+    }
+    interface Statistics extends Element {
+        quartileMethod?: 'inclusive' | 'exclusive';
+    }
+    /** `c:extLst`: what later versions add to an element, one extension each. */
+    interface ExtensionList extends Element {
+        extensions?: Extension[];
+    }
+    /** `c:ext`. What the model does not read of an extension is kept in its {@link Element.unknown}. */
+    interface Extension extends Element {
+        uri?: string;
+        /** `c15:datalabelsRange`: the cells a series' data labels show (Excel's "Value From Cells"). */
+        datalabelsRange?: DataReference;
+        /** `c15:showDataLabelsRange`, on a series' labels: whether they show those cells. */
+        showDataLabelsRange?: boolean;
+    }
+    /**
+     * A series name: a reference to a cell, or text written into the chart (`c:v`). A 2016 chart
+     * states the text the reference last read in `v`, and may state rich text.
+     */
+    interface SeriesText extends Element {
+        strRef?: DataReference;
+        v?: string;
+        rich?: TextBody;
+    }
+    /**
+     * Where a series dimension's values come from: one of a reference (with the values it last read)
+     * or values written into the chart.
+     */
+    interface DataSource extends Element {
+        numRef?: DataReference;
+        strRef?: DataReference;
+        multiLvlStrRef?: DataReference;
+        numLit?: DataCache;
+        strLit?: DataCache;
+        /** The formula of the dimension's name, where a 2016 chart states it: the cell above the values. */
+        nf?: DataReference;
+    }
+    /** `c:numRef`, `c:strRef`, `c:multiLvlStrRef`: a formula, and the values it read when the file was saved. */
+    interface DataReference extends Element {
+        f: string;
+        /** Whether a 2016 chart reads the range by column (the default) or by row. */
+        dir?: 'col' | 'row';
+        cache?: DataCache;
+    }
+    /** `c:numCache`/`c:numLit`, `c:strCache`/`c:strLit`, `c:multiLvlStrCache`. */
+    interface DataCache extends Element {
+        formatCode?: string;
+        ptCount?: number;
+        /** By `idx`: a point the cache leaves out is blank. */
+        points?: CachePoint[];
+        /** `multiLvlStrCache`: one list of labels per level, the innermost first. */
+        levels?: CacheLevel[];
+    }
+    interface CachePoint extends Element {
+        idx: number;
+        /** The value as the file spells it. */
+        v: string;
+        formatCode?: string;
+    }
+    /** One level of a cache. A 2016 chart's levels state their own count, format and name. */
+    interface CacheLevel extends Element {
+        ptCount?: number;
+        formatCode?: string;
+        name?: string;
+        points: CachePoint[];
+    }
+    /** `c:dPt`: what one point states for itself. */
+    interface DataPoint extends Element {
+        idx: number;
+        invertIfNegative?: boolean;
+        marker?: Marker;
+        bubble3D?: boolean;
+        explosion?: number;
+        spPr?: ShapeProperties;
+        /** A waterfall's point that is a total of the points before it rather than a step. */
+        subtotal?: boolean;
+    }
+    interface Marker extends Element {
+        symbol?: 'circle' | 'dash' | 'diamond' | 'dot' | 'none' | 'picture' | 'plus' | 'square' | 'star' | 'triangle' | 'x' | 'auto';
+        size?: number;
+        spPr?: ShapeProperties;
+    }
+    /** `c:dLbls`: the labels of a group or series, with the ones that differ listed in `labels`. */
+    interface DataLabels extends DataLabelOptions {
+        labels?: DataLabel[];
+        delete?: boolean;
+        showLeaderLines?: boolean;
+        leaderLines?: ChartLines;
+        extLst?: ExtensionList;
+    }
+    /** `c:dLbl`: the label of one point. */
+    interface DataLabel extends DataLabelOptions {
+        idx: number;
+        delete?: boolean;
+        layout?: Layout;
+        tx?: Text;
+        extLst?: ExtensionList;
+    }
+    interface DataLabelOptions extends Element {
+        numFmt?: NumberFormat;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+        dLblPos?: 'bestFit' | 'b' | 'ctr' | 'inBase' | 'inEnd' | 'l' | 'outEnd' | 'r' | 't';
+        showLegendKey?: boolean;
+        showVal?: boolean;
+        showCatName?: boolean;
+        showSerName?: boolean;
+        showPercent?: boolean;
+        showBubbleSize?: boolean;
+        separator?: string;
+    }
+    /**
+     * `c:trendline`: a line fitted to its series' points, or their moving average, with the fit's
+     * equation and R² as a label.
+     */
+    interface Trendline extends Element {
+        /** Its entry in the legend; when absent, the type and the series' name: `Linear (Sales)`. */
+        name?: string;
+        spPr?: ShapeProperties;
+        trendlineType: 'exp' | 'linear' | 'log' | 'movingAvg' | 'poly' | 'power';
+        /** A polynomial's order, 2 to 6. */
+        order?: number;
+        /** A moving average's period, in points. */
+        period?: number;
+        /** How far the line runs past the last point, in x: in categories on a category axis. */
+        forward?: number;
+        /** How far the line runs before the first point. */
+        backward?: number;
+        /** The y the fit is held to at x = 0: a linear, exponential or polynomial fit. */
+        intercept?: number;
+        dispRSqr?: boolean;
+        dispEq?: boolean;
+        trendlineLbl?: TrendlineLabel;
+    }
+    /** `c:trendlineLbl`: the label of a trendline's equation and R². */
+    interface TrendlineLabel extends Element {
+        layout?: Layout;
+        tx?: Text;
+        numFmt?: NumberFormat;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+    }
+    /**
+     * `c:errBars`: a bar about each point of its series, as far as an amount of error. The amount is
+     * a fixed value, a percentage of the point's value, standard deviations of the series' values
+     * (the bars then about their mean), their standard error, or each point's own from `plus` and
+     * `minus`.
+     */
+    interface ErrorBars extends Element {
+        /**
+         * Which of the point's values the bar is of: `y`, or a scatter's or bubble's `x`. A bar series
+         * states none: its bars run along its values.
+         */
+        errDir?: 'x' | 'y';
+        /** Which side of the point the bar runs to. */
+        errBarType: 'both' | 'minus' | 'plus';
+        errValType: 'cust' | 'fixedVal' | 'percentage' | 'stdDev' | 'stdErr';
+        /** The bar's ends are drawn with no cap. */
+        noEndCap?: boolean;
+        /** Each point's amount above, for `cust`. */
+        plus?: DataSource;
+        /** Each point's amount below, for `cust`. */
+        minus?: DataSource;
+        /** The amount: a value, a percentage, or a number of standard deviations. */
+        val?: number;
+        spPr?: ShapeProperties;
+        extLst?: ExtensionList;
+    }
+    interface NumberFormat extends Element {
+        formatCode: string;
+        sourceLinked?: boolean;
+    }
+    /** `c:serLines`, `c:dropLines`, `c:hiLowLines`, `c:leaderLines`, gridlines. */
+    interface ChartLines extends Element {
+        spPr?: ShapeProperties;
+    }
+    interface UpDownBars extends Element {
+        gapWidth?: number;
+        upBars?: ChartLines;
+        downBars?: ChartLines;
+    }
+    /** Which side of the chart an element sits on, and where along it. */
+    type SidePosition = 'l' | 't' | 'r' | 'b';
+    type PositionAlign = 'min' | 'ctr' | 'max';
+    /** `c:title`. A title with no `tx` shows text the application makes up for it. */
+    interface Title extends Element {
+        tx?: Text;
+        layout?: Layout;
+        overlay?: boolean;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+        /** The side a 2016 chart's title is on. */
+        pos?: SidePosition;
+        align?: PositionAlign;
+    }
+    /**
+     * `c:tx` of a title or label: rich text, or a reference to a cell. A 2016 chart may state plain
+     * text, or the text the reference last read, in `v`.
+     */
+    interface Text extends Element {
+        strRef?: DataReference;
+        rich?: TextBody;
+        v?: string;
+    }
+    /** `c:layout`. An empty layout is automatic. */
+    interface Layout extends Element {
+        manualLayout?: ManualLayout;
+    }
+    /**
+     * `c:manualLayout`: where an element is, as fractions of the chart. In `edge` mode `x`/`y` are its
+     * position; in `factor` mode (the default) they move it from where automatic layout puts it.
+     */
+    interface ManualLayout extends Element {
+        layoutTarget?: 'inner' | 'outer';
+        xMode?: 'edge' | 'factor';
+        yMode?: 'edge' | 'factor';
+        wMode?: 'edge' | 'factor';
+        hMode?: 'edge' | 'factor';
+        x?: number;
+        y?: number;
+        w?: number;
+        h?: number;
+    }
+    interface Legend extends Element {
+        legendPos?: 'b' | 'tr' | 'l' | 'r' | 't';
+        /** Where along its side a 2016 chart's legend sits. */
+        align?: PositionAlign;
+        entries?: LegendEntry[];
+        layout?: Layout;
+        overlay?: boolean;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+    }
+    interface LegendEntry extends Element {
+        idx: number;
+        delete?: boolean;
+        txPr?: TextBody;
+    }
+    interface View3D extends Element {
+        rotX?: number;
+        hPercent?: number;
+        rotY?: number;
+        depthPercent?: number;
+        rAngAx?: boolean;
+        perspective?: number;
+    }
+    /** `c:floor`, `c:sideWall`, `c:backWall`. */
+    interface Surface extends Element {
+        thickness?: number;
+        spPr?: ShapeProperties;
+    }
+    /** `c:dTable`: a table of the chart's values under the plot area. */
+    interface DataTable extends Element {
+        showHorzBorder?: boolean;
+        showVertBorder?: boolean;
+        showOutline?: boolean;
+        showKeys?: boolean;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+    }
+    type AxisType = 'cat' | 'val' | 'date' | 'ser';
+    /**
+     * `c:catAx`, `c:valAx`, `c:dateAx`, `c:serAx`, and a 2016 chart's `cx:axis`, which states no
+     * position and no crossing axis.
+     */
+    interface Axis extends Element {
+        type: AxisType;
+        axId: number;
+        scaling: Scaling;
+        delete?: boolean;
+        axPos?: 'b' | 'l' | 'r' | 't';
+        majorGridlines?: ChartLines;
+        minorGridlines?: ChartLines;
+        title?: Title;
+        numFmt?: NumberFormat;
+        majorTickMark?: TickMark;
+        minorTickMark?: TickMark;
+        tickLblPos?: 'high' | 'low' | 'nextTo' | 'none';
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+        /** The `axId` of the axis this one crosses. */
+        crossAx?: number;
+        crosses?: 'autoZero' | 'max' | 'min';
+        crossesAt?: number;
+        /** `catAx`, `dateAx`: read dates as dates. */
+        auto?: boolean;
+        lblAlgn?: 'ctr' | 'l' | 'r';
+        lblOffset?: number;
+        tickLblSkip?: number;
+        tickMarkSkip?: number;
+        noMultiLvlLbl?: boolean;
+        /** `valAx`: whether the crossing axis is drawn between categories or through them. */
+        crossBetween?: 'between' | 'midCat';
+        majorUnit?: number;
+        minorUnit?: number;
+        dispUnits?: DisplayUnits;
+        baseTimeUnit?: TimeUnit;
+        majorTimeUnit?: TimeUnit;
+        minorTimeUnit?: TimeUnit;
+    }
+    type TickMark = 'cross' | 'in' | 'none' | 'out';
+    type TimeUnit = 'days' | 'months' | 'years';
+    interface Scaling extends Element {
+        logBase?: number;
+        orientation?: 'maxMin' | 'minMax';
+        max?: number;
+        min?: number;
+        /** A 2016 chart's gap between categories, as a fraction of a category's width (`0.5`). */
+        gapWidth?: number;
+    }
+    interface DisplayUnits extends Element {
+        custUnit?: number;
+        /** `hundreds`, `thousands`… or, on a 2016 chart, `percentage`. */
+        builtInUnit?: string;
+        dispUnitsLbl?: DisplayUnitsLabel;
+    }
+    interface DisplayUnitsLabel extends Element {
+        layout?: Layout;
+        tx?: Text;
+        spPr?: ShapeProperties;
+        txPr?: TextBody;
+    }
+    /**
+     * `c:spPr`: the fill, line and effects of an element, as the shape model states them.
+     *
+     * @remarks
+     * A fill or line the shape model cannot state exactly (a picture fill, for one) stays in
+     * `unknown`, and the field is absent.
+     */
+    interface ShapeProperties extends Element {
+        fill?: IFill.JSON;
+        stroke?: IStroke.JSON;
+        /** `a:effectLst`. An empty list is an explicit "no effects". */
+        effects?: IEffect.JSON[];
+    }
+    /**
+     * `c:txPr` and `c:rich`: a DrawingML text body. `c:txPr` holds formatting only: one paragraph whose
+     * default run (`pPr.defaultRun`) is the element's font.
+     */
+    interface TextBody extends Element {
+        bodyPr: TextBodyProperties;
+        /** `a:lstStyle`; present, and usually empty, when the file states it. */
+        lstStyle?: Element;
+        paragraphs: TextParagraph[];
+    }
+    /** `a:bodyPr`, as the file states it. */
+    interface TextBodyProperties extends Element {
+        /** `rot`, in degrees. Excel states `-1000` (`rot="-60000000"`) for "rotate as the element's default". */
+        rotation?: number;
+        vert?: string;
+        wrap?: 'none' | 'square';
+        anchor?: string;
+        anchorCtr?: boolean;
+        vertOverflow?: string;
+        horzOverflow?: string;
+        spcFirstLastPara?: boolean;
+        /** `lIns`, `tIns`, `rIns`, `bIns` in EMU. */
+        lIns?: number;
+        tIns?: number;
+        rIns?: number;
+        bIns?: number;
+    }
+    interface TextParagraph extends Element {
+        pPr?: ParagraphProperties;
+        runs?: TextRun[];
+        /** `a:endParaRPr`. */
+        endRun?: RunProperties;
+    }
+    /** `a:pPr`. */
+    interface ParagraphProperties extends Element {
+        align?: string;
+        rtl?: boolean;
+        /** `a:defRPr`: the font of runs that state none. */
+        defaultRun?: RunProperties;
+    }
+    /** `a:r`, `a:br` (`break`, text `'
+  '`) or `a:fld` (`field`). */
+    interface TextRun extends Element {
+        text: string;
+        rPr?: RunProperties;
+        break?: true;
+        field?: {
+            id: string;
+            type?: string;
+        };
+        /** The file marks the text's spaces as significant (`xml:space="preserve"` on `a:t`). */
+        preserveSpace?: true;
+    }
+    /** `a:rPr`, `a:defRPr`, `a:endParaRPr`: the run properties of {@link IText.RunPropertiesJSON}, in its units. */
+    interface RunProperties extends Element, Pick<IText.RunPropertiesJSON, 'size' | 'weight' | 'style' | 'underline' | 'strike' | 'capitals' | 'kerning' | 'letterSpacing' | 'baseline' | 'language' | 'alternateLanguage' | 'normalizeHeight' | 'outline'> {
+        color?: IFill.JSON;
+        /**
+         * The typefaces by script: a family, or a {@link IFontStyle.ThemeFamily} for the theme's
+         * heading or body font in that script.
+         */
+        latin?: string;
+        eastAsian?: string;
+        complexScript?: string;
+        symbol?: string;
+        /** {@inheritDoc IFontStyle.getFallbacks} */
+        fallbacks?: string[];
+    }
+}
+//# sourceMappingURL=ChartModel.d.ts.map

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

@@ -0,0 +1,14 @@
+import { ChartModel } from './ChartModel';
+import { NewChartType } from './_NewChart';
+/**
+ * `model` as a chart of `type`: one group of every series in plot order on the primary axes, each
+ * series drawn as the type draws it, the secondary axes gone (C14), the axes turned as the type
+ * needs. A 3-D form states Excel's view, floor and walls: a 3-D column's as a conversion makes
+ * them (C20), the others' as a new chart has them (believed); a surface its series axis and its
+ * value bands. A 2016 type is a new chart of the type over the series ({@link chartExOf}), and a
+ * 2016 chart given a classic type takes a new chart's axes and states what a classic chart does.
+ *
+ * @param counts Each series' point count by `idx`, for a pie's points and a bubble's sizes.
+ */
+export declare const convertChartType: (model: ChartModel.ChartSpace, type: NewChartType, counts: ReadonlyMap<number, number>) => ChartModel.ChartSpace;
+//# sourceMappingURL=_ChartType.d.ts.map