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

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

@@ -0,0 +1,95 @@
+import { IRichData, IRichType, Scalar } from '@sheetxl/primitives';
+import { IResource } from '../resource';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * A picture as a cell value: what `IMAGE()` returns.
+ *
+ * @remarks
+ * It reads as nothing where a primitive is needed, so `LEN`, `&` and `+` over it are `#VALUE!`,
+ * and a reference carries it whole: `=A1` over an image is the image.
+ *
+ * It holds where the picture comes from and, once they are in, the resource holding its bytes:
+ * `IMAGE` adds the picture it fetched, and a picture placed in a cell brings its own. The workbook
+ * saves a resource while a value holds it. A value with no resource fetches its source to draw.
+ *
+ * Immutable.
+ */
+export declare class CellImage implements IRichData {
+    /** The name of the kind of every `CellImage` ({@link CellImageKind}). */
+    static readonly Type = "image";
+    private readonly _source;
+    private readonly _altText;
+    private readonly _sizing;
+    private readonly _height;
+    private readonly _width;
+    private readonly _resource;
+    /**
+     * @param source Where the picture comes from: a URL.
+     */
+    constructor(source: string, options?: CellImage.Options);
+    /** {@inheritDoc IRichData.getKind} */
+    getKind(): IRichType;
+    /** Where the picture comes from. */
+    getSource(): string;
+    /** The text that describes the picture, for accessibility, or `null`. */
+    getAltText(): string | null;
+    /** How the picture is sized in its cell. */
+    getSizing(): CellImage.Sizing;
+    /** The height in pixels for {@link CellImage.Sizing.Custom}, or `null`. */
+    getHeight(): number | null;
+    /** The width in pixels for {@link CellImage.Sizing.Custom}, or `null`. */
+    getWidth(): number | null;
+    /** {@inheritDoc IRichData.getProperty} */
+    getProperty(_name: string): Scalar;
+    /** {@inheritDoc IRichData.toString} */
+    toString(): string;
+    /** The resource holding the picture's bytes, or `null` when it has none and fetches its source. */
+    getResource(): IResource | null;
+    /** {@inheritDoc IRichData.toJSON} */
+    toJSON(toResourceId?: IRichData.ToResourceId): IRichData.JSON;
+    /** {@inheritDoc IRichData.isIRichData} */
+    get isIRichData(): true;
+}
+export declare namespace CellImage {
+    /**
+     * How a picture sits in its cell: `IMAGE()`'s `sizing` argument.
+     */
+    const Sizing: {
+        /** Fits inside the cell, keeping its aspect ratio. */
+        readonly Fit: 0;
+        /** Fills the cell, ignoring its aspect ratio. */
+        readonly Fill: 1;
+        /** At its own size, which may overflow the cell. */
+        readonly Original: 2;
+        /** At the height and width given. */
+        readonly Custom: 3;
+    };
+    type Sizing = typeof Sizing[keyof typeof Sizing];
+    /** What an image holds besides its source. */
+    interface Options {
+        altText?: string | null;
+        sizing?: Sizing;
+        height?: number | null;
+        width?: number | null;
+        /** The resource holding the picture's bytes. */
+        resource?: IResource | null;
+    }
+    /** The `data` of an image's JSON. */
+    interface Data {
+        source: string;
+        altText?: string;
+        sizing?: Sizing;
+        height?: number;
+        width?: number;
+        /** The resource holding the picture's bytes, by the id the file gave it. */
+        resId?: number;
+        /**
+         * The resource itself, in place of `resId`, where a value is made in memory rather than read
+         * (`createRichData`, `setValue`).
+         */
+        resource?: IResource;
+    }
+}
+/** The {@link IRichDataKind} of {@link CellImage}. */
+export declare const CellImageKind: IRichDataKind<CellImage>;
+//# sourceMappingURL=CellImage.d.ts.map

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

