@sheetxl/sdk 0.8.0-beta.17 → 0.8.0-beta.18

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

@@ -29,6 +29,8 @@ export declare namespace AddressUtils {
     const refToRun: <T = any>(ref: IRange.JSONReference<T>, isColumn: boolean) => RunCoordValue<T> | null;
     /** {@inheritDoc runToRef} */
     const runsToRefs: <T = any>(runs: readonly Readonly<RunCoordValue<T>>[], isColumn: boolean) => IRange.JSONReferenceEntry<T>[];
+    /** Splits an address list at its `,` separators, skipping those in a quoted sheet name or brackets. */
+    const splitAddressList: (address: string) => string[];
     /** {@inheritDoc refToRun} */
     const refsToRuns: <T = any>(refs: readonly IRange.JSONReference<T>[], isColumn: boolean) => RunCoordValue<T>[];
 }

package/types/src/anomalies/_Anomalies.d.ts

@@ -38,6 +38,8 @@ export interface AnomalySource extends RoleSource {
     readonly isProtected: boolean;
     /** The font colors the workbook's other sheets write their roles in ({@link roleColorsOf}). */
     readonly workbookRoleColors: () => ReadonlySet<string>;
+    /** The cells of this sheet the workbook's other sheets' formulas read ({@link foreignReadsOf}). */
+    readonly workbookReads: () => ISpatialQuery<unknown>;
 }
 type Rect = IRange.Coords;
 /** @internal */
@@ -89,6 +91,32 @@ export interface FormulaRegion {
     /** The formula in R1C1, which is what agrees between two cells of one run. */
     readonly r1c1: string;
 }
+/** @internal */
+export declare class _FormatKeys {
+    private readonly _styles;
+    private readonly _normal;
+    private readonly _named;
+    constructor(_styles: IStyleCollection);
+    keyOf(props: Readonly<ICellStyle.Properties> | null, part: 'font' | 'fill' | 'numberFormat' | 'alignment'): string;
+    /**
+     * The font color a cell claims, as `#RRGGBB`: its own, else its named style's, else the Normal
+     * style's. A theme color resolves through the workbook's theme, so an unformatted cell and one
+     * authored in the theme's text color are one key.
+     */
+    fontColorOf(props: Readonly<ICellStyle.Properties> | null): string;
+    private _toHex;
+    private readonly _hex;
+    private _namedProps;
+}
+/**
+ * The cells of `target` that the formulas of `others` read, as rectangles: what `unreferencedInput`
+ * subtracts from a sheet's own unread inputs. A filled formula region is read at its first and
+ * last cells and the two references' bounding box is taken, which overstates a diagonal fill and
+ * never understates. With the engine off there is no compiler for a detached formula, and a
+ * region whose formula is not compiled reads nothing.
+ * @internal
+ */
+export declare function foreignReadsOf(target: IWorksheet, others: readonly IWorksheet[]): ISpatialMap<boolean>;
 /**
  * The role layer (`ICellRange.Feature.Role`): the kind layer refined by what a formula reads and
  * by who reads a cell. Typed cells are `label` (nothing reads them) or `input` (something does); a
@@ -105,5 +133,11 @@ export declare function buildRoles(source: RoleSource): ISpatialMap<ICell.Role>;
  * @internal
  */
 export declare function roleColorsOf(source: AnomalySource): ReadonlySet<string>;
+/** The parts of `rects` that none of `held` covers. @internal */
+export declare function minusHeld(rects: readonly Rect[], held: readonly Rect[]): Rect[];
+/** @internal */
+export declare const intersect: (a: Rect, b: Rect) => Rect | null;
+/** The parts of `rects` inside `bounds`. @internal */
+export declare const clipAll: (rects: readonly Rect[], bounds: Rect) => Rect[];
 export {};
 //# sourceMappingURL=_Anomalies.d.ts.map

package/types/src/anomalies/_CompletenessChecks.d.ts

