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

package/types/src/print/PageLayout.d.ts

@@ -0,0 +1,258 @@
+import { IRange } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ICalculation } from '../calculation';
+import { IResource } from '../resource';
+import { IEmbeddedPart } from '../io/IEmbeddedPart';
+import { IWorksheet } from '../sheet/IWorksheet';
+import { IPageLayout } from './IPageLayout';
+interface State {
+    /** Everything but the printer settings, which hold a resource. Defaults left out. */
+    json: Readonly<IPageLayout.JSON>;
+    printerSettings: IEmbeddedPart | null;
+}
+type HeaderFooterKind = 'odd' | 'even' | 'first';
+type HeaderFooterKey = keyof Pick<IPageLayout.HeaderFooterJSON, 'oddHeader' | 'oddFooter' | 'evenHeader' | 'evenFooter' | 'firstHeader' | 'firstFooter'>;
+/** The left, center and right sections of a header or footer string. */
+type Sections = [string, string, string];
+/**
+ * The print layout of a sheet.
+ *
+ * @remarks
+ * Holds the settings as JSON, an absent value being its default, so `toJSON` returns what the file
+ * said plus what was set since. The print area and titles are the sheet's names, not state here.
+ */
+export declare class PageLayout implements IPageLayout {
+    protected _options: PageLayout.ConstructorOptions;
+    protected _transactions: ITransaction.IStore;
+    protected _id: string;
+    protected _headersFooters: HeaderFooterGroup | null;
+    constructor(options: PageLayout.ConstructorOptions);
+    protected _getState(): Readonly<State>;
+    /** @internal */
+    _getJSON(): Readonly<IPageLayout.JSON>;
+    /**
+     * Writes the fields given, leaving out any that are `undefined` (a default) and dropping an
+     * empty header/footer block.
+     * @internal
+     */
+    _update(update: Partial<IPageLayout.JSON>, options?: ITransaction.OperationOptions, description?: string): this;
+    protected _sheet(): IWorksheet;
+    /** @internal */
+    _getSheet(): IWorksheet;
+    /** {@inheritDoc IPageLayout.getOrientation} */
+    getOrientation(): IPageLayout.Orientation;
+    /** {@inheritDoc IPageLayout.setOrientation} */
+    setOrientation(orientation: IPageLayout.Orientation, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPaperSize} */
+    getPaperSize(): IPageLayout.PaperType | null;
+    /** {@inheritDoc IPageLayout.getPaperSizeCode} */
+    getPaperSizeCode(): number;
+    /** {@inheritDoc IPageLayout.setPaperSize} */
+    setPaperSize(paperSize: IPageLayout.PaperType | number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getZoom} */
+    getZoom(): IPageLayout.ZoomOptions;
+    /** {@inheritDoc IPageLayout.setZoom} */
+    setZoom(zoom: IPageLayout.ZoomOptions, options?: ITransaction.OperationOptions): this;
+    protected _margins(): Readonly<IPageLayout.MarginsJSON>;
+    protected _setMargins(inches: IPageLayout.MarginOptions, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getTopMargin} */
+    getTopMargin(): number;
+    /** {@inheritDoc IPageLayout.setTopMargin} */
+    setTopMargin(topMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getBottomMargin} */
+    getBottomMargin(): number;
+    /** {@inheritDoc IPageLayout.setBottomMargin} */
+    setBottomMargin(bottomMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getLeftMargin} */
+    getLeftMargin(): number;
+    /** {@inheritDoc IPageLayout.setLeftMargin} */
+    setLeftMargin(leftMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getRightMargin} */
+    getRightMargin(): number;
+    /** {@inheritDoc IPageLayout.setRightMargin} */
+    setRightMargin(rightMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getHeaderMargin} */
+    getHeaderMargin(): number;
+    /** {@inheritDoc IPageLayout.setHeaderMargin} */
+    setHeaderMargin(headerMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getFooterMargin} */
+    getFooterMargin(): number;
+    /** {@inheritDoc IPageLayout.setFooterMargin} */
+    setFooterMargin(footerMargin: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.setPrintMargins} */
+    setPrintMargins(unit: IPageLayout.PrintMarginUnit, marginOptions: IPageLayout.MarginOptions, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getCenterHorizontally} */
+    getCenterHorizontally(): boolean;
+    /** {@inheritDoc IPageLayout.setCenterHorizontally} */
+    setCenterHorizontally(centerHorizontally: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getCenterVertically} */
+    getCenterVertically(): boolean;
+    /** {@inheritDoc IPageLayout.setCenterVertically} */
+    setCenterVertically(centerVertically: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintGridlines} */
+    getPrintGridlines(): boolean;
+    /** {@inheritDoc IPageLayout.setPrintGridlines} */
+    setPrintGridlines(printGridlines: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintHeadings} */
+    getPrintHeadings(): boolean;
+    /** {@inheritDoc IPageLayout.setPrintHeadings} */
+    setPrintHeadings(printHeadings: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getBlackAndWhite} */
+    getBlackAndWhite(): boolean;
+    /** {@inheritDoc IPageLayout.setBlackAndWhite} */
+    setBlackAndWhite(blackAndWhite: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getDraftMode} */
+    getDraftMode(): boolean;
+    /** {@inheritDoc IPageLayout.setDraftMode} */
+    setDraftMode(draftMode: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getFirstPageNumber} */
+    getFirstPageNumber(): number | '';
+    /** {@inheritDoc IPageLayout.setFirstPageNumber} */
+    setFirstPageNumber(firstPageNumber: number | '' | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintOrder} */
+    getPrintOrder(): IPageLayout.PrintOrder;
+    /** {@inheritDoc IPageLayout.setPrintOrder} */
+    setPrintOrder(printOrder: IPageLayout.PrintOrder, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintComments} */
+    getPrintComments(): IPageLayout.PrintComments;
+    /** {@inheritDoc IPageLayout.setPrintComments} */
+    setPrintComments(printComments: IPageLayout.PrintComments, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintErrors} */
+    getPrintErrors(): IPageLayout.PrintErrorType;
+    /** {@inheritDoc IPageLayout.setPrintErrors} */
+    setPrintErrors(printErrors: IPageLayout.PrintErrorType, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getHeadersFooters} */
+    getHeadersFooters(): IPageLayout.IHeaderFooterGroup;
+    /** The sheet's own name of this kind; a global one of the same name is not the sheet's. */
+    protected _getName(name: string): ICalculation.INamedFormula | null;
+    /** Writes the name, or deletes it when `expression` is `null`. */
+    protected _setName(name: string, expression: string | null): void;
+    /** The absolute, sheet-qualified reference to each range, as Excel writes these names. */
+    protected _toReference(coords: readonly Readonly<IRange.Coords>[]): string;
+    /**
+     * The ranges a print name designates, read from its text: the engine answers `getRanges()` only
+     * once it has compiled the name, and a setter reads the titles straight after writing them.
+     * `null` when the name is not a list of references on this sheet.
+     */
+    protected _nameCoords(name: string): IRange.Coords[] | null;
+    /** {@inheritDoc IPageLayout.getPrintArea} */
+    getPrintArea(): ICellRanges | null;
+    /** {@inheritDoc IPageLayout.setPrintArea} */
+    setPrintArea(printArea: ICellRanges.Address | null, _options?: ITransaction.OperationOptions): this;
+    /** The title rows and columns, each the first block of its kind in `_xlnm.Print_Titles`. */
+    protected _titles(): {
+        rows: ICellRange | null;
+        columns: ICellRange | null;
+    };
+    /** Writes the titles as Excel does: columns first, then rows. */
+    protected _setTitles(rows: IRange.Coords | null, columns: IRange.Coords | null): void;
+    /** The entire rows or columns a title setter was given, or `null` to clear them. */
+    protected _toTitle(title: ICellRange | string | null, axis: IRange.Axis): IRange.Coords | null;
+    /** {@inheritDoc IPageLayout.getPrintTitleRows} */
+    getPrintTitleRows(): ICellRange | null;
+    /** {@inheritDoc IPageLayout.setPrintTitleRows} */
+    setPrintTitleRows(printTitleRows: ICellRange | string | null, _options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.getPrintTitleColumns} */
+    getPrintTitleColumns(): ICellRange | null;
+    /** {@inheritDoc IPageLayout.setPrintTitleColumns} */
+    setPrintTitleColumns(printTitleColumns: ICellRange | string | null, _options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    _getHeaderFooter(key: HeaderFooterKey): string;
+    /** @internal */
+    _updateHeaderFooter(update: Partial<IPageLayout.HeaderFooterJSON>, options?: ITransaction.OperationOptions): this;
+    /** The manual and automatic breaks before rows (`Row`) or columns (`Column`), in order. @internal */
+    _getBreaks(axis: IRange.Axis): readonly IPageLayout.BreakJSON[];
+    /** @internal */
+    _setBreaks(axis: IRange.Axis, breaks: IPageLayout.BreakJSON[], options?: ITransaction.OperationOptions): this;
+    /**
+     * Moves the breaks as rows (or columns) `start` to `end` are inserted or deleted: a break at or
+     * after an insert moves with it, a break before a deleted row goes with it, and a break past a
+     * delete moves back. Excel's behavior (`scripts/openpy-parity/probe-print-setup.ps1`).
+     * @internal
+     */
+    _shiftBreaks(axis: IRange.Axis, start: number, end: number, isInsert: boolean): void;
+    /** The manual breaks on an axis. */
+    protected _getPageBreaks(axis: IRange.Axis): IPageLayout.IPageBreak[];
+    /** {@inheritDoc IPageLayout.getHorizontalPageBreaks} */
+    getHorizontalPageBreaks(): IPageLayout.IPageBreak[];
+    /** {@inheritDoc IPageLayout.getVerticalPageBreaks} */
+    getVerticalPageBreaks(): IPageLayout.IPageBreak[];
+    /** {@inheritDoc IPageLayout.addHorizontalPageBreak} */
+    addHorizontalPageBreak(pageBreakRange: ICellRange.Address, options?: ITransaction.OperationOptions): IPageLayout.IPageBreak;
+    /** {@inheritDoc IPageLayout.addVerticalPageBreak} */
+    addVerticalPageBreak(pageBreakRange: ICellRange.Address, options?: ITransaction.OperationOptions): IPageLayout.IPageBreak;
+    /** {@inheritDoc IPageLayout.removeAllHorizontalPageBreaks} */
+    removeAllHorizontalPageBreaks(options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.removeAllVerticalPageBreaks} */
+    removeAllVerticalPageBreaks(options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IPageLayout.isIPageLayout} */
+    get isIPageLayout(): true;
+    /**
+     * Adds a manual break before `index`, spanning the whole sheet the way Excel writes a new one.
+     * An automatic break already there becomes manual.
+     */
+    protected _addPageBreak(axis: IRange.Axis, index: number, options?: ITransaction.OperationOptions): IPageLayout.IPageBreak;
+    /** @internal */
+    _removePageBreak(axis: IRange.Axis, index: number, options?: ITransaction.OperationOptions): void;
+    /** Removes every break on an axis, the automatic ones the file carried included. */
+    protected _removeAllPageBreaks(axis: IRange.Axis, options?: ITransaction.OperationOptions): void;
+    /** @internal */
+    _getPrinterSettings(): IEmbeddedPart | null;
+    /** The layout as JSON, or `null` when every setting is its default. */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IPageLayout.JSON | null;
+    /** @internal */
+    _sections(key: HeaderFooterKey): Sections;
+    /** @internal */
+    _setSection(key: HeaderFooterKey, section: 0 | 1 | 2, text: string, options?: ITransaction.OperationOptions): this;
+}
+/** @see {@link IPageLayout.IHeaderFooterGroup} */
+declare class HeaderFooterGroup implements IPageLayout.IHeaderFooterGroup {
+    protected _layout: PageLayout;
+    protected _sets: Record<HeaderFooterKind, HeaderFooter>;
+    constructor(layout: PageLayout);
+    getState(): IPageLayout.HeaderFooterState;
+    setState(state: IPageLayout.HeaderFooterState, options?: ITransaction.OperationOptions): this;
+    getDefaultForAllPages(): IPageLayout.IHeaderFooter;
+    getOddPages(): IPageLayout.IHeaderFooter;
+    getEvenPages(): IPageLayout.IHeaderFooter;
+    getFirstPage(): IPageLayout.IHeaderFooter;
+    getUseSheetMargins(): boolean;
+    setUseSheetMargins(useSheetMargins: boolean, options?: ITransaction.OperationOptions): this;
+    getUseSheetScale(): boolean;
+    setUseSheetScale(useSheetScale: boolean, options?: ITransaction.OperationOptions): this;
+}
+/** @see {@link IPageLayout.IHeaderFooter} */
+declare class HeaderFooter implements IPageLayout.IHeaderFooter {
+    protected _layout: PageLayout;
+    protected _header: HeaderFooterKey;
+    protected _footer: HeaderFooterKey;
+    constructor(layout: PageLayout, kind: HeaderFooterKind);
+    getLeftHeader(): string;
+    setLeftHeader(leftHeader: string, options?: ITransaction.OperationOptions): this;
+    getCenterHeader(): string;
+    setCenterHeader(centerHeader: string, options?: ITransaction.OperationOptions): this;
+    getRightHeader(): string;
+    setRightHeader(rightHeader: string, options?: ITransaction.OperationOptions): this;
+    getLeftFooter(): string;
+    setLeftFooter(leftFooter: string, options?: ITransaction.OperationOptions): this;
+    getCenterFooter(): string;
+    setCenterFooter(centerFooter: string, options?: ITransaction.OperationOptions): this;
+    getRightFooter(): string;
+    setRightFooter(rightFooter: string, options?: ITransaction.OperationOptions): this;
+    getHeader(): string;
+    setHeader(header: string, options?: ITransaction.OperationOptions): this;
+    getFooter(): string;
+    setFooter(footer: string, options?: ITransaction.OperationOptions): this;
+}
+export declare namespace PageLayout {
+    interface ConstructorOptions {
+        /** The sheet the layout prints, for its names and ranges. */
+        getSheet: () => IWorksheet;
+        transactions?: ITransaction.IStore;
+        json?: IPageLayout.JSON;
+        fromResourceId?: (resourceId: number) => IResource;
+    }
+}
+export {};
+//# sourceMappingURL=PageLayout.d.ts.map

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

@@ -1,2 +1,2 @@
-export * from './IPrint';
+export * from './IPageLayout';
 //# sourceMappingURL=index.d.ts.map

package/types/src/protectedRange/IProtectedRange.d.ts

@@ -9,7 +9,7 @@ import { ITransaction } from '../transaction';
  * @remarks
  * Excel surfaces these as *Review → Allow Edit Ranges*, and OOXML persists them as
  * `<protectedRange>` inside `<protectedRanges>`. Despite the name, a protected range **relaxes**
- * protection rather than adding it: it is only consulted while {@link ISheetProtection.isLocked}
+ * protection rather than adding it: it is only consulted while {@link IWorksheetProtection.isLocked}
  * is true, and it grants an exemption for the cells it covers — optionally behind a password.
  *
  * * Like {@link IConditionalFormat} and {@link IDataValidation}, one entry may be anchored to
@@ -47,7 +47,7 @@ export interface IProtectedRange extends IAnchored {
     /**
      * Re-anchors this protected range to `address`, REPLACING every range it currently covers.
      *
-     * @param address The range or ranges to cover — anything `ISheet.getRanges` accepts
+     * @param address The range or ranges to cover — anything `IWorksheet.getRanges` accepts
      *   (`'A1:C20'`, `'A1:A5, C1:C5'`, coords). Resolved against this protected range's own sheet.
      * @param options Transaction options; `description` names the entry in undo history.
      *

package/types/src/protection/IProtection.d.ts

@@ -187,6 +187,12 @@ export declare namespace IProtection {
          * @defaultValue `100000`.
          */
         spinCount?: number;
+        /**
+         * The 16-bit hash older applications write instead of {@link hash} (Excel 2010 and earlier,
+         * LibreOffice, openpyxl), as hex digits. A password is checked against it when there is no
+         * {@link hash}. A password set through the API is never stored this way.
+         */
+        legacyHash?: string;
     }
     /**
      * **PLACEHOLDER** - Will integrate into the user identity system.

package/types/src/protection/PasswordHasher.d.ts

@@ -1,3 +1,4 @@
+import { IProtection } from './IProtection';
 export interface SaltAndHash {
     salt: string;
     hash: string;
@@ -27,6 +28,18 @@ export declare class PasswordHasher {
      * @returns The encryption key as a base64 string.
      */
     static verifyPassword(password: string, saltAndHash: SaltAndHash, algorithm?: string, spinCount?: number): Promise<boolean>;
+    /**
+     * Verify a password against the 16-bit hash older applications write.
+     *
+     * @param password The password.
+     * @param legacyHash The hash, as hex digits.
+     */
+    static verifyLegacyPassword(password: string, legacyHash: string): boolean;
+    /**
+     * Verify a password against a stored one: its {@link IProtection.EncryptedPassword.hash} when it
+     * has one, else its {@link IProtection.EncryptedPassword.legacyHash}. `true` when it has neither.
+     */
+    static verifyStoredPassword(password: string, stored: Partial<IProtection.EncryptedPassword>): Promise<boolean>;
     /**
      * For unit testing against existing salt and hash keys.
      */

package/types/src/richData/IRichDataKind.d.ts

@@ -0,0 +1,22 @@
+import { IRichData } from '@sheetxl/primitives';
+/**
+ * A registered kind of rich data: its name, and how a value of it is made from its JSON.
+ *
+ * @remarks
+ * A value's `getType()` is the kind's `name`. What a value reads as where a primitive or an array
+ * is consumed is the value's own answer ({@link IRichData.toPrimitive}, {@link IRichData.toArray}),
+ * as `toString()` is; the kind only makes values.
+ *
+ * Register a kind with {@link RichDataRegistry.register}.
+ */
+export interface IRichDataKind<T extends IRichData = IRichData> {
+    /**
+     * The kind's name, the `type` of its values and their JSON.
+     */
+    readonly name: string;
+    /**
+     * A value from its JSON, as {@link IRichData.toJSON} wrote it.
+     */
+    fromJSON(json: IRichData.JSON): T;
+}
+//# sourceMappingURL=IRichDataKind.d.ts.map

package/types/src/richData/RichDataRegistry.d.ts

@@ -0,0 +1,57 @@
+import { IRichData, Scalar, ScalarType } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * The kinds of rich data a cell can hold, by name.
+ *
+ * @remarks
+ * A value is made from its JSON by looking its `type` up here; what a value reads as where a
+ * primitive is consumed is asked here too. The built-in kinds are registered when the SDK loads;
+ * a host registers its own the same way. A type nobody has registered still loads and saves: it
+ * becomes an {@link RichDataRegistry.Unmodeled} value that carries its JSON as it was and reads as
+ * nothing.
+ */
+export declare namespace RichDataRegistry {
+    /**
+     * Registers a kind. A kind registered again under the same name replaces the earlier one.
+     */
+    function register(kind: IRichDataKind<any>): void;
+    /** The kind registered as `name`, or `null`. */
+    function get(name: string): IRichDataKind | null;
+    /** The kind of `value`, or `null` when its type is not registered. */
+    function kindOf(value: IRichData): IRichDataKind | null;
+    /** The registered names. */
+    function getNames(): string[];
+    /**
+     * A value from its JSON: the registered kind's, or an {@link Unmodeled} one carrying the JSON.
+     */
+    function fromJSON(json: IRichData.JSON): IRichData;
+    /**
+     * What `value` reads as where a primitive is consumed ({@link IRichData.toPrimitive}), or
+     * `undefined` when it reads as nothing.
+     */
+    function toPrimitive(value: IRichData): number | string | boolean | undefined;
+    /**
+     * The `ScalarType` of what `value` reads as: `String`, `Number` or `Boolean` for a kind with a
+     * primitive, `RichData` otherwise.
+     */
+    function primitiveTypeOf(value: IRichData): ScalarType;
+    /**
+     * The items `value` unpacks to where a range or array is accepted ({@link IRichData.toArray}),
+     * or `null` when it is one value.
+     */
+    function toArray(value: IRichData): Scalar[][] | null;
+    /**
+     * A value whose type nobody has registered: it carries its JSON as it was read and reads as
+     * nothing, so a workbook that holds one saves it unchanged.
+     */
+    class Unmodeled implements IRichData {
+        private readonly _json;
+        constructor(json: IRichData.JSON);
+        getType(): string;
+        getProperty(name: string): Scalar;
+        toString(): string;
+        toJSON(): IRichData.JSON;
+        get isIRichData(): true;
+    }
+}
+//# sourceMappingURL=RichDataRegistry.d.ts.map

package/types/src/richData/RichText.d.ts

@@ -0,0 +1,59 @@
+import { IRichData, Scalar } from '@sheetxl/primitives';
+import { IRichText } from '../text';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * Text with formatted runs, as a cell value.
+ *
+ * @remarks
+ * The value of a cell whose text has more than one font: `**Bold** plain`. It is text to
+ * calculation (`LEN`, `&`, comparison, `ISTEXT`, `TYPE()` 2) and formatting to the renderer, and a
+ * reference carries it whole. A run's font records only what it sets over the cell's font; the
+ * first run usually sets nothing.
+ *
+ * Immutable. Make one with {@link RichText.from} or {@link ICellRange.setRichText}; read one with
+ * {@link ICell.getRichText} or `getValue()`.
+ */
+export declare class RichText implements IRichData {
+    /** The {@link IRichData.getType} of every `RichText`. */
+    static readonly Type = "richText";
+    private readonly _runs;
+    private readonly _text;
+    /**
+     * @param runs The runs, in order. Copied and frozen; a run that sets no font is kept without one.
+     */
+    constructor(runs: readonly IRichText.RunUpdate[]);
+    /**
+     * A `RichText` from runs, from {@link IRichText.JSON}, or from plain text (one run).
+     */
+    static from(source: RichText | IRichText.Update): RichText;
+    /** From the JSON {@link toJSON} wrote. */
+    static fromJSON(json: IRichData.JSON): RichText;
+    /** {@inheritDoc IRichData.getType} */
+    getType(): string;
+    /**
+     * The runs, in order; each font is what the run sets over the cell's font.
+     */
+    getRuns(): readonly Readonly<IRichText.Run>[];
+    /**
+     * The text of every run, concatenated: what calculation reads.
+     */
+    getText(): string;
+    /**
+     * Whether any run sets a font. A `RichText` with none is plain text that happens to be held
+     * as runs.
+     */
+    isFormatted(): boolean;
+    /** {@inheritDoc IRichData.getProperty} */
+    getProperty(name: string): Scalar;
+    /** {@inheritDoc IRichData.toString} */
+    toString(): string;
+    /** {@inheritDoc IRichData.toPrimitive} */
+    toPrimitive(): string;
+    /** {@inheritDoc IRichData.toJSON} */
+    toJSON(): IRichData.JSON;
+    /** {@inheritDoc IRichData.isIRichData} */
+    get isIRichData(): true;
+}
+/** The {@link IRichDataKind} of {@link RichText}. */
+export declare const RichTextKind: IRichDataKind<RichText>;
+//# sourceMappingURL=RichText.d.ts.map

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

@@ -1 +1,4 @@
+export * from './IRichDataKind';
+export * from './RichDataRegistry';
+export * from './RichText';
 //# sourceMappingURL=index.d.ts.map

package/types/src/scripting/IModule.d.ts

@@ -1,6 +1,6 @@
 import { CompileOptions as _CompileOptions, CompileResult as _CompileResult, CompiledModule, Diagnostic as _Diagnostic } from '@sheetxl/scripting';
 import { IListener } from '../listener';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { IWorkbook } from '../workbook';
 import { IFunctionCollection } from './IFunctionCollection';
 /**
@@ -35,7 +35,7 @@ export interface IModule {
      * workbook-scoped module is unreachable from a cell formula.
      *
      * It is also **derived, not stored** — a module's scope is where it lives. A sheet's modules
-     * are reached through {@link ISheet.getModules}, and go away with the sheet; there is
+     * are reached through {@link IWorksheet.getModules}, and go away with the sheet; there is
      * deliberately no setter, because changing a module's scope would silently promote or demote
      * every function in it.
      */
@@ -90,7 +90,7 @@ export declare namespace IModule {
     /**
      * What a module is bound to: a sheet, the workbook, or `null` for global.
      */
-    type Scope = ISheet | IWorkbook | null;
+    type Scope = IWorksheet | IWorkbook | null;
     /**
      * A positioned compile diagnostic (error or warning).
      */

package/types/src/scripting/IScript.d.ts

@@ -73,7 +73,7 @@ export interface IScript {
      * {@link executeMacro}, the user-invoked path, which puts it at the selection). The entry
      * is the default export, authored as `export default function (ctx: IScript.ScriptContext) { ... }`
      * — one parameter, with the workbook as `ctx.wb`. A macro that wants "the selected" sheet/range
-     * instead takes that target first and the context second (`(sheet: ISheet, ctx)`).
+     * instead takes that target first and the context second (`(sheet: IWorksheet, ctx)`).
      * Changes are made via the workbook API in the body; observation is via `ctx.log`.
      *
      * Accepts either form of the same script:
@@ -137,7 +137,7 @@ export declare namespace IScript {
      */
     const DEFAULT_MODULE: string;
     /**
-     * Events for {@link ISheet}.
+     * Events for {@link IWorksheet}.
      */
     interface Events {
         /**

package/types/src/scripting/ITypedFunction.d.ts

@@ -18,7 +18,7 @@ export declare namespace ITypedFunction {
          * The selected sheet.
          *
          * @remarks
-         * `ISheet` will be passed as the first argument to `execute`.
+         * `IWorksheet` will be passed as the first argument to `execute`.
          */
         readonly Sheet: "sheet";
         /**

package/types/src/scripting/declarations.d.ts

@@ -18,6 +18,8 @@ export declare namespace ScriptingApi {
         /** The first sentence of the member's documentation. */
         readonly summary?: string;
         readonly deprecated?: true;
+        /** Declared for the type check but not offered: left out of listings, searches and suggestions. */
+        readonly hidden?: true;
         /** 1-based, inclusive line span in `scripting.d.ts`, documentation included. */
         readonly lines: readonly [start: number, end: number];
     }
@@ -27,6 +29,7 @@ export declare namespace ScriptingApi {
         /** The first sentence of the declaration's documentation. */
         readonly summary?: string;
         readonly deprecated?: true;
+        readonly hidden?: true;
         /** The type parameter list as written, e.g. `<T = any>`. */
         readonly typeParams?: string;
         /** The types this one extends, as written. Their members are reachable on this type too. */

package/types/src/selection/ChartElementSelection.d.ts

@@ -0,0 +1,39 @@
+import { IListener } from '../listener';
+import { IChart } from '../chart/IChart';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+import { IChartElementSelection } from './IChartElementSelection';
+import { ItemSelection } from './ItemSelection';
+/**
+ * The chart element selection of a sheet's view, or of one chart.
+ */
+export declare class ChartElementSelection extends ItemSelection<IChart.IElement> implements IChartElementSelection {
+    protected _sheet: IWorksheet | null;
+    protected _own: IChart | null;
+    /** While elements are selected, the chart's listener that drops what an edit removes. */
+    protected _chartRemoveListener: IListener.Remove | null;
+    constructor(options?: IChartElementSelection.ConstructorOptions);
+    /** {@inheritDoc IChartElementSelection.getChart} */
+    getChart(): IChart | null;
+    /** {@inheritDoc IChartElementSelection.addListeners} */
+    addListeners(listeners: IChartElementSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Empties the selection when the movable selection no longer holds its chart alone: the view
+     * calls it on every movable selection change.
+     * @internal
+     */
+    _follow(): void;
+    protected _traversal(): readonly IChart.IElement[];
+    /** The chart whose movable is the active selected movable on the sheet, if that is a chart. */
+    private _activeChartOnSheet;
+    protected _comparable(other: IItemSelection<IChart.IElement>): boolean;
+    protected _check(element: IChart.IElement): void;
+    protected _beforeSelect(picks: readonly IChart.IElement[]): void;
+    protected _afterChange(): void;
+    /** Drops the elements the chart no longer has, after an edit. */
+    private _prune;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IChartElementSelection.isIChartElementSelection} */
+    get isIChartElementSelection(): true;
+}
+//# sourceMappingURL=ChartElementSelection.d.ts.map