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

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

@@ -0,0 +1,66 @@
+import { IRichData, IRichMeta, IRichType } from '@sheetxl/primitives';
+import { IResource, IResourceCollection } from '../resource';
+import { IStringCollection } from '../string';
+/**
+ * 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
+ * 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.
+ *
+ * Make one with {@link IRichDataKind.create}; register it with {@link RichDataRegistry.register}.
+ */
+export interface IRichDataKind<T extends IRichData = IRichData> extends IRichType {
+    /**
+     * 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.
+     */
+    fromJSON(json: IRichData.JSON, ctx: IRichDataKind.Context): T;
+}
+export declare namespace IRichDataKind {
+    /**
+     * What a kind can reach while making a value.
+     */
+    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

@@ -0,0 +1,89 @@
+import { IRichData, IRichType, Scalar, ScalarType } from '@sheetxl/primitives';
+import { IRichDataKind } from './IRichDataKind';
+/**
+ * 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
+ * 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,
+     * a built-in included.
+     */
+    function register(kind: IRichDataKind<any>): void;
+    /**
+     * 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 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, 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): 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 `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`, `Boolean` or `Error` 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 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);
+        getKind(): IRichType;
+        getProperty(name: string): Scalar;
+        toString(): string;
+        toJSON(): IRichData.JSON;
+        get isIRichData(): true;
+    }
+}
+//# sourceMappingURL=RichDataRegistry.d.ts.map

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

@@ -0,0 +1,59 @@
+import { IRichData, IRichType, 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 name of the kind of every `RichText` ({@link RichTextKind}). */
+    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.getKind} */
+    getKind(): IRichType;
+    /**
+     * 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,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;

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/Scripts.d.ts

@@ -12,6 +12,8 @@ export declare class Scripts implements IScript {
     private _modules;
     /** In-flight {@link start} run, so concurrent callers share one attempt (and one error). */
     private _startPromise?;
+    /** In-flight {@link _load} run, shared the same way. */
+    private _loadPromise?;
     protected _emitter: ListenerEmitter<IScript, IScript.IListeners>;
     constructor(options: Scripts.ConstructorOptions);
     protected _initState(): void;
@@ -49,7 +51,15 @@ export declare class Scripts implements IScript {
     searchFunctions(options?: IScript.SearchOptions): Promise<IFunction[]>;
     /** {@inheritDoc IScript.start} */
     start(): Promise<void>;
+    /**
+     * Builds the modules from the file without running anything in them: what the calculation's
+     * first pass needs (their formula functions), ahead of {@link start}, which also runs the
+     * `autoRun` functions and so belongs after it.
+     * @internal
+     */
+    _load(): Promise<void>;
     private _doStart;
+    private _doLoad;
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: IScript.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc IScript.isReadOnly} */

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

@@ -205,6 +205,8 @@ export declare class TypedFunction implements IFunction {
      * parameter is the same thing to a body asking which parameter its argument landed in.
      */
     protected _va: number;
+    /** The declaration's `volatile`, read once: what the call frame carries for `defer`. */
+    protected _vol: boolean;
     /** Resolved {@link RepeatPlan} per argument count (`null` = an arity the declaration refuses). */
     protected _gc: Map<number, RepeatPlan | null> | null;
     /** The name's argument ceiling — {@link IFunction.IDeclaration.getMaxArguments}, cached. */

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