@@ -0,0 +1,32 @@
+import { ISpatialMap } from '../collections';
+import { AnomalySource, _Findings, _FormatKeys } from './_Anomalies';
+/**
+ * `unreferencedInput`: a typed number (or date) beside a label that no formula in the workbook
+ * reads — `Tax rate  21%` where nothing computes a tax. The role layer says what this sheet's
+ * formulas read, and what the other sheets read (`workbookReads`) is subtracted too. A labeled
+ * line fires only when none of its typed numbers is read anywhere: a historical row whose last
+ * period feeds a forecast is data in use, not an assumption left out. A line of three or more
+ * numbers at a constant step (years, period counts) is a header and never fires. One finding per
+ * labeled line, by its row label, else its column label, ranked down by the cells it holds: a
+ * lone cell is an assumption, a twelve-cell row is data.
+ */
+export declare function checkUnreferencedInput(source: AnomalySource, findings: _Findings): void;
+/**
+ * `rowGap`: a labeled row with nothing where its block or its header has columns — the line of a
+ * schedule left out, its first period, or a whole period never built. The label is the row's
+ * first filled cell when it is text. A block is a run of filled rows with no blank row between
+ * (one spacer row still joins); its columns are every column, past the label, that any other row
+ * of the block fills, so a first-period column that only the block's last line fills still counts.
+ * The nearest header row above (text, dates or a numeric series past its first cell, no formula)
+ * adds its columns, so a period the header names and no row fills is a gap too; a row with no
+ * header above it (a title, a note) has no periods and never fires. `missing` of `of`
+ * says how much of the row is empty: a row with some of those cells filled is a line with a period
+ * left out and ranks in full, an empty row at half; a column only the header supplies ranks at
+ * two thirds (`header`, the period's label, says so). A label in a font neither neighbor's label
+ * shares reads as a heading (`labelFont: 'own'`) and ranks at a third: a heading has nothing to
+ * its right by design.
+ */
+export declare function checkRowGap(source: AnomalySource, formats: _FormatKeys, findings: _Findings): void;
+/** @internal */
+export type { ISpatialMap };
+//# sourceMappingURL=_CompletenessChecks.d.ts.map

package/types/src/cell/ICell.d.ts

@@ -3,8 +3,9 @@ import { Size, Rectangle, Bounds } from '@sheetxl/utils';
 import { ITypes } from '../type';
 import { ITextFrame, TextRotation, TextStacked, IRichText } from '../text';
 import { NumberFormat } from '../numFmt';
-import { IConditionalFormat } from '../conditionalFormat/IConditionalFormat';
+import { IConditionalFormat } from '../conditionalFormat';
 import { ICellControl } from '../cellControl';
+import { ISparklineGroup } from '../sparkline';
 import { IHyperlink } from '../hyperlink';
 import { IComment } from '../comment';
 import { ICellStyle } from '../style';
@@ -367,6 +368,15 @@ export interface ICell {
      * checkbox cell holding `2` has a control and draws `2`.
      */
     getControl(): ICellControl | null;
+    /**
+     * Returns the cell's sparkline, or `null` when it has none.
+     *
+     * @remarks
+     * The sparkline is the cell's view of its group: what it draws
+     * ({@link ISparklineGroup.ISparkline.getDataRange}) and how ({@link ISparklineGroup.ISparkline.getGroup}).
+     * A cell has at most one. It is drawn over the cell's value, which it leaves as it is.
+     */
+    getSparkline(): ISparklineGroup.ISparkline | null;
     /**
      * Returns `true` if the cell contains a value.
      *
@@ -779,6 +789,14 @@ export declare namespace ICell {
          * `range.getDataValidation().clear()`.
          */
         readonly DataValidations: "dataValidations";
+        /**
+         * Represents the sparklines drawn in the cells.
+         * @remarks
+         * A clear takes the cells out of their sparkline groups; a group left with no cell is
+         * deleted. Excel's Sparkline > Clear. Clear Contents and Clear Formats leave a sparkline, as in
+         * Excel; Clear All removes it.
+         */
+        readonly Sparklines: "sparklines";
     };
     type Content = typeof Content[keyof typeof Content];
     /**
@@ -888,6 +906,10 @@ export declare namespace ICell {
         readonly TwinBlockDivergence: "twinBlockDivergence";
         /** A typed number an order of magnitude or more off the numbers typed in its format on the sheet. */
         readonly ScaleOutlier: "scaleOutlier";
+        /** A typed number beside a label that no formula in the workbook reads: an assumption the model never uses. */
+        readonly UnreferencedInput: "unreferencedInput";
+        /** A labeled row with nothing where the rows above and below hold values: a line left out, or a period of it. */
+        readonly RowGap: "rowGap";
         /** A constant typed into a formula — a number, a string or a boolean — and how often the workbook types it. */
         readonly ConstantFrequency: "constantFrequency";
     };