@@ -0,0 +1,49 @@
+import { IRichData, IRichType, Scalar } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * A link as a cell value: what `HYPERLINK()` returns.
+ *
+ * @remarks
+ * It reads as its friendly name, or as its address when it has none, so `LEN`, `&` and comparison
+ * see the text a user sees. A reference carries it whole, so `=A1` and `IF(c, HYPERLINK(...), "")`
+ * are links too.
+ *
+ * This is the link a cell's value is. The link a cell carries beside its value is
+ * {@link ICell.getHyperlink}; a cell may have both.
+ *
+ * Immutable.
+ */
+export declare class Hyperlink implements IRichData {
+    /** The name of the kind of every `Hyperlink` ({@link HyperlinkKind}). */
+    static readonly Type = "hyperlink";
+    private readonly _address;
+    private readonly _friendly;
+    /**
+     * @param address Where the link goes: a URL, a file path, or a location in the workbook
+     * (`#Sheet1!A1`). `null` when it is not known until the formula that made the link
+     * recalculates (a link read from a file whose address is computed).
+     * @param friendly What the cell shows. Omitted, the address.
+     */
+    constructor(address: string | null, friendly?: string | number | boolean | null);
+    /** From the JSON {@link toJSON} wrote. */
+    static fromJSON(json: IRichData.JSON): Hyperlink;
+    /** {@inheritDoc IRichData.getKind} */
+    getKind(): IRichType;
+    /** Where the link goes, or `null` when that is not known yet: the link goes nowhere. */
+    getAddress(): string | null;
+    /** What the cell shows, or `null` when it shows the address. */
+    getFriendlyName(): string | number | boolean | null;
+    /** {@inheritDoc IRichData.getProperty} */
+    getProperty(_name: string): Scalar;
+    /** {@inheritDoc IRichData.toString} */
+    toString(): string;
+    /** {@inheritDoc IRichData.toPrimitive} */
+    toPrimitive(): string | number | boolean;
+    /** {@inheritDoc IRichData.toJSON} */
+    toJSON(): IRichData.JSON;
+    /** {@inheritDoc IRichData.isIRichData} */
+    get isIRichData(): true;
+}
+/** The {@link IRichDataKind} of {@link Hyperlink}. */
+export declare const HyperlinkKind: IRichDataKind<Hyperlink>;
+//# sourceMappingURL=Hyperlink.d.ts.map

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

@@ -0,0 +1,76 @@
+import { IRichData, IRichType } from '@sheetxl/primitives';
+import { ICollection } from '../type';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * The rich values a workbook's cells hold, interned: a cell run stores a rich value as its id here,
+ * as it stores a string as its id in the string collection.
+ *
+ * @remarks
+ * Equal values share one id (equal JSON; a resource counts by identity), so recalculating a
+ * formula that makes a new but equal value adds nothing. Values are not removed: a save writes only
+ * the ones a cell holds.
+ */
+export interface IRichDataCollection extends ICollection<IRichData> {
+    /**
+     * The id of `value`, added when no equal value is here.
+     *
+     * @param value A rich value. Never an error: an error is stored by its code.
+     */
+    add(value: IRichData): number;
+    /**
+     * The value for an id, or `null` if not found.
+     *
+     * @param id The id {@link add} answered.
+     */
+    getById(id: number): IRichData | null;
+    /**
+     * Starts saving or loading the rich values cells name. Scopes begun while one is open share its
+     * ids, so a workbook and its sheets agree on them.
+     */
+    beginPersist(): IRichDataCollection.IPersistScope;
+    /** For runtime type checking. */
+    readonly isIRichDataCollection: true;
+}
+/**
+ * {@inheritDoc IRichDataCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IRichDataCollection}
+ */
+export declare namespace IRichDataCollection {
+    /** A saved rich value: its kind's JSON. */
+    type JSON = IRichData.JSON;
+    /**
+     * One save or load of the rich values cells name. Ids are positions in the saved table, not the
+     * collection's own.
+     */
+    interface IPersistScope {
+        /** The saved id of `value`, added to the table when new. */
+        add(value: IRichData): number;
+        /** The value a loaded id names, or `null`. */
+        at(id: number): IRichData | null;
+        /**
+         * Loads a saved table: each entry made by its kind, its ids then answered by {@link at}.
+         *
+         * @param ctx What the values are made for: the workbook's resources, and the file's resource ids.
+         * @param kinds The kinds saved with the table ({@link toKindsJSON}), made before the values
+         * that name them.
+         */
+        fromJSON(json: readonly JSON[] | undefined, ctx: IRichDataKind.Context, kinds?: readonly IRichType.JSON[]): void;
+        /**
+         * The table, in id order.
+         *
+         * @param toResourceId The saved id of a resource a value holds.
+         */
+        toJSONAsync(toResourceId?: IRichData.ToResourceId): Promise<JSON[]>;
+        /**
+         * The kinds the table's values name, nested values included, that are not registered in code
+         * and so are saved with it.
+         */
+        toKindsJSON(): IRichType.JSON[];
+        /** Ends the scope. The last to end lets the table go. */
+        endPersist(): void;
+    }
+}
+//# sourceMappingURL=IRichDataCollection.d.ts.map

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

