@sheetxl/sdk 0.8.0-beta.5 → 0.8.0-beta.6

package/types/src/calculation/_TableRename.d.ts

@@ -0,0 +1,13 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICalculation } from './ICalculation';
+/**
+ * Re-points every structured reference that names the table `from` at the table `to`. A
+ * reference with no table name is left alone: it names the table it is written in.
+ */
+export declare function renameTableTransform(from: string, to: string): ICalculation.FormulaTransform;
+/**
+ * `text`, parsed at `at`, with its references to the table `from` re-pointed at `to`, or the text
+ * itself when it names no such table or does not parse.
+ */
+export declare function renameTableInText(text: string, at: IRange.CellCoords, from: string, to: string): string;
+//# sourceMappingURL=_TableRename.d.ts.map

package/types/src/calculation/grid/CalcGrid.d.ts

@@ -1,5 +1,5 @@
 import { IRange, Scalar, IRuntime, FormulaError } from '@sheetxl/primitives';
-import { CoordUtils } from '@sheetxl/utils';
+import { CoordUtils, RunCoords } from '@sheetxl/utils';
 import { ITypes } from '../../type';
 import { IListener } from '../../listener';
 import { ListenerEmitter } from '../../listener/ListenerEmitter';
@@ -223,6 +223,15 @@ export declare class CalcGrid implements ICalcGrid {
     getEntireCoords(): IRange.Coords;
     /** {@inheritDoc ICalcGrid.resize} */
     resize(options?: ICalcGrid.RequestOptions): void;
+    /** {@inheritDoc ICalcGrid.setHidden} */
+    setHidden(axis: IRange.Axis, runs: readonly RunCoords[], options?: ICalcGrid.RequestOptions): void;
+    /** {@inheritDoc ICalcGrid.setFiltered} */
+    setFiltered(filtered: boolean, options?: ICalcGrid.RequestOptions): void;
+    /**
+     * Holds what the owner says of itself - what it hides, whether it is filtered - in the caller's
+     * operation: an undo restores it with whatever changed it.
+     */
+    protected _holdOwnerState(update: Pick<Partial<CalcGrid.State>, 'hiddenRows' | 'hiddenColumns' | 'filtered'>): void;
     /** {@inheritDoc ICalcGrid.getId} */
     getId(): string;
     /** {@inheritDoc ICalcGrid.toJSON} */
@@ -237,8 +246,8 @@ export declare class CalcGrid implements ICalcGrid {
     /**
      * This grid's content as its calc JSON (DESIGN-CALC-SERVICE §6.6): the same record a save
      * writes, and what a start opens the backend from. The formulas, the array extents, the
-     * volatile regions and - with `includeData` - the values are all this grid's own; a volatile
-     * region is kept only where a formula still sits.
+     * volatile regions, the rows and columns the owner hides and - with `includeData` - the values
+     * are all this grid's own; a volatile region is kept only where a formula still sits.
      *
      * A pending entry is written as its own text; a compiled one images its block where it sits.
      * @internal
@@ -366,6 +375,12 @@ export declare namespace CalcGrid {
         errorSpatial: ISpatialMap<boolean>;
         /** The grid was deleted - a sheet's removal - in this snapshot or before it. */
         deleted: boolean;
+        /** The rows the owner hides, ascending and disjoint; `null` for none. See {@link ICalcGrid.setHidden}. */
+        hiddenRows: readonly RunCoords[] | null;
+        /** The columns the owner hides, as {@link hiddenRows}. */
+        hiddenColumns: readonly RunCoords[] | null;
+        /** Whether the owner is filtered. See {@link ICalcGrid.setFiltered}. */
+        filtered: boolean;
     }
     /**
      * The maps a write may change. Each is cloned once, on first ask, under the caller's key; a map

package/types/src/calculation/grid/CalcGridBackend.d.ts

@@ -1,4 +1,5 @@
 import { IRange, FormulaError, Scalar, IFormulaContext } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
 import { Tuple, ISpatialQuery, ISparseGrid, ISpatialMap, ISpatialMap3D } from '../../collections';
 import { IContextContainer, CalcNode } from '../state';
 import { SpillEntry, FormulaSpatialValue, ContentfulSpatialValue, PrecedentSpatialValue, CircularEntry } from '../spatial';
@@ -46,6 +47,12 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     _getEntireCoords: () => IRange.Coords;
     /** The size a `resize` gave, in place of {@link _getEntireCoords}; versioned with the maps. */
     protected _resized: IRange.Coords | null;
+    /** The rows the owner hides, ascending and disjoint; `null` for none. Versioned with the maps. */
+    protected _hiddenRows: readonly RunCoords[] | null;
+    /** The columns the owner hides, as {@link _hiddenRows}. */
+    protected _hiddenColumns: readonly RunCoords[] | null;
+    /** Whether the owner is filtered ({@link ICalcGrid.setFiltered}). Versioned with the maps. */
+    protected _filtered: boolean;
     /**
      * @see CalcGridBackend.ConstructorOptions.unanchored
      */
@@ -151,6 +158,42 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     _detach(): void;
     /** The engine's own dirty marking over this grid's cells. @internal */
     _markDirtyRegionsNow(coords: readonly IRange.Coords[]): void;
+    /**
+     * The rows or columns the owner hides, ascending and disjoint; `null` for none. Engine-side: not
+     * on {@link ICalcGrid}.
+     */
+    getHiddenRuns(axis: IRange.Axis): readonly RunCoords[] | null;
+    /**
+     * Whether the owner is filtered: some AutoFilter or table on it holds a condition
+     * ({@link ICalcGrid.setFiltered}). Engine-side: not on {@link ICalcGrid}.
+     */
+    isFiltered(): boolean;
+    /**
+     * A range's skip (`IRange.IteratorOptions.processRowSkip`) over the rows or columns the owner
+     * hides, for a range starting at `origin` on that axis; `null` when the hidden set does not
+     * cross `origin..end`.
+     *
+     * @remarks
+     * One per hidden set and origin, kept: the statistics cache their zones by the skip they were
+     * walked under, so a formula handed the same skip on every pass keeps them warm, and a set
+     * that changed is a new array and so a new skip. A skip keeps a cursor, which makes it cheap
+     * to ask in order and correct to ask out of it.
+     */
+    getHiddenSkip(axis: IRange.Axis, origin: number, end: number): ((index: number, reverse?: boolean) => number) | null;
+    /**
+     * What a `hidden` request carries, held; the formulas that can skip hidden cells are owed a pass.
+     *
+     * @remarks
+     * A row hidden changes no cell, so nothing in the graph reaches them. They are found by what
+     * they call ({@link FormulaSpatialValue.hasTotals}), on every grid: a total reads another
+     * sheet's rows too, and a fact of the compiled formula holds for one a load trusted and never
+     * evaluated.
+     */
+    protected _setHiddenNow(axis: IRange.Axis, runs: readonly RunCoords[]): void;
+    /** What a `filtered` request carries, held; as {@link _setHiddenNow}, the totals are owed a pass. */
+    protected _setFilteredNow(filtered: boolean): void;
+    /** Mark every formula that calls a total function, on every grid, and ask for a pass. */
+    protected _markTotals(): void;
     /** @inheritdoc ICalcGrid.getId */
     getShadowOf(): string | null;
     /** @inheritdoc ICalcGrid.isArrayFirstCell */
@@ -434,6 +477,12 @@ export interface CalcGridMaps {
     circular: ISpatialMap<CircularEntry>;
     /** The size a `resize` gave, or `null` for the one the grid was made with. */
     entireCoords?: IRange.Coords | null;
+    /** The rows the owner hides, or `null` for none. */
+    hiddenRows?: readonly RunCoords[] | null;
+    /** The columns the owner hides, or `null` for none. */
+    hiddenColumns?: readonly RunCoords[] | null;
+    /** Whether the owner is filtered. */
+    filtered?: boolean;
 }
 interface CalcGridSnapshot {
     calcGrid: CalcGridBackend;

package/types/src/calculation/grid/CalcGridProxy.d.ts

@@ -1,4 +1,5 @@
 import { IRange, FormulaError, Scalar } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
 import { IListener } from '../../listener';
 import { ListenerEmitter } from '../../listener/ListenerEmitter';
 import { ISpatialMap, Tuple } from '../../collections';
@@ -40,6 +41,10 @@ export declare class CalcGridProxy implements ICalcGrid.Backend {
     getEntireCoords(): IRange.Coords;
     /** {@inheritDoc ICalcGrid.resize} */
     resize(options?: ICalcGrid.RequestOptions): void;
+    /** {@inheritDoc ICalcGrid.setHidden} */
+    setHidden(axis: IRange.Axis, runs: readonly RunCoords[], options?: ICalcGrid.RequestOptions): void;
+    /** {@inheritDoc ICalcGrid.setFiltered} */
+    setFiltered(filtered: boolean, options?: ICalcGrid.RequestOptions): void;
     /** {@inheritDoc ICalcGrid.addListeners} */
     addListeners(listeners: ICalcGrid.IListeners, options?: IListener.Options): IListener.Remove;
     /** @inheritdoc ICalcGrid.setInputs */

package/types/src/calculation/grid/ICalcGrid.d.ts

@@ -1,4 +1,5 @@
 import { Scalar, IRange, FormulaError } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
 import { RangeStats } from '../../primitives/RangeStats';
 import { ITypes } from '../../type';
 import { ITransaction } from '../../transaction';
@@ -312,6 +313,30 @@ export interface ICalcGrid {
      * @param options See {@link ICalcGrid.RequestOptions}.
      */
     resize(options?: ICalcGrid.RequestOptions): void;
+    /**
+     * Sets the rows or columns the grid's owner hides: the whole set on that axis, replacing the
+     * one before. Recorded with the grid's other content, in the caller's operation, and told to the
+     * engine in order with the grid's writes; every formula that calls `SUBTOTAL` or `AGGREGATE`
+     * recalculates. The set a grid opens with is its seed's ({@link ICalcGrid.JSON.hiddenRows}).
+     *
+     * @param axis The axis the runs are on.
+     * @param runs Every hidden run on that axis, ascending and disjoint; empty for none.
+     * @param options See {@link ICalcGrid.RequestOptions}.
+     */
+    setHidden(axis: IRange.Axis, runs: readonly RunCoords[], options?: ICalcGrid.RequestOptions): void;
+    /**
+     * Sets whether the grid's owner is filtered: some AutoFilter or table on it holds a condition.
+     * Recorded and told as {@link setHidden} is; every formula that calls `SUBTOTAL` or `AGGREGATE`
+     * recalculates. The state a grid opens with is its seed's ({@link ICalcGrid.JSON.filtered}).
+     *
+     * @remarks
+     * `SUBTOTAL` 1-11 skip the owner's hidden rows only while this is set; 101-111 skip them always.
+     * A hidden row is one thing whoever hid it, so this is the whole of what a filter adds.
+     *
+     * @param filtered `true` while a condition is held.
+     * @param options See {@link ICalcGrid.RequestOptions}.
+     */
+    setFiltered(filtered: boolean, options?: ICalcGrid.RequestOptions): void;
     /**
      * Opens the grid from a seed: a statement of its whole content (DESIGN-CALC-SERVICE §6).
      *
@@ -810,6 +835,18 @@ export declare namespace ICalcGrid {
          * For built-in functions volatile will be auto added.
          */
         volatile?: IRange.Address[];
+        /**
+         * The rows the grid's owner hides, ascending and disjoint; absent for none.
+         */
+        hiddenRows?: readonly RunCoords[];
+        /**
+         * The columns the grid's owner hides, as {@link hiddenRows}.
+         */
+        hiddenColumns?: readonly RunCoords[];
+        /**
+         * Whether the grid's owner is filtered ({@link ICalcGrid.setFiltered}); absent for not.
+         */
+        filtered?: boolean;
     }
     /**
      * Options for {@link ICalcGrid.seed}.

package/types/src/calculation/grid/_CalcRequest.d.ts

@@ -1,4 +1,5 @@
 import { Scalar, IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
 import { ISpatialMap, Tuple } from '../../collections';
 import { FormulaRecord, FormulaImager } from '../formula';
 import { ICalculation } from '../ICalculation';
@@ -31,6 +32,27 @@ export type CalcRequest =
     type: 'resize';
     entireCoords: IRange.Coords;
     options?: ICalcGrid.RequestOptions;
+}
+/**
+ * The rows or columns the grid's owner hides changed: every run as it is now, ascending and
+ * disjoint, empty for none. What the functions that skip hidden cells read (`SUBTOTAL` 101-111,
+ * `AGGREGATE`'s ignore-hidden options); the formulas that call them are recalculated.
+ */
+ | {
+    type: 'hidden';
+    axis: IRange.Axis;
+    runs: readonly RunCoords[];
+    options?: ICalcGrid.RequestOptions;
+}
+/**
+ * Whether the grid's owner is filtered changed: some AutoFilter or table on it holds a
+ * condition, or none does any more. What `SUBTOTAL` 1-11 read to decide whether hidden rows
+ * count; the formulas that call the total functions are recalculated.
+ */
+ | {
+    type: 'filtered';
+    filtered: boolean;
+    options?: ICalcGrid.RequestOptions;
 } | {
     type: 'seed';
     json: ICalcGrid.JSON;

package/types/src/calculation/state/CalculationContext.d.ts

@@ -92,7 +92,13 @@ export declare class CalculationContext implements IFormulaContext {
     /** @inheritdoc IFormulaContext.formatResults */
     formatResults(numFmt: string): void;
     /** @inheritdoc IFormulaContext.filterHidden */
-    filterHidden(range: IRange, axes?: IRange.AxisSelection): IRange;
+    filterHidden(range: IRange, options?: IFormulaContext.FilterHiddenOptions): IRange;
+    /**
+     * The id of the grid a reference's public coords name: its sheet's, or - unqualified - the grid
+     * being evaluated. `getCoords()` spells a sheet as its name, and the engine's own maps (the
+     * formulas, the hidden runs) are keyed by grid id.
+     */
+    private _gridIdOf;
     /** @inheritdoc IFormulaContext.filterTotals */
     filterTotals(range: IRange): IRange;
     /** @inheritdoc IFormulaContext.getSheetIndex */

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

@@ -369,10 +369,13 @@ export interface ICell {
     /**
      * Creates a temporary copy of the cell with the specified updates applied.
      *
+     * @param modifiers The update.
+     * @param options How the update is read. See {@link ICell.CreateCellOptions}.
+     *
      * @remarks
      * The original cell remains unchanged, making this useful for temporary modifications.
      */
-    createCell(modifiers: ICell.Update): ICell;
+    createCell(modifiers: ICell.Update, options?: ICell.CreateCellOptions): ICell;
     /**
      * Returns the `CellCoords`.
      */
@@ -518,6 +521,23 @@ export declare namespace ICell {
          */
         comments?: IComment.Update;
     }
+    /**
+     * Options for {@link ICell.createCell} and {@link ISheet.createCell}.
+     */
+    interface CreateCellOptions {
+        /**
+         * Whether a text value is read as a typed entry is — `9/23/95` a date, `12.3%` a number —
+         * rather than taken as the text it is. `true` reads it with the defaults; an
+         * {@link ICell.ModifiersFromStringOptions} customizes the reading.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * The same reading {@link ICellRange.setValues} gives text, where it is the default. Here it
+         * is opt-in: a cell created from a value keeps that value.
+         */
+        textParser?: boolean | ICell.ModifiersFromStringOptions;
+    }
     /**
      * Configuration options for customizing the parsing of a string into an `ICell.Update` object.
      * Commonly used for processing CSV imports and other string-based data sources.

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

@@ -1,22 +1,20 @@
 import { IResource, IResourceCollection } from '../resource';
-import { IModel, AbstractModel } from '../model';
-import { IMovable } from '../movable';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ICellRange } from '../cellRange';
 import { IEmbeddedPart } from '../io';
 import { IChart } from './IChart';
-interface State extends AbstractModel.State {
+interface State extends AbstractMovableContent.State {
     data?: any;
 }
 /**
  * Implementation for {@link IChart}.
  */
-export declare class Chart extends AbstractModel<State, IChart.JSON> implements IChart {
+export declare class Chart extends AbstractMovableContent<State, IChart.JSON> implements IChart {
     /**
      * The chart's document part. Held beside {@link State.data} rather than in it because the
      * resources it carries are model references, not JSON, and have to be re-persisted per save.
      */
     protected _part: IEmbeddedPart | null;
-    protected _getMovable: () => IMovable;
     protected _getRange: ((address: string) => ICellRange | null) | null;
     /** The markup `_facts` was read from. */
     private _factsSource;
@@ -47,15 +45,11 @@ export declare class Chart extends AbstractModel<State, IChart.JSON> implements
     getAxes(): readonly IChart.IAxis[];
     /** {@inheritDoc IChart.getPivotSource} */
     getPivotSource(): string | null;
-    /** {@inheritDoc Movable.Content.getDescription} */
-    getDescription(): string;
-    /** {@inheritDoc IChart.getMovable} */
-    getMovable(): IMovable;
     /** {@inheritDoc IChart.getXML} */
     getXML(): string | null;
     /** {@inheritDoc Movable.Content.toJSON} */
     toJSON(toResourceId?: (resource: IResource) => number | null): IChart.JSON | null;
-    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
     getTypeDescription(): string;
     /** @internal */
     protected _processDelete(): void;
@@ -74,7 +68,7 @@ export declare namespace Chart {
     /**
      * Options for creating a Chart.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<IChart.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<IChart.JSON> {
         /**
          * Returns an IResource from the resourceId or null if not found.
          */
@@ -87,13 +81,6 @@ export declare namespace Chart {
          * Allow for the default lock aspect ratio to be overwritten.
          */
         defaultLockAspectRatio?: boolean;
-        /**
-         * Resolves the movable this chart is the content of.
-         *
-         * @remarks
-         * Called when asked, not at construction — the content is built before its movable is.
-         */
-        getMovable: () => IMovable;
         /**
          * Resolves a sheet-qualified address in the chart's workbook.
          */

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

@@ -9,7 +9,7 @@ import { IChartCollection } from './IChartCollection';
  * @remarks
  * A live view over the movables — no store of its own and no event of its own. The movables'
  * `onCollectionChange` is forwarded as this collection's, with this collection as the source;
- * deleting the movable is deleting the chart.
+ * deleting the chart removes its movable.
  */
 export declare class ChartCollection extends AbstractCollection<IChart> implements IChartCollection {
     private _movables;

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

@@ -1,4 +1,5 @@
 import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IModel } from '../model';
 import { IMovable } from '../movable';
@@ -8,11 +9,11 @@ import { ICellRange } from '../cellRange';
  * Interface for working with a chart.
  *
  * @remarks
- * A chart is the content of a movable, which places and names it — see {@link IChart.getMovable}.
+ * 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 {
+export interface IChart extends IModel, IMovable.IContent {
     /**
      * Returns the chart's title, or `null` if it has none.
      *
@@ -54,17 +55,17 @@ export interface IChart extends IModel {
      */
     getPivotSource(): string | null;
     /**
-     * Returns a description for assistive technologies.
-     */
-    getDescription(): string;
-    /**
-     * Returns the movable that places the chart on the sheet.
+     * Returns the movable that places the chart on the sheet, or `null` if it is not placed by one.
      *
      * @remarks
-     * The movable holds the chart's position, size and name; the chart keeps no copy of any of
-     * them. Deleting the movable deletes the chart.
+     * The movable holds the chart's position and size; the chart keeps no copy of either.
+     * Deleting the chart removes its movable.
+     */
+    getMovable(): IMovable | null;
+    /**
+     * Deletes the chart, and with it the movable that places it.
      */
-    getMovable(): IMovable;
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * Returns the chart's own markup, or `null` if none was captured.
      *

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

@@ -5,8 +5,8 @@ import { IChart } from './IChart';
  *
  * @remarks
  * A view over the sheet's movables: a chart is the content of a movable, and the movable is what
- * places, names and deletes it — see {@link IChart.getMovable}. Read-only for now; a chart is
- * added by adding a movable with chart content.
+ * places it — see {@link IChart.getMovable}. Read-only for now; a chart is added by adding a
+ * movable with chart content.
  */
 export interface IChartCollection extends ICollection<IChart> {
     /**
@@ -14,7 +14,7 @@ export interface IChartCollection extends ICollection<IChart> {
      */
     getItems(options?: ICollection.GetItemsOptions): IChart[];
     /**
-     * Returns the chart whose movable has the given name, or `null` if there is none.
+     * Returns the chart with the given name, or `null` if there is none.
      *
      * @param name The name of the chart. This is case insensitive.
      */

package/types/src/color/_BuiltInIndexDefs.d.ts

@@ -1,4 +1,10 @@
 import { ColorSpace } from './ColorSpace';
+import { IColor } from './IColor';
+/**
+ * The system color an index names, or `null` for a palette index.
+ * @internal
+ */
+export declare function _BuiltInIndexSystemName(index: number): IColor.Named | null;
 /** @internal */
 export declare function _BuiltInIndexDefs(index: number): ColorSpace.RGBA | null;
 //# sourceMappingURL=_BuiltInIndexDefs.d.ts.map

package/types/src/comment/Comment.d.ts

@@ -4,9 +4,12 @@ import { ITransaction } from '../transaction';
 import { ICellRange } from '../cellRange';
 import { ISheet } from '../sheet';
 import { IPerson, IPersonCollection } from '../person';
+import { IMovable } from '../movable';
+import { IRichText } from '../text';
 import { Anchored } from '../anchored/Anchored';
 import { AbstractAnchored } from '../anchored/AbstractAnchored';
 import { IComment } from './IComment';
+import { NoteMovable } from './NoteMovable';
 /**
  * Implementation of {@link IComment}.
  *
@@ -15,9 +18,19 @@ import { IComment } from './IComment';
  * so it subscribes to nothing. The replies are part of this model's state — a reply has no cell
  * and no transaction of its own — and {@link CommentReply} objects are handles over them, one
  * per reply id, minted on demand and kept so identity is stable.
+ *
+ * A note's box is a movable the sheet places when the comment becomes a note, with the comment
+ * as its content. Where the box is and whether it is shown are the movable's; the comment saves
+ * them with itself, the anchor restated from its cell, so a note copied to another cell keeps
+ * its box beside it.
  */
 export declare class Comment extends AbstractAnchored<State, IComment.Events> implements IComment {
     private _replies;
+    /**
+     * Every box placed for this comment. At most one is live: a reply deletes the box, an undo
+     * brings the same one back, and a note made again from a thread is given a new one.
+     */
+    private _boxes;
     /** @internal */
     protected _initialize(options: Comment.ConstructorOptions): void;
     /** @internal */
@@ -31,6 +44,8 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
     protected _isAnchorAbsolute(): boolean;
     /** @internal */
     protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
+    /** @internal */
+    protected _processDelete(): void;
     /**
      * {@inheritDoc IComment.getId}
      *
@@ -48,7 +63,7 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
     /** {@inheritDoc IComment.setContent} */
     setContent(content: IComment.Content, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc IComment.getRichContent} */
-    getRichContent(): IComment.RichContent | null;
+    getRichContent(): IRichText.JSON | null;
     /** {@inheritDoc IComment.getAuthor} */
     getAuthor(): IPerson | null;
     /** {@inheritDoc IComment.getCreationDate} */
@@ -67,17 +82,38 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
     addReply(content: IComment.Content, options?: IComment.AddReplyOptions): IComment.IReply;
     /** {@inheritDoc IComment.update} */
     update(update: IComment.Modifiers | IComment, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IComment.getType} */
+    getType(): string;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IMovable.IContent.getDescription} */
+    getDescription(): string | null;
+    /** {@inheritDoc IMovable.IContent.setDescription} */
+    setDescription(description: string | null): this;
+    /** {@inheritDoc IComment.getMovable} */
+    getMovable(): IMovable | null;
+    /**
+     * The live box, if there is one.
+     * @internal
+     */
+    protected _getBox(): NoteMovable | null;
+    /**
+     * Asks the sheet for a box: at `anchor`, its cells counted from this comment's, or where Excel
+     * puts a new note's. A comment with no sheet to place one on has no box.
+     * @internal
+     */
+    protected _placeBox(anchor: IMovable.AnchorOffset | null, hidden: boolean): void;
+    /**
+     * The note is gone, or is a thread now: its box goes with it.
+     * @internal
+     */
+    protected _removeBox(): void;
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: IComment.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc IComment.toJSON} */
     toJSON(): IComment.JSON | null;
     /** @internal */
     protected _fromJSON(json?: IComment.JSON | null, options?: ITransaction.OperationOptions): void;
-    /**
-     * The note's box, as read.
-     * @internal
-     */
-    getBox(): IComment.BoxJSON | null;
     /** @internal */
     protected _getPeople(): IPersonCollection | null;
     /** @internal */
@@ -140,6 +176,29 @@ export declare namespace Comment {
          * has finished loading.
          */
         getPeople?: () => IPersonCollection | null;
+        /**
+         * What places a note's box. A comment given none has no movable.
+         */
+        boxes?: Comment.Boxes;
+    }
+    /**
+     * What a note's box needs of the sheet it is on: to be placed, and to know whether it is where
+     * a new note's goes.
+     */
+    interface Boxes {
+        /**
+         * Places a note's box among the sheet's movables, with the note as its content.
+         *
+         * @param comment The note.
+         * @param anchor Where the box is, its cells counted from the note's; `null` for where Excel
+         * puts a new note's.
+         * @param hidden Whether the box appears only while its cell is pointed at.
+         */
+        add(comment: Comment, anchor: IMovable.AnchorOffset | null, hidden: boolean): NoteMovable;
+        /**
+         * Whether a box is where a new note's goes, which a note saves nothing for.
+         */
+        isDefault(comment: Comment, box: IMovable): boolean;
     }
 }
 /** @internal */
@@ -153,7 +212,10 @@ interface State extends AbstractAnchored.State {
     asNote: boolean;
     mentions: IComment.MentionJSON[] | null;
     replies: readonly IComment.ReplyJSON[];
-    box: IComment.BoxJSON | null;
+    /** The alternative text of a note's box. */
+    description: string | null;
+    /** How a note's box is drawn when not the default: markup a file's writer replays. */
+    boxXml: string | null;
 }
 export {};
 //# sourceMappingURL=Comment.d.ts.map