@@ -927,6 +949,8 @@ export declare namespace ICell {
      * | `literalMatchesInput` | `literal`, the number as the formula types it; `inputAt`, the nearest typed number of that value no formula reads; `label` / `labelAt`, that input's label, when it has one; `matches`, the places the value is typed unread |
      * | `twinBlockDivergence` | `part` (`'literal'` / `'sign'`); for a literal, `literal` and `expected`, this formula's number and its twins'; for a sign, `term` of `terms`, the term that differs, `references`, how many the shape holds, and `sign`, how this formula adds it; `twins`, how many formulas carry the other side; `twinAt`, one of them |
      * | `scaleOutlier` | `format` (`'percent'`); `times`, the power of ten the value is off by; `typical`, the median of the sheet's typed numbers in that format; `of`, how many there are |
+     * | `unreferencedInput` | `label` / `labelAt`, the line's label; `cells`, the typed numbers on the line nothing reads; `value`, the number as shown, for a line of one cell |
+     * | `rowGap` | `label` / `labelAt`, the row's label; `missing` of `of`, the empty cells among those filled in both neighbor rows; `kind` (`'cells'`, some of the row is filled; `'row'`, none of it); `above` / `aboveAt` and `below` / `belowAt`, the neighbor rows' labels, where text; `labelFont: 'own'` when neither neighbor's label shares the label's font |
      * | `constantFrequency` | `kind` (`'number'`, `'string'`, `'boolean'`); `value`, a number without its sign; `uses`, the places in the workbook that type it; `of`, the workbook's constant uses |
      *
      * **Runs.** `formula`, `hardcodeInRun` and `styleBreak` are one rule over different layers of
@@ -982,6 +1006,17 @@ export declare namespace ICell {
      * places in the workbook type it (`uses`) and of how many constant uses (`of`). The rarer the
      * constant, the higher it ranks. A finding's `uses` and `of` change when another sheet changes.
      *
+     * **What is left out.** `unreferencedInput` reads the typed numbers beside a label that no
+     * formula on any sheet reads: an assumption the model never uses, which in a model being built
+     * is the item still to build. A labeled line fires only when none of its numbers is read, so a
+     * historical row whose last period feeds a forecast is data in use; a line of numbers at one
+     * step (years) is a header. The rank is divided by the line's cells: a lone cell is an
+     * assumption, a long row is data. `rowGap` reads a labeled row against the rows above and
+     * below it (within one spacer row): the cells filled in both neighbors and empty here are the
+     * line left out, or its missing periods. A row that is partly filled ranks in full, an empty row
+     * at half, and a row whose label is in a font neither neighbor shares (a heading) at a third.
+     * Both findings change when another sheet starts or stops reading the cell.
+     *
      * A label's position is absolute (`R12C3`), since it stays put whichever cell of a region reads
      * it; its text is the one read at the region's first cell.
      */

package/types/src/cellRange/ICellRange.d.ts

@@ -21,6 +21,7 @@ import { IDataValidation, IDataValidationCollection } from '../dataValidation';
 import { IConditionalFormat, IConditionalFormatCollection } from '../conditionalFormat';
 import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
 import { ICellControl, ICellControlCollection } from '../cellControl';
+import { ISparklineGroup, ISparklineGroupCollection } from '../sparkline';
 import { ICellRanges } from './ICellRanges';
 import { ICellRegions } from './ICellRegion';
 import { ICellHeaderRange } from './ICellHeaderRange';
@@ -131,6 +132,53 @@ export interface ICellRange {
      * by {@link clear} of formats, and carried by a paste of formats.
      */
     setControl(control: ICellControl.JSON | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * Draws a sparkline in each cell of the range, from its share of `data`, as one new group; `null`
+     * removes the cells' sparklines.
+     *
+     * @param data The cells the sparklines draw: one area, on this sheet when not qualified, or a
+     * defined name for one (read as the cells it names now, as Excel does).
+     * @param properties How they draw. A new group starts as Excel's does: empty cells as gaps,
+     * Excel's colors, and negative points colored for win/loss.
+     * @returns The new group, or `null` for a removal.
+     *
+     * @remarks
+     * Excel's Insert > Sparklines, and VBA's `Range.SparklineGroups.Add(Type, SourceData)`. The range
+     * is the location: one cell, or one row or one column of cells. The cells pair with the data as
+     * Excel pairs them:
+     * - One cell draws all of `data`, which must be one row or one column.
+     * - A column of cells draws a row of `data` each, its first cell the first row: `F2:F4` over
+     *   `A2:E4` draws `A2:E2`, `A3:E3`, `A4:E4`.
+     * - A row of cells draws a column each, the same way.
+     *
+     * Refused, as Excel refuses them: a location of several rows and columns, data that is a union
+     * or a table's structured reference, two-dimensional data for one cell, and data whose rows or
+     * columns do not number the cells. Also refused: a row of cells over data that only pairs by
+     * rows, which Excel draws a row each, transposed.
+     *
+     * A cell has one sparkline, so the cells leave any group they were in. Sparklines are drawn over
+     * the cells' values, which stay; refused on a protected sheet unless formatting cells is allowed.
+     *
+     * @example
+     * ```ts
+     * sheet.getRange('F2:F4').setSparkline('A2:E4', { type: 'column', high: true });
+     * sheet.getRange('F2:F4').setSparkline(null);
+     * ```
+     */
+    /**
+     * Returns the {@link ISparklineGroup}s with a sparkline in the range.
+     *
+     * @param options The filters of {@link ISparklineGroupCollection.getItems} without `address`;
+     * this range is the address.
+     *
+     * @remarks
+     * See {@link getConditionalFormats} for the overlap and one-entry-per-item rules, which are the
+     * same for every ranged item lookup. The groups, never one entry per sparkline: a column of a
+     * million sparklines is one group. Ask a cell for its own with {@link ICell.getSparkline}.
+     * VBA's `Range.SparklineGroups`.
+     */
+    getSparklineGroups(options?: ICellRange.GetItemsOptions<ISparklineGroupCollection.GetItemsOptions>): ISparklineGroup[];
+    setSparkline(data: ICellRange.Address | null, properties?: ISparklineGroup.Modifiers, options?: ITransaction.OperationOptions): ISparklineGroup | null;
     /**
      * Returns the {@link IDataValidation}s that overlap the range, in priority order.
      *
@@ -2861,6 +2909,11 @@ export declare namespace ICellRange {
          * question: ask for both to split a column of checkboxes from the text cells among them.
          */
         readonly CellControl: "cellControl";
+        /**
+         * Cells with a sparkline ({@link IWorksheet.getSparklineGroups}). Regions group by the
+         * sparkline group, so two groups side by side are two regions.
+         */
+        readonly Sparkline: "sparkline";
         /**
          * Cells where an error check fires — what breaks the pattern around it. Regions group by the
          * check and its evidence, so a filled row that breaks the same way is one region; the anchor
@@ -3187,6 +3240,18 @@ export declare namespace ICellRange {
          * An address rather than a range, because the cells at it now are other cells.
          */
         getPreviousAddress(): string | null;
+        /**
+         * The edits that changed the range's cells, in the order they were made, for an `'address'`
+         * event of a listener that asked for them ({@link ListenerOptions.edits}); empty otherwise.
+         *
+         * @remarks
+         * Where {@link getSource} says where the range landed, these say what happened to its cells on
+         * the way: each band inserted or deleted, and each cut that took some of them. A listener that
+         * keeps something per cell of the range - a reference, a mark - reads these to take each cell
+         * through on its own. An undo or a redo restores a revision rather than repeating the edits,
+         * so it has none.
+         */
+        getEdits(): readonly ICellRange.Edit[];
         /**
          * What happened to the range.
          *
@@ -3233,6 +3298,35 @@ export declare namespace ICellRange {
          */
         type Trigger = 'data' | 'address' | 'restore';
     }
+    /**
+     * One edit that changed a listened range's cells. See {@link ICellRange.Event.getEdits}.
+     */
+    type Edit = Edit.Shift | Edit.Move;
+    namespace Edit {
+        /**
+         * Cells inserted or deleted: `range` is the band, and `direction` the way the cells beside it
+         * shifted (`Down` or `Right` for an insert, `Up` or `Left` for a delete).
+         */
+        interface Shift {
+            readonly type: 'shift';
+            readonly range: IRange.Coords;
+            readonly direction: IRange.Direction;
+        }
+        /**
+         * Cells cut from `from` to `to`, taking all of the listened range or only some of it.
+         *
+         * @remarks
+         * A cut to another sheet names it as `toSheet`. A listener whose whole range was cut there
+         * goes with it: its source is on that sheet from then on.
+         */
+        interface Move {
+            readonly type: 'move';
+            readonly from: IRange.Coords;
+            readonly to: IRange.Coords;
+            /** The sheet the cells went to, when it is not the sheet they came from. */
+            readonly toSheet?: IWorksheet;
+        }
+    }
     /**
      * Called with what changed at a listened range. See {@link ICellRange.addListener}.
      *
@@ -3297,6 +3391,18 @@ export declare namespace ICellRange {
          * @defaultValue false
          */
         ignoreAddressChanges?: boolean;
+        /**
+         * Whether an `'address'` event carries the edits that changed the range's cells
+         * ({@link Event.getEdits}).
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * With it, the listener is also told of a cut that takes only some of its cells: the range
+         * itself stays (a cut moves a reference only when it takes all of it), but the cells it
+         * names were moved, and the event says where.
+         */
+        edits?: boolean;
         /**
          * How the listened range follows rows and columns inserted or deleted around it.
          *

package/types/src/index.d.ts

@@ -52,6 +52,7 @@ export * from './dataValidation';
 export * from './conditionalFormat';
 export * from './protectedRange';
 export * from './cellControl';
+export * from './sparkline';
 export * from './slicer';
 export * from './table';
 export { Table } from './table/Table';

package/types/src/license/runtime.browser.d.ts

@@ -18,7 +18,9 @@ export declare function getHostDetails(): Promise<HostDetails>;
  * does — no watermark, the evaluation period, then its grace — so the line is the host, not the
  * product, and nothing has to declare it. Plain `http:` is web too: an intranet site is still a
  * site, and the cheapest bypass there could be is "serve it over http". Outside a window (a worker
- * without a location, node under test) there is no page to classify, and it stays web.
+ * without a location, node under test) there is no page to classify, and it stays web. The one
+ * `http` page that is not a site is the screenshot page ({@link SCREENSHOT_HOST}), on that exact
+ * scheme and host; it is not a dev environment, so a key served to it is still checked in full.
  */
 export declare function isWebPage(): Promise<boolean>;
 /**

package/types/src/sheet/IWorksheet.d.ts

@@ -24,6 +24,7 @@ import { IDataValidation, IDataValidationCollection } from '../dataValidation';
 import { IConditionalFormat, IConditionalFormatCollection } from '../conditionalFormat';
 import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
 import { ICellControl, ICellControlCollection } from '../cellControl';
+import { ISparklineGroup, ISparklineGroupCollection } from '../sparkline';
 import { IModule, IModuleCollection } from '../scripting';
 import { IChartCollection } from '../chart';
 import { INamedCollection } from '../named';
@@ -230,6 +231,14 @@ export interface IWorksheet extends ISheet, ITransaction.ITransactional, IListen
      * {@link ICellRange.setControl} and {@link ICellRange.getControls}.
      */
     getCellControls(): ICellControlCollection;
+    /**
+     * Returns the sparkline groups on this sheet.
+     *
+     * @remarks
+     * A sparkline is a small chart drawn in a cell, over its value. Each group shares one type and
+     * one set of properties across its sparklines.
+     */
+    getSparklineGroups(): ISparklineGroupCollection;
     /**
      * Returns the comments and notes on this sheet.
      *
@@ -1019,6 +1028,10 @@ export declare namespace IWorksheet {
          * Always accompanied by the coarse {@link onStyleChange}: a control is a format.
          */
         onCellControlsChange?(source: IWorksheet): void;
+        /**
+         * Called when a sparkline group is added, removed or re-anchored.
+         */
+        onSparklineGroupsChange?(source: IWorksheet): void;
         /**
          * Called when a comment is added, removed, edited, resolved, replied to or re-anchored.
          *
@@ -1463,6 +1476,10 @@ export declare namespace IWorksheet {
         validationSettings?: IDataValidationCollection.Settings;
         protectedRanges?: IRange.JSONReference<IProtectedRange.JSON>[];
         cellControls?: IRange.JSONReference<ICellControl.JSON>[];
+        /**
+         * The sparkline groups. Each group's ranges pair by position with the areas of its `data`.
+         */
+        sparklineGroups?: IRange.JSONReference<ISparklineGroup.JSON>[];
         movables?: IMovable.JSON[];
         /**
          * The sheet's VBA code name. Absent when it has none.

package/types/src/sheet/SheetCell.d.ts

@@ -20,6 +20,7 @@ import { CellStyleUpdater } from './style/SheetCellStyle';
 import { ICalcGrid } from '../calculation/grid';
 import { IConditionalFormat } from '../conditionalFormat';
 import { ICellControl } from '../cellControl/ICellControl';
+import { ISparklineGroup } from '../sparkline/ISparklineGroup';
 import { PivotLabelInset } from '../pivot/_PivotControls';
 /**
  * CellModifiers with all functions removed and all properties set and a type.
@@ -238,6 +239,8 @@ export declare class SheetCell implements ICell {
     getConditionalDecorations(): Readonly<IConditionalFormat.Decorations>;
     /** {@inheritDoc ICell.getControl} */
     getControl(): ICellControl | null;
+    /** {@inheritDoc ICell.getSparkline} */
+    getSparkline(): ISparklineGroup.ISparkline | null;
     /** {@inheritDoc ICell.getProtection} */
     getProtection(): ICellProtection;
     /** {@inheritDoc ICell.getTextOverflow} */

package/types/src/sheet/SheetRange.d.ts

@@ -3,6 +3,8 @@ import { Size, RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ICell } from '../cell';
+import { ISparklineGroup } from '../sparkline/ISparklineGroup';
+import { ISparklineGroupCollection } from '../sparkline/ISparklineGroupCollection';
 import { ICellRange, ICellRegions, ICellRanges, ICellHeaderRange } from '../cellRange';
 import { IComment, ICommentCollection } from '../comment';
 import { ICellStyle } from '../style';
@@ -348,6 +350,10 @@ export declare class SheetRange implements ICellRange {
     getControls(options?: ICellRange.GetItemsOptions<ICellControlCollection.GetItemsOptions>): ICellControl[];
     /** {@inheritDoc ICellRange.setControl} */
     setControl(control: ICellControl.JSON | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.getSparklineGroups} */
+    getSparklineGroups(options?: ICellRange.GetItemsOptions<ISparklineGroupCollection.GetItemsOptions>): ISparklineGroup[];
+    /** {@inheritDoc ICellRange.setSparkline} */
+    setSparkline(data: ICellRange.Address | null, properties?: ISparklineGroup.Modifiers, options?: ITransaction.OperationOptions): ISparklineGroup | null;
     /** {@inheritDoc ICellRange.getDataValidations} */
     getDataValidations(options?: ICellRange.GetItemsOptions<IDataValidationCollection.GetItemsOptions>): IDataValidation[];
     /** {@inheritDoc ICellRange.getComments} */

package/types/src/sheet/Worksheet.d.ts

@@ -50,6 +50,8 @@ import { IDataValidationCollection, IDataValidation } from '../dataValidation';
 import { DataValidation } from '../dataValidation/DataValidation';
 import { ProtectedRange } from '../protectedRange/ProtectedRange';
 import { CellControl } from '../cellControl/CellControl';
+import { ISparklineGroup, ISparklineGroupCollection } from '../sparkline';
+import { SparklineGroup } from '../sparkline/SparklineGroup';
 import { Comment } from '../comment/Comment';
 import { NoteMovable } from '../comment/NoteMovable';
 import { NoteLayout } from '../comment/_NoteBox';
@@ -81,6 +83,7 @@ import { ICalculation } from '../calculation';
 import { ICalcGrid } from '../calculation/grid';
 import { SpillEntry } from '../calculation/spatial';
 import { SheetCellOptions } from './SheetCell';
+import * as SparklineRanges from '../sparkline/SparklineRanges';
 import * as _SheetFilterUtils from './_SheetFilterUtils';
 /** The font colors a workbook writes its roles in, and a key that compares by content. */
 interface WorkbookRoleColors {
@@ -228,6 +231,7 @@ export declare class Worksheet implements IWorksheet {
     protected _dataValidations: IDataValidationCollection;
     protected _protectedRanges: IProtectedRangeCollection;
     protected _cellControls: ICellControlCollection;
+    protected _sparklineGroups: ISparklineGroupCollection;
     protected _comments: ICommentCollection;
     protected _movables: IMovableCollection;
     protected _charts: IChartCollection;
@@ -406,6 +410,7 @@ export declare class Worksheet implements IWorksheet {
         filteredTables: () => ITable[];
         setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
         setCellControl: (address: ICellRanges.Address, control: ICellControl.JSON | null, options?: ITransaction.OperationOptions) => ICellControl | null;
+        setSparkline: (address: ICellRanges.Address, data: ICellRange.Address, modifiers?: ISparklineGroup.Modifiers | null, options?: ITransaction.OperationOptions) => ISparklineGroup;
         setErrorIgnored: (ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions) => void;
         setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
         getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
@@ -431,6 +436,7 @@ export declare class Worksheet implements IWorksheet {
         formulas: unknown;
         epoch: number;
         roleColors: string;
+        reads: unknown;
         findings: AnomalyFindings;
     } | null;
     /**
@@ -440,6 +446,19 @@ export declare class Worksheet implements IWorksheet {
      * @internal
      */
     protected _getAnomalyFindings(roleColors?: WorkbookRoleColors): AnomalyFindings;
+    /** The cells of this sheet the other sheets read, and the formulas they were read from; see {@link _getForeignReads}. */
+    protected _foreignReads: {
+        sheets: readonly Worksheet[];
+        formulas: readonly unknown[];
+        map: ISpatialMap<boolean>;
+    } | null;
+    /**
+     * The cells of this sheet that the workbook's other sheets' formulas read, the reads
+     * `unreferencedInput` subtracts. Derived from the other sheets' formula partitions and kept
+     * until one of them changes.
+     * @internal
+     */
+    protected _getForeignReads(): ISpatialMap<boolean>;
     /** This worksheet and the workbook's others, very hidden included. */
     protected _getWorkbookSheets(): Worksheet[];
     /** The workbook's role colors and the sheets' sets they were the union of; see {@link _getWorkbookRoleColors}. */
@@ -547,6 +566,7 @@ export declare class Worksheet implements IWorksheet {
         assertContentEditable: (ranges: readonly IRange.Coords[], viaRanges?: boolean) => boolean;
         isMoveRuled: () => boolean;
         getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
+        getName: () => string;
         processLayoutChange: () => void;
         /** The movables' by-model index as a shift left it, or `null` if the shift moved none. */
         takeShiftedMovableModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
@@ -670,6 +690,7 @@ export declare class Worksheet implements IWorksheet {
             filteredTables: () => ITable[];
             setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
             setCellControl: (address: ICellRanges.Address, control: ICellControl.JSON | null, options?: ITransaction.OperationOptions) => ICellControl | null;
+            setSparkline: (address: ICellRanges.Address, data: ICellRange.Address, modifiers?: ISparklineGroup.Modifiers | null, options?: ITransaction.OperationOptions) => ISparklineGroup;
             setErrorIgnored: (ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions) => void;
             setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
             getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
@@ -1276,6 +1297,26 @@ export declare class Worksheet implements IWorksheet {
         node: ListenerAnchor;
         remove: IListener.Remove;
     };
+    /**
+     * Removes a listener's node and its callback, with the twins a cut to another sheet made of it.
+     * @internal
+     */
+    protected _dropListenerEntry(entry: ListenerNodeEntry): void;
+    /**
+     * After a cut of `from` on this sheet to `to` on `sheetTo`: a listener whose ranges the cut
+     * encloses goes with them, as a twin node on `sheetTo` written in the cut's commit (so undo and
+     * redo carry both sheets' maps together, and the twin that is not in a snapshot stays quiet). One
+     * the cut takes only part of stays, and is told the move if it asked for the edits. A sparkline
+     * group whose data the cut took reads it on `sheetTo`.
+     * @internal
+     */
+    protected _moveReferencesToSheet(sheetTo: Worksheet, from: IRange.Coords, to: IRange.Coords): void;
+    /**
+     * A listener from `fromSheet`, its ranges cut here to `coords`: a node in this sheet's map, in the
+     * current commit, delivering to the same callback. Its first delivery is the move.
+     * @internal
+     */
+    protected _adoptListenerNode(entry: ListenerNodeEntry, coords: readonly IRange.Coords[], previous: readonly IRange.Coords[], from: IRange.Coords, to: IRange.Coords, fromSheet: Worksheet): ListenerNodeEntry;
     /**
      * Register a watch: an expression kept evaluated over a range.
      *
@@ -1475,6 +1516,8 @@ export declare class Worksheet implements IWorksheet {
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyCellControlsChange(): void;
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifySparklineGroupsChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyCommentsChange(): void;
     /**
      * Presents one of the sheet's own events as a collection's `onCollectionChange`, and the
@@ -1485,7 +1528,7 @@ export declare class Worksheet implements IWorksheet {
      * it. Forwarding, rather than a second emitter, is what keeps the two from drifting apart.
      * @internal
      */
-    protected _forwardCollectionListeners(key: 'onTablesChange' | 'onConditionalFormatsChange' | 'onDataValidationsChange' | 'onProtectedRangesChange' | 'onCellControlsChange' | 'onCommentsChange', collection: () => ICollection<any>): (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove;
+    protected _forwardCollectionListeners(key: 'onTablesChange' | 'onConditionalFormatsChange' | 'onDataValidationsChange' | 'onProtectedRangesChange' | 'onCellControlsChange' | 'onSparklineGroupsChange' | 'onCommentsChange', collection: () => ICollection<any>): (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove;
     /** {@inheritDoc IWorksheet.addListeners} */
     addListeners(listeners: IWorksheet.IListeners, options?: IListener.Options): IListener.Remove;
     /** @internal */
@@ -2055,6 +2098,8 @@ export declare class Worksheet implements IWorksheet {
     getProtectedRanges(): IProtectedRangeCollection;
     /** {@inheritDoc IWorksheet.getCellControls} */
     getCellControls(): ICellControlCollection;
+    /** {@inheritDoc IWorksheet.getSparklineGroups} */
+    getSparklineGroups(): ISparklineGroupCollection;
     /** {@inheritDoc IWorksheet.getComments} */
     getComments(): ICommentCollection;
     /** @deprecated Use {@link IWorksheet.getConditionalFormats} */
@@ -2130,6 +2175,49 @@ export declare class Worksheet implements IWorksheet {
      * @internal
      */
     protected _addCellControl(address: ICellRanges.Address, control: ICellControl.JSON, options?: ITransaction.OperationOptions): ICellControl;
+    /**
+     * Adds a sparkline group over `ranges`, each a location and the data its cells read, taking
+     * those cells out of any group they were in: a cell has one sparkline.
+     * @internal
+     */
+    _addSparklineGroup(ranges: readonly SparklineRanges.SparklineRange[], properties: Readonly<ISparklineGroup.Properties>, options?: ITransaction.OperationOptions): ISparklineGroup | null;
+    /**
+     * Draws a sparkline in each cell of `address` from its share of `data`, as one new group: the
+     * write behind `ICellRange.setSparkline` and `ISparklineGroupCollection.add`. Pairs and refuses as
+     * Excel's `SparklineGroups.Add` does (`SparklineRanges.pairData`).
+     * @internal
+     */
+    protected _setSparkline(address: ICellRanges.Address, data: ICellRange.Address, modifiers?: ISparklineGroup.Modifiers | null, options?: ITransaction.OperationOptions): ISparklineGroup;
+    private _refuseSparklinePairing;
+    /** The prefix data on `range`'s sheet is written with: none for this sheet. */
+    private _sparklinePrefix;
+    /**
+     * Gives `group` new cells, new data or both, as Excel's Edit Sparklines dialog does: the write
+     * behind `ISparklineGroup.setRanges` and `setDataRanges`. Pairs as `SparklineRanges.pairAreas`; the
+     * new cells leave any other group they were in. One undo entry.
+     * @internal
+     */
+    protected _modifySparklineGroup(group: SparklineGroup, location: ICellRanges.Address | null, data: ICellRanges.Address | null, options?: ITransaction.OperationOptions): void;
+    /**
+     * The areas `data` names, each one area as {@link _sparklineDataRange} reads it: a union is
+     * split at its commas, each area on its own sheet.
+     */
+    private _sparklineDataAreas;
+    /**
+     * The one area `data` names: bare on this sheet, qualified on its sheet, a defined name as the
+     * cells it names now. Refuses what Excel's `Add` refuses: a union and a table's structured
+     * reference.
+     */
+    private _sparklineDataRange;
+    /**
+     * Puts one group over `coords`, each reading `data` (paired by position, as the JSON states
+     * them), taking those cells out of any group they were in.
+     *
+     * @param ruled Whether the cells' protection allowance has already ruled, so the commit-time
+     * check is skipped.
+     * @internal
+     */
+    private _putSparklineGroup;
     /**
      * Makes `control` the control of every cell of `address`, or removes the cells' controls when
      * it is `null`. The write behind `ICellRange.setControl` and `ICellControlCollection.add`.
@@ -2279,6 +2367,11 @@ export declare class Worksheet implements IWorksheet {
     protected _createProtectedRanges(protectedRanges: IAnchoredMap<IProtectedRange, IProtectedRange.JSON>, key: keyof State, refs: IRange.JSONReference<IProtectedRange.JSON>[], createModel: (options: ProtectedRange.ConstructorOptions) => IProtectedRange, addListeners?: (model: IProtectedRange) => IListener.Remove): IAnchoredMap<IProtectedRange, IProtectedRange.JSON>;
     /** @internal */
     protected _createCellControls(cellControls: IAnchoredMap<ICellControl, ICellControl.JSON>, key: keyof State, refs: IRange.JSONReference<ICellControl.JSON>[], createModel: (options: CellControl.ConstructorOptions) => ICellControl): IAnchoredMap<ICellControl, ICellControl.JSON>;
+    /**
+     * Loads sparkline groups into their anchored map.
+     * @internal
+     */
+    protected _createSparklineGroups(sparklineGroups: IAnchoredMap<ISparklineGroup, ISparklineGroup.JSON>, refs: IRange.JSONReference<ISparklineGroup.JSON>[]): IAnchoredMap<ISparklineGroup, ISparklineGroup.JSON>;
     /**
      * Loads the pivot tables into their anchored map, each anchored where its part says it sits.
      * The map moves and deletes them with structural edits; the grid's spill of a table rules on
@@ -2397,6 +2490,8 @@ interface RangeEventOptions extends NotifierOptions {
      * @defaultValue `#REF!`
      */
     invalidError?: string;
+    /** The edits an `'address'` event carries, for a listener that asked for them. */
+    edits?: readonly ICellRange.Edit[];
 }
 interface ListenerNodeEntry {
     node: ListenerAnchor;
@@ -2417,6 +2512,13 @@ interface ListenerNodeEntry {
     watch?: WatchAnchor.Handlers;
     /** The batch a participant was added through: it is told as each step of that batch is made. */
     batch?: BatchHandle | null;
+    /** The same listener on other sheets, made by cuts that took its ranges there (and back). */
+    twins?: {
+        sheet: Worksheet;
+        entry: ListenerNodeEntry;
+    }[];
+    /** Removed: its callback is gone, and so are its twins'. */
+    dropped?: boolean;
 }
 /**
  * A run of formula cells with the references they inherit a number format from, relative to the