@@ -1,22 +1,66 @@
-import { IRichData } from '@sheetxl/primitives';
+import { IRichData, IRichMeta, IRichType } from '@sheetxl/primitives';
+import { IResource, IResourceCollection } from '../resource';
+import { IStringCollection } from '../string';
 /**
- * A registered kind of rich data: its name, and how a value of it is made from its JSON.
+ * A registered kind of rich data: the {@link IRichType} its values return from `getKind()`, 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.
+ * 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
+ * describes values and makes them.
  *
- * Register a kind with {@link RichDataRegistry.register}.
+ * Make one with {@link IRichDataKind.create}; register it with {@link RichDataRegistry.register}.
  */
-export interface IRichDataKind<T extends IRichData = IRichData> {
+export interface IRichDataKind<T extends IRichData = IRichData> extends IRichType {
     /**
-     * The kind's name, the `type` of its values and their JSON.
+     * A value from its JSON, as {@link IRichData.toJSON} wrote it.
+     *
+     * @param ctx What the value is being made for. Every value is made here, whether it is loaded,
+     * written with `setValue`, or returned by a function. `{ type }` alone asks for the kind's
+     * default value, which is what a UI inserts.
      */
-    readonly name: string;
+    fromJSON(json: IRichData.JSON, ctx: IRichDataKind.Context): T;
+}
+export declare namespace IRichDataKind {
     /**
-     * A value from its JSON, as {@link IRichData.toJSON} wrote it.
+     * What a kind can reach while making a value.
      */
-    fromJSON(json: IRichData.JSON): T;
+    interface Context {
+        /**
+         * Binary resources (image bytes) by id, the store pictures use. `null` when the value is
+         * made outside a workbook, as an external link's cached values are.
+         */
+        readonly resources: IResourceCollection | null;
+        /**
+         * The string table the value's cells share. `null` outside a workbook.
+         */
+        readonly strings: IStringCollection | null;
+        /**
+         * The resource a value's JSON names by id, while a file is being read: the id
+         * `IRichData.toJSON`'s `toResourceId` gave it. `null` for an id the file does not hold, and
+         * always outside a read.
+         */
+        fromResourceId?(id: number): IResource | null;
+    }
+    /** A context with nothing to reach: a value made outside any workbook. */
+    const DetachedContext: Context;
+    /** What {@link create} makes a kind from. */
+    interface Definition<T extends IRichData = IRichData> {
+        /** {@inheritDoc IRichType.getName} */
+        name: string;
+        /** {@inheritDoc IRichType.getLabel} */
+        label?: string;
+        /** {@inheritDoc IRichType.getProperties} */
+        properties?: readonly IRichType.Property[];
+        /** {@inheritDoc IRichType.getDisplayProperty} */
+        displayProperty?: string | null;
+        /** {@inheritDoc IRichType.getMeta} */
+        meta?: IRichMeta | null;
+        /** {@inheritDoc IRichDataKind.fromJSON} */
+        fromJSON(json: IRichData.JSON, ctx: Context): T;
+    }
+    /** A kind from its definition. The kind is immutable. */
+    function create<T extends IRichData>(definition: Definition<T>): IRichDataKind<T>;
 }
 //# sourceMappingURL=IRichDataKind.d.ts.map

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

@@ -0,0 +1,42 @@
+import { IRichData, IRichType, Scalar } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * An array as one value: what an entity's list property holds ("Leader(s)", "Official
+ * language"), and what a cell holding a list holds.
+ *
+ * @remarks
+ * Its elements are rows of values, any of them rich. It unpacks to them where a range or array is
+ * accepted ({@link IRichData.toArray}) and reads as nothing where a primitive is.
+ *
+ * Immutable.
+ */
+export declare class RichArray implements IRichData {
+    /** The name of the kind of every `RichArray` ({@link RichArrayKind}). */
+    static readonly Type = "array";
+    private readonly _elements;
+    /**
+     * @param elements The rows. Each row is copied; ragged rows are kept as given.
+     */
+    constructor(elements: readonly (readonly Scalar[])[]);
+    /** From the JSON {@link toJSON} wrote; nested values are made by their kinds. */
+    static fromJSON(json: IRichData.JSON, ctx: IRichDataKind.Context): RichArray;
+    /** {@inheritDoc IRichData.getKind} */
+    getKind(): IRichType;
+    /** The rows. */
+    getElements(): readonly (readonly Scalar[])[];
+    /** The values the array holds, for walks over nested values. @internal */
+    getNestedValues(): readonly Scalar[];
+    /** {@inheritDoc IRichData.getProperty} */
+    getProperty(_name: string): Scalar;
+    /** {@inheritDoc IRichData.toArray} */
+    toArray(): Scalar[][];
+    /** {@inheritDoc IRichData.toString} */
+    toString(): string;
+    /** {@inheritDoc IRichData.toJSON} */
+    toJSON(toResourceId?: IRichData.ToResourceId): IRichData.JSON;
+    /** {@inheritDoc IRichData.isIRichData} */
+    get isIRichData(): true;
+}
+/** The {@link IRichDataKind} of {@link RichArray}. */
+export declare const RichArrayKind: IRichDataKind<RichArray>;
+//# sourceMappingURL=RichArray.d.ts.map

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

@@ -0,0 +1,23 @@
+import { IRichData } from '@sheetxl/primitives';
+import { AbstractCollection } from '../type';
+import { IRichDataCollection } from './IRichDataCollection';
+export declare class RichDataCollection extends AbstractCollection<IRichData> implements IRichDataCollection {
+    private readonly _byId;
+    /** By instance first: one lookup for the cells that share a value. Weak, so a replaced value goes. */
+    private readonly _byInstance;
+    private readonly _byKey;
+    private _persist;
+    /** {@inheritDoc IRichDataCollection.add} */
+    add(value: IRichData): number;
+    /** {@inheritDoc IRichDataCollection.getById} */
+    getById(id: number): IRichData | null;
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(): IRichData[];
+    /** {@inheritDoc IRichDataCollection.beginPersist} */
+    beginPersist(): IRichDataCollection.IPersistScope;
+    /** {@inheritDoc IRichDataCollection.isIRichDataCollection} */
+    get isIRichDataCollection(): true;
+}
+//# sourceMappingURL=RichDataCollection.d.ts.map

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

@@ -1,7 +1,7 @@
-import { IRichData, Scalar, ScalarType } from '@sheetxl/primitives';
+import { IRichData, IRichType, Scalar, ScalarType } from '@sheetxl/primitives';
 import { IRichDataKind } from './IRichDataKind';
 /**
- * The kinds of rich data a cell can hold, by name.
+ * The kinds of rich data a cell can hold, by type.
  *
  * @remarks
  * A value is made from its JSON by looking its `type` up here; what a value reads as where a
@@ -12,27 +12,60 @@ import { IRichDataKind } from './IRichDataKind';
  */
 export declare namespace RichDataRegistry {
     /**
-     * Registers a kind. A kind registered again under the same name replaces the earlier one.
+     * Registers a kind. A kind registered again under the same name replaces the earlier one,
+     * a built-in included.
      */
     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. */
+    /**
+     * The kind named `type`: registered, or defined ({@link RichRecord.defineKind}); `null` when
+     * there is none.
+     */
+    function get(type: string): IRichDataKind | null;
+    /** The kind of `value`, registered or defined, or `null` when it is neither. */
     function kindOf(value: IRichData): IRichDataKind | null;
-    /** The registered names. */
-    function getNames(): string[];
+    /** The names of the registered kinds. */
+    function getTypes(): string[];
     /**
      * A value from its JSON: the registered kind's, or an {@link Unmodeled} one carrying the JSON.
+     *
+     * @param ctx What the value is made for; omitted, a value made outside any workbook.
      */
-    function fromJSON(json: IRichData.JSON): IRichData;
+    function fromJSON(json: IRichData.JSON, ctx?: IRichDataKind.Context): IRichData;
+    /**
+     * Whether `value` is the JSON of a rich value (`{ type, data? }`), as `setValue` accepts it
+     * in place of the value.
+     */
+    function isJSON(value: unknown): value is IRichData.JSON;
     /**
      * 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;
+    function toPrimitive(value: IRichData): Exclude<Scalar, IRichData | null> | undefined;
+    /**
+     * The text `value` shows in a cell when it reads as no primitive: the value of its kind's
+     * display property ({@link IRichType.getDisplayProperty}), or `null` when the kind names none or
+     * the value holds no text there.
+     *
+     * @remarks
+     * Display only: the value still reads as nothing to calculation.
+     */
+    function toDisplayText(value: IRichData): string | null;
+    /**
+     * The text that stands for `value` as a whole, as in the formula bar: its display text
+     * ({@link toDisplayText}), else the label its kind was given in parentheses, `(Image)`, else
+     * `(Rich Object)`.
+     */
+    function toPlaceholderText(value: IRichData): string;
+    /**
+     * The `ScalarType` `value` lays out as in a cell: its primitive's when it has one (a hyperlink
+     * named by a number is a number); `String` when it reads as nothing but shows text (an entity's
+     * display string), so it aligns left and spills into empty neighbors; `RichData` when it shows
+     * no text (a picture).
+     */
+    function layoutTypeOf(value: IRichData): ScalarType;
     /**
-     * The `ScalarType` of what `value` reads as: `String`, `Number` or `Boolean` for a kind with a
-     * primitive, `RichData` otherwise.
+     * The `ScalarType` of what `value` reads as: `String`, `Number`, `Boolean` or `Error` for a
+     * kind with a primitive, `RichData` otherwise.
      */
     function primitiveTypeOf(value: IRichData): ScalarType;
     /**
@@ -41,13 +74,18 @@ export declare namespace RichDataRegistry {
      */
     function toArray(value: IRichData): Scalar[][] | null;
     /**
-     * A value whose type nobody has registered: it carries its JSON as it was read and reads as
+     * A value whose kind nobody has registered: it carries its JSON as it was read and reads as
      * nothing, so a workbook that holds one saves it unchanged.
+     *
+     * @remarks
+     * Its kind is made from what it holds: named by its JSON's `type`, with a property for each
+     * entry of its data.
      */
     class Unmodeled implements IRichData {
         private readonly _json;
+        private _kind;
         constructor(json: IRichData.JSON);
-        getType(): string;
+        getKind(): IRichType;
         getProperty(name: string): Scalar;
         toString(): string;
         toJSON(): IRichData.JSON;

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

@@ -0,0 +1,20 @@
+import { IRichData, Scalar } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * A value held inside a rich value (a property, an array element) as JSON, and back.
+ *
+ * @remarks
+ * A primitive is itself; an error is `{ e: code }`; a rich value is its JSON (`{ type, data }`),
+ * made again by its kind.
+ *
+ * @internal
+ */
+export declare namespace RichDataValues {
+    /** `value` as JSON. A rich value whose JSON is only available asynchronously is `null`. */
+    function toJSON(value: Scalar, toResourceId?: IRichData.ToResourceId): unknown;
+    /** The value `json` is, as {@link toJSON} wrote it. */
+    function fromJSON(json: unknown, ctx: IRichDataKind.Context): Scalar;
+    /** Every rich value `value` holds, itself included, depth first. */
+    function forEachRich(value: Scalar, visit: (rich: IRichData) => void): void;
+}
+//# sourceMappingURL=RichDataValues.d.ts.map

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

@@ -0,0 +1,68 @@
+import { IRichData, IRichMeta, IRichType, Scalar } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/** A kind's definition without its name: what the name is made from. */
+type Content = Omit<IRichType.JSON, 'name'>;
+/**
+ * A value of a kind with no code of its own: a record of properties its kind declares, such as an
+ * entity read from a file (a stock, a country).
+ *
+ * @remarks
+ * It reads as nothing where a primitive is consumed and shows its kind's display property. A
+ * property it holds no value for reads as the kind's default. Its presentation per property is its
+ * own where it differs from its kind's ({@link getPropertyMeta}).
+ *
+ * Immutable. Make its kind with {@link RichRecord.defineKind}.
+ */
+export declare class RichRecord implements IRichData {
+    private readonly _kind;
+    private readonly _values;
+    private readonly _meta;
+    /**
+     * @param kind The record's kind, from {@link RichRecord.defineKind}.
+     * @param values The values it holds, by property name.
+     * @param meta Presentation for the properties where it differs from its kind, by property name.
+     */
+    constructor(kind: IRichDataKind<RichRecord>, values: Readonly<Record<string, Scalar>>, meta?: Readonly<Record<string, IRichMeta>> | null);
+    /** {@inheritDoc IRichData.getKind} */
+    getKind(): IRichType;
+    /** {@inheritDoc IRichData.getProperty} */
+    getProperty(name: string): Scalar;
+    /** {@inheritDoc IRichData.getPropertyMeta} */
+    getPropertyMeta(name: string): IRichMeta | null;
+    /** The values the record holds, by property name: not its kind's defaults. */
+    getValues(): Readonly<Record<string, Scalar>>;
+    /** The presentation the record gives its own properties, by property name, or `null`. */
+    getOwnMeta(): Readonly<Record<string, IRichMeta>> | null;
+    /** The values the record holds, for walks over nested values. @internal */
+    getNestedValues(): readonly Scalar[];
+    /** {@inheritDoc IRichData.toString} */
+    toString(): string;
+    /** {@inheritDoc IRichData.toJSON} */
+    toJSON(toResourceId?: IRichData.ToResourceId): IRichData.JSON;
+    /** {@inheritDoc IRichData.isIRichData} */
+    get isIRichData(): true;
+}
+/**
+ * {@inheritDoc RichRecord}
+ */
+export declare namespace RichRecord {
+    /**
+     * The kind for a definition, named `base:digest`: the digest is of the whole definition, so the
+     * same definition gets the same kind, and the same name, in every workbook and session.
+     *
+     * @param base What the name starts with: a family of kinds, such as where they come from.
+     * @param definition The kind's properties and presentation.
+     */
+    function defineKind(base: string, definition: Content): IRichDataKind<RichRecord>;
+    /**
+     * The kind a saved definition names. A definition saved by {@link toKindJSON} gives back the same
+     * kind as the one it was saved from.
+     */
+    function kindFromJSON(json: IRichType.JSON): IRichDataKind<RichRecord>;
+    /** The defined kind named `name`, or `null`. */
+    function getDefinedKind(name: string): IRichDataKind<RichRecord> | null;
+    /** The definition to save for `kind`, or `null` when it is not a defined kind. */
+    function toKindJSON(kind: IRichType): IRichType.JSON | null;
+}
+export {};
+//# sourceMappingURL=RichRecord.d.ts.map

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

@@ -1,4 +1,4 @@
-import { IRichData, Scalar } from '@sheetxl/primitives';
+import { IRichData, IRichType, Scalar } from '@sheetxl/primitives';
 import { IRichText } from '../text';
 import { IRichDataKind } from './IRichDataKind';
 /**
@@ -14,7 +14,7 @@ import { IRichDataKind } from './IRichDataKind';
  * {@link ICell.getRichText} or `getValue()`.
  */
 export declare class RichText implements IRichData {
-    /** The {@link IRichData.getType} of every `RichText`. */
+    /** The name of the kind of every `RichText` ({@link RichTextKind}). */
     static readonly Type = "richText";
     private readonly _runs;
     private readonly _text;
@@ -28,8 +28,8 @@ export declare class RichText implements IRichData {
     static from(source: RichText | IRichText.Update): RichText;
     /** From the JSON {@link toJSON} wrote. */
     static fromJSON(json: IRichData.JSON): RichText;
-    /** {@inheritDoc IRichData.getType} */
-    getType(): string;
+    /** {@inheritDoc IRichData.getKind} */
+    getKind(): IRichType;
     /**
      * The runs, in order; each font is what the run sets over the cell's font.
      */
@@ -44,7 +44,7 @@ export declare class RichText implements IRichData {
      */
     isFormatted(): boolean;
     /** {@inheritDoc IRichData.getProperty} */
-    getProperty(name: string): Scalar;
+    getProperty(_name: string): Scalar;
     /** {@inheritDoc IRichData.toString} */
     toString(): string;
     /** {@inheritDoc IRichData.toPrimitive} */

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

@@ -1,4 +1,10 @@
 export * from './IRichDataKind';
+export * from './IRichDataCollection';
+export * from './RichDataCollection';
 export * from './RichDataRegistry';
 export * from './RichText';
+export * from './Hyperlink';
+export * from './CellImage';
+export * from './RichArray';
+export * from './RichRecord';
 //# sourceMappingURL=index.d.ts.map

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

@@ -11,12 +11,28 @@ export interface IArgumentsFrame extends IFunctionArguments {
     _setLiftValues(values: any[] | null): void;
     /** @see FunctionArguments._setPrivateArgs */
     _setPrivateArgs(args: any[]): void;
+    /** @see FunctionArguments._takeServed */
+    _takeServed(): unknown;
 }
 /**
  * Binds the view for a call about to dispatch, and returns it so the lift can point it at its
  * per-cell arguments. Pairs with {@link popArguments} in a `finally`.
  */
-export declare const pushArguments: (params: IFunction.ParameterTypeJSON[] | null | undefined, variadic: number, suffix: number, args: any[], argsLength: number) => IArgumentsFrame;
+export declare const pushArguments: (params: IFunction.ParameterTypeJSON[] | null | undefined, variadic: number, suffix: number, args: any[], argsLength: number, volatile?: boolean) => IArgumentsFrame;
 /** Ends the call {@link pushArguments} began. */
 export declare const popArguments: () => void;
+/**
+ * The declaration of the innermost dispatching call — one object per registered function, so it
+ * tells which function is running without the dispatch recording anything — or `null`.
+ */
+export declare const currentDeclaration: () => object | null;
+/** Whether the innermost dispatching call's function declares itself volatile; `false` outside one. */
+export declare const currentIsVolatile: () => boolean;
+/**
+ * Tells the innermost dispatching call's frame that its body deferred, and which call it was
+ * served (`null` for a new one): what a lift reads back per member (`_takeServed`).
+ */
+export declare const noteServed: (served: {
+    readonly latest: unknown;
+} | null) => void;
 //# sourceMappingURL=FunctionArguments.d.ts.map

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

@@ -22,6 +22,7 @@ export declare class FunctionCollection extends AbstractCollection<IFunction, IF
     private _index;
     /** The read-only and own functions, by name. Dropped with {@link _index}. */
     private _sorted;
+    private _stamp;
     constructor(options: ConstructorOptions);
     /** {@inheritDoc AbstractCollection._getItems} */
     protected _getItems(options?: IFunctionCollection.GetItemsOptions): IFunction[];
@@ -79,6 +80,13 @@ export declare class FunctionCollection extends AbstractCollection<IFunction, IF
     beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
     /** Drops everything derived from the collection's contents. */
     private _invalidate;
+    /**
+     * @hidden
+     * Changes whenever {@link getByName} could answer differently for a registered function, and is
+     * unique across collections: a caller holding a resolved function may keep it while the stamp it
+     * resolved under is still current.
+     */
+    _getStamp(): number;
     private _getState;
     private _beginCommit;
     private _updateState;