@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.2

package/types/src/named/NamedCollection.d.ts

@@ -1,18 +1,16 @@
+import { AbstractCollection } from '../type';
 import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ICellRanges } from '../cellRange';
 import { INamed, INamedCollection } from '../named';
-import { ListenerEmitter } from '../listener/ListenerEmitter';
 export declare const REGEX_INVALID_NAME_FIRST_CHARS: RegExp;
 export declare const REGEX_INVALID_NAME_TRAILING_CHARS: RegExp;
 /**
  * Implementation for `INamedCollection`.
  */
-export declare class NamedCollection implements INamedCollection {
-    protected _emitter: ListenerEmitter<this, INamedCollection.IListeners>;
+export declare class NamedCollection extends AbstractCollection<INamed, INamedCollection.GetItemsOptions> implements INamedCollection {
     private _options;
-    private _transactions;
-    private _closed;
+    protected _transactions: ITransaction.IStore;
     private _lastLookup;
     private _lastLookupAddress;
     private _lastLookupType;
@@ -51,10 +49,8 @@ export declare class NamedCollection implements INamedCollection {
      * the name.
      */
     private _getOwningSource;
-    /** {@inheritDoc ICollection.[Symbol.iterator]} */
-    [Symbol.iterator](): IterableIterator<INamed>;
-    /** {@inheritDoc INamedCollection.getItems} */
-    getItems(options?: INamedCollection.GetItemsOptions): INamed[];
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: INamedCollection.GetItemsOptions): INamed[];
     /** {@inheritDoc INamedCollection.getByRanges} */
     getByRanges(ranges: ICellRanges.Address, options?: INamedCollection.GetByRangesOptions): string[];
     /** {@link getByRanges}, against an explicit anchor — see {@link _scopedTo}. */
@@ -131,8 +127,6 @@ export declare class NamedCollection implements INamedCollection {
      * distinct names, so a scoped query must not report the global one as a hit.
      */
     private _findInSourcesByKey;
-    /** {@inheritDoc ICollection.getCount} */
-    getCount(): number;
     /** {@inheritDoc INamedCollection.findValidName} */
     findValidName(template: string, scope?: string | null, ignoreExisting?: boolean): string;
     /** {@inheritDoc INamedCollection.validateName} */
@@ -163,7 +157,7 @@ export declare class NamedCollection implements INamedCollection {
     private _invalidateLookup;
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: INamedCollection.IListeners, options?: IListener.Options): IListener.Remove;
-    isClosed(): boolean;
+    /** {@inheritDoc INamedCollection.close} */
     close(): void;
     /**
      * {@inheritDoc INamedCollection.isINamedCollection}
@@ -217,14 +211,21 @@ export declare namespace NamedCollection {
          */
         getItems(): readonly INamed[];
         /**
-         * Notified when items are added, removed, renamed or re-scoped.
+         * Notified when items are added, removed, renamed or re-scoped (`onCollectionChange`), and when
+         * an undo or a redo has moved them (`onInvalidated`).
          *
          * @remarks
-         * The aggregator re-emits this as its own `onCollectionChange`, which is also what drops its
-         * lookup memo — a source changing behind a cached result is otherwise invisible.
+         * The aggregator re-emits each as its own event of the same name, and either drops its lookup
+         * memo — a source changing behind a cached result is otherwise invisible.
+         *
+         * A source that has no restore of its own to report may implement only the first; one whose
+         * items are DERIVED (tables) has to report both, because an undo of a rename moves nothing this
+         * collection holds. The two stay separate all the way through: consumers of a restore and
+         * consumers of a write are not the same set.
          */
         addListeners(listeners: {
             onCollectionChange?: (...args: any[]) => void;
+            onInvalidated?: (...args: any[]) => void;
         }, options?: IListener.Options): IListener.Remove;
         /**
          * Creates a name owned by this source, if it can own one.

package/types/src/numFmt/BuiltInFormats.d.ts

@@ -20,14 +20,22 @@ export declare const FIRST_CUSTOM_FORMAT_ID = 164;
 export declare const BUILT_IN_FORMAT_CODES: Readonly<Record<number, string>>;
 /**
  * Ids whose rendering adapts to the viewer's regional settings in Excel (the
- * `*`-prefixed formats in the Format Cells dialog, currency symbol ids, and
- * the regional/CJK 27-36 & 50-58 ranges).
+ * `*`-prefixed formats in the Format Cells dialog, currency symbol ids, the
+ * date/time ids Excel renders with a per-locale pattern, and the regional/CJK
+ * 27-36 & 50-58 ranges).
  *
- * Today only 14/22 render adaptively (via the Intl interception in
- * `toLocaleDateCore`); the rest resolve to their canonical en-US codes.
- * I18N-DESIGN Plane 1 substitutes LocaleProfile-derived patterns here.
+ * The date/time ids render through {@link getLocaleBuiltInFormatCode} where a
+ * locale's pattern is known, and 14/22 fall back to `Intl` otherwise
+ * (`toLocaleDateCore`). The rest resolve to their canonical en-US codes.
  */
 export declare const LOCALE_ADAPTIVE_IDS: ReadonlySet<number>;
+/**
+ * The code a built-in id renders with in `locale`, or `undefined` when the
+ * locale is not measured or renders the canonical code.
+ *
+ * @param locale BCP-47 tag. @defaultValue 'en-US'
+ */
+export declare function getLocaleBuiltInFormatCode(id: number, locale?: string): string | undefined;
 /** The raw ECMA table lookup, or `undefined` for unknown ids. */
 export declare function getBuiltInFormatCode(id: number): string | undefined;
 /**
@@ -42,8 +50,8 @@ export declare function getBuiltInFormatCode(id: number): string | undefined;
  */
 export declare function resolveNumberFormat(ref: NumberFormatRef): string;
 /**
- * Find the built-in id for a format code (exact match, lowest id wins), or
- * `undefined` if the code is not a built-in.
+ * Find the built-in id Excel saves a format code as, or `undefined` if Excel
+ * saves it as a custom format.
  */
 export declare function findBuiltInFormatId(code: string): number | undefined;
 //# sourceMappingURL=BuiltInFormats.d.ts.map

package/types/src/numFmt/IFormatEngine.d.ts

@@ -138,6 +138,8 @@ export interface IFormatEngine {
     getFormatDateInfo(format: NumberFormatRef): FormatDateInfo | null;
     /** True if the format code parses (usable for live custom-code validation). */
     isValidFormat(format: NumberFormatRef): boolean;
+    /** For runtime type checking. */
+    readonly isIFormatEngine: true;
 }
 /**
  * The number-format engine.

package/types/src/numFmt/NumfmtFormatEngine.d.ts

@@ -29,5 +29,7 @@ export declare class NumfmtFormatEngine implements IFormatEngine {
     getFormatDateInfo(format: NumberFormatRef): FormatDateInfo | null;
     /** @inheritdoc IFormatEngine.isValidFormat */
     isValidFormat(format: NumberFormatRef): boolean;
+    /** {@inheritDoc IFormatEngine.isIFormatEngine} */
+    get isIFormatEngine(): true;
 }
 //# sourceMappingURL=NumfmtFormatEngine.d.ts.map

package/types/src/person/IPerson.d.ts

@@ -0,0 +1,99 @@
+/**
+ * A person known to the workbook: the author of a comment, or someone mentioned in one.
+ *
+ * @remarks
+ * Excel keeps these in a workbook-wide list (`xl/persons/person.xml`) and refers to each by id
+ * from every threaded comment. A legacy note names its author by display name alone; the reader
+ * mints a person for it so both kinds answer {@link IComment.getAuthor} the same way.
+ *
+ * A person is added when a comment names an author the workbook has not seen, and removed with
+ * {@link delete}; a comment whose author was removed answers `null` for them.
+ */
+export interface IPerson {
+    /**
+     * The unique identifier.
+     *
+     * @remarks
+     * A GUID in files Excel wrote; anything unique within the workbook otherwise.
+     */
+    getId(): string;
+    /**
+     * The name shown beside the person's comments.
+     */
+    getDisplayName(): string;
+    /**
+     * The id the person is known by to their identity provider, or `null` if there is none.
+     *
+     * @remarks
+     * Excel keeps an email address here for a person signed in to an organization. Nothing in
+     * SheetXL resolves it.
+     */
+    getUserId(): string | null;
+    /**
+     * The identity provider that vouches for the {@link getUserId | user id}, or `null` if there is
+     * none.
+     *
+     * @remarks
+     * Excel writes `AD` for a directory account, `Windows Live` for a personal one, and `None` for
+     * a name typed with no account behind it.
+     */
+    getProviderId(): string | null;
+    /**
+     * Removes the person from the workbook.
+     *
+     * @remarks
+     * Comments they wrote keep their text and lose their author.
+     */
+    delete(): void;
+    /**
+     * Returns `true` once the person has been removed.
+     */
+    isDeleted(): boolean;
+    /**
+     * @returns The current state as a JSON object.
+     */
+    toJSON(): IPerson.JSON;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIPerson: true;
+}
+/**
+ * {@inheritDoc IPerson}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IPerson}
+ *
+ * **Additional Interfaces**
+ * * {@link IPersonCollection}
+ */
+export declare namespace IPerson {
+    /**
+     * The values that describe a person.
+     */
+    interface Properties {
+        /**
+         * {@inheritDoc IPerson.getDisplayName}
+         */
+        displayName: string;
+        /**
+         * {@inheritDoc IPerson.getUserId}
+         */
+        userId?: string;
+        /**
+         * {@inheritDoc IPerson.getProviderId}
+         */
+        providerId?: string;
+    }
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON extends Properties {
+        /**
+         * {@inheritDoc IPerson.getId}
+         */
+        id: string;
+    }
+}
+//# sourceMappingURL=IPerson.d.ts.map

package/types/src/person/IPersonCollection.d.ts

@@ -0,0 +1,51 @@
+import { ICollection } from '../type';
+import { IPerson } from './IPerson';
+/**
+ * Holds the {@link IPerson | people} a workbook knows: everyone who authored or is mentioned in
+ * a comment.
+ *
+ * @remarks
+ * Keyed by id. Adding a person whose id, or whose display name, is already here returns the
+ * existing one rather than a second copy, which is what lets a legacy note's author (a display
+ * name with no id) and a threaded comment's author (an id) land on one person.
+ */
+export interface IPersonCollection extends ICollection<IPerson> {
+    /**
+     * Adds a person, or returns the one already here with the same id or display name.
+     *
+     * @param person The person's properties, or a display name alone.
+     */
+    add(person: IPerson.Properties | string): IPerson;
+    /**
+     * Returns the person with the given id, or `null` if there is none.
+     */
+    getById(id: string): IPerson | null;
+    /**
+     * Returns the person with the given display name, or `null` if there is none.
+     *
+     * @param displayName The display name. Case sensitive, as Excel keeps it.
+     */
+    getByDisplayName(displayName: string): IPerson | null;
+    /**
+     * The person a new comment is authored by when none is named.
+     *
+     * @remarks
+     * Excel uses the signed-in user; SheetXL has no user, so this is whoever {@link setCurrent}
+     * named, and otherwise a person called `Author`, added on first use.
+     */
+    getCurrent(): IPerson;
+    /**
+     * Names the person new comments are authored by.
+     *
+     * @param person A person, a person's properties, a display name, or `null` to forget the
+     * choice. A person not yet in the collection is added.
+     */
+    setCurrent(person: IPerson | IPerson.Properties | string | null): void;
+    /**
+     * Serializes to JSON, or `null` if there is no one to write.
+     */
+    toJSON(): IPerson.JSON[] | null;
+    /** For runtime type checking. */
+    readonly isIPersonCollection: true;
+}
+//# sourceMappingURL=IPersonCollection.d.ts.map

package/types/src/person/Person.d.ts

@@ -0,0 +1,32 @@
+import { IPerson } from './IPerson';
+/**
+ * Implementation of {@link IPerson}.
+ *
+ * @remarks
+ * Immutable: a person is never edited, only added and removed.
+ */
+export declare class Person implements IPerson {
+    private readonly _json;
+    private readonly _deleteFromCollection;
+    private _deleted;
+    constructor(json: IPerson.JSON, deleteFromCollection?: (person: Person) => void);
+    /** {@inheritDoc IPerson.getId} */
+    getId(): string;
+    /** {@inheritDoc IPerson.getDisplayName} */
+    getDisplayName(): string;
+    /** {@inheritDoc IPerson.getUserId} */
+    getUserId(): string | null;
+    /** {@inheritDoc IPerson.getProviderId} */
+    getProviderId(): string | null;
+    /** {@inheritDoc IPerson.delete} */
+    delete(): void;
+    /** {@inheritDoc IPerson.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc IPerson.toJSON} */
+    toJSON(): IPerson.JSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IPerson.isIPerson} */
+    get isIPerson(): true;
+}
+//# sourceMappingURL=Person.d.ts.map

package/types/src/person/PersonCollection.d.ts

@@ -0,0 +1,49 @@
+import { AbstractCollection } from '../type';
+import { IPerson } from './IPerson';
+import { IPersonCollection } from './IPersonCollection';
+/**
+ * The display name of the person minted when a comment is added and nobody was named.
+ *
+ * @remarks
+ * Data, not UI text: it is written into the file as the author, so it is not localized.
+ */
+export declare const DEFAULT_AUTHOR_NAME = "Author";
+/**
+ * Implementation for {@link IPersonCollection}.
+ *
+ * @remarks
+ * Not transactional: a person is added as a side effect of authoring a comment, and a removal is
+ * not something Excel offers to undo either. Announces `onCollectionChange` on each change.
+ */
+export declare class PersonCollection extends AbstractCollection<IPerson> implements IPersonCollection {
+    private _byId;
+    private _byDisplayName;
+    private _items;
+    private _current;
+    constructor(json?: IPerson.JSON[] | null);
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(): IPerson[];
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IPersonCollection.add} */
+    add(person: IPerson.Properties | string): IPerson;
+    /** {@inheritDoc IPersonCollection.getById} */
+    getById(id: string): IPerson | null;
+    /** {@inheritDoc IPersonCollection.getByDisplayName} */
+    getByDisplayName(displayName: string): IPerson | null;
+    /** {@inheritDoc IPersonCollection.getCurrent} */
+    getCurrent(): IPerson;
+    /** {@inheritDoc IPersonCollection.setCurrent} */
+    setCurrent(person: IPerson | IPerson.Properties | string | null): void;
+    /** @internal */
+    protected _remove(person: IPerson): void;
+    /** {@inheritDoc IPersonCollection.toJSON} */
+    toJSON(): IPerson.JSON[] | null;
+    /**
+     * Loads people from JSON, keeping any already here.
+     */
+    fromJSON(json: IPerson.JSON[] | null | undefined): void;
+    /** {@inheritDoc IPersonCollection.isIPersonCollection} */
+    get isIPersonCollection(): true;
+}
+//# sourceMappingURL=PersonCollection.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './IPerson';
+export * from './IPersonCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/picture/IPicture.d.ts

@@ -23,6 +23,8 @@ export interface IPicture extends IModel {
      * Returns a local object URL for placing in an image tag.
      */
     getDetails(): Promise<IPicture.Details>;
+    /** For runtime type checking. */
+    readonly isIPicture: true;
 }
 /**
  * {@inheritDoc IPicture}

package/types/src/picture/Picture.d.ts

@@ -35,6 +35,8 @@ export declare class Picture extends AbstractModel<State, IPicture.JSON> impleme
     protected _toDrawingJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
     /** @internal */
     protected _processDelete(): void;
+    /** {@inheritDoc IPicture.isIPicture} */
+    get isIPicture(): true;
 }
 /**
  * Interfaces for creating `Picture` items.

package/types/src/pivot/IPivotTable.d.ts

@@ -0,0 +1,107 @@
+import { IResource } from '../resource';
+import { ISheet } from '../sheet';
+import { IEmbeddedPart } from '../io';
+/**
+ * Interface for working with a pivot table — a summary of source data laid out on a sheet.
+ *
+ * @remarks
+ * Read-only for now: the table is carried as it was read and written back unchanged, which also
+ * means its location does not follow rows and columns that are inserted or deleted.
+ * {@link IPivotTable.getXML} is the read-only view of that markup.
+ */
+export interface IPivotTable {
+    /** @internal */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IPivotTable.JSON | null;
+    /**
+     * Returns the name of the pivot table.
+     *
+     * @remarks
+     * Unique within the workbook, as Excel keeps it.
+     */
+    getName(): string;
+    /**
+     * Returns the sheet the pivot table is laid out on.
+     */
+    getSheet(): ISheet;
+    /**
+     * Returns the pivot table's own markup, or `null` if none was captured.
+     *
+     * @remarks
+     * Read-only, and the one escape hatch for what the table does not model yet: it is the
+     * `<pivotTableDefinition>` the table was read from, not its cache. It will be removed when the
+     * table is modeled.
+     */
+    getXML(): string | null;
+    /**
+     * Returns the id of the cache this table summarizes.
+     *
+     * @see {@link IPivotTable.getCache}
+     *
+     * @internal
+     */
+    getCacheId(): number;
+    /** For runtime type checking. */
+    readonly isIPivotTable: true;
+}
+/**
+ * {@inheritDoc IPivotTable}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IPivotTable}
+ */
+export declare namespace IPivotTable {
+    /**
+     * One pivot cache — the snapshot of source data a pivot table summarizes.
+     *
+     * @remarks
+     * A cache belongs to the workbook rather than to any one sheet because it is shared: several
+     * tables can summarize the same source, and the snapshot is the expensive part, so it is held
+     * once and referenced from each table by id ({@link IPivotTable.getCacheId}).
+     *
+     * JSON only: a cache has no model and nothing public returns one — the table is the modeled side.
+     * It is carried so a workbook read with pivot tables can be written back with them; a table whose
+     * cache is missing is a file Excel refuses.
+     *
+     * @see {@link IWorkbook.JSON.pivotCaches}, which holds them.
+     */
+    interface CacheJSON {
+        /** The id the workbook's pivot tables reference this cache by. */
+        cacheId: number;
+        /**
+         * The part describing the cache: what its source is, its fields, and the records it holds.
+         *
+         * @remarks
+         * Opaque: held as it was read and written back unchanged, since the cache has no model yet.
+         */
+        part?: IEmbeddedPart.JSON;
+    }
+    interface JSON {
+        /**
+         * The name of the table.
+         *
+         * @remarks
+         * A mirror of the `name` attribute in {@link JSON.part}'s markup, which is authoritative;
+         * carried so the name is answered without reading the markup. Read from the markup once when
+         * absent.
+         *
+         * @see {@link IPivotTable.getName}
+         */
+        name?: string;
+        /**
+         * The id of the cache the table summarizes.
+         *
+         * @see {@link IPivotTable.getCacheId}
+         */
+        cacheId: number;
+        /**
+         * The part describing the table: its layout, its fields, and where it sits on the sheet.
+         *
+         * @remarks
+         * Opaque: held as it was read and written back unchanged, since the table has no model yet.
+         * {@link IPivotTable.getXML} is the readable view of it.
+         */
+        part?: IEmbeddedPart.JSON;
+    }
+}
+//# sourceMappingURL=IPivotTable.d.ts.map

package/types/src/pivot/IPivotTableCollection.d.ts

@@ -0,0 +1,25 @@
+import { ICollection } from '../type';
+import { IPivotTable } from './IPivotTable';
+/**
+ * Holds {@link IPivotTable | pivot tables} — a sheet's, or every sheet's in the workbook.
+ *
+ * @remarks
+ * Read-only for now: a table is carried as it was read and written back unchanged. Adding,
+ * deleting and refreshing wait on the table having a model of its own.
+ */
+export interface IPivotTableCollection extends ICollection<IPivotTable> {
+    /**
+     * Returns the pivot tables, in the order they were read; the workbook's walks its sheets in
+     * sheet order.
+     */
+    getItems(options?: ICollection.GetItemsOptions): IPivotTable[];
+    /**
+     * Returns the pivot table with the given name, or `null` if there is none.
+     *
+     * @param name The name of the pivot table. This is case insensitive.
+     */
+    getByName(name: string): IPivotTable | null;
+    /** For runtime type checking. */
+    readonly isIPivotTableCollection: true;
+}
+//# sourceMappingURL=IPivotTableCollection.d.ts.map

package/types/src/pivot/PivotTable.d.ts

@@ -0,0 +1,57 @@
+import { IResource } from '../resource';
+import { ISheet } from '../sheet';
+import { IEmbeddedPart } from '../io';
+import { IPivotTable } from './IPivotTable';
+/**
+ * Implementation for {@link IPivotTable}.
+ *
+ * @remarks
+ * Held as read until the table has a model of its own. Not sheet state: nothing edits it, so it
+ * neither transacts nor notifies.
+ *
+ * @internal
+ */
+export declare class PivotTable implements IPivotTable {
+    protected _name: string | null;
+    protected _sheet: ISheet;
+    protected _cacheId: number;
+    protected _part: IEmbeddedPart | null;
+    constructor(options: PivotTable.ConstructorOptions);
+    /** {@inheritDoc IPivotTable.getName} */
+    getName(): string;
+    /** {@inheritDoc IPivotTable.getSheet} */
+    getSheet(): ISheet;
+    /** {@inheritDoc IPivotTable.getXML} */
+    getXML(): string | null;
+    /** {@inheritDoc IPivotTable.getCacheId} */
+    getCacheId(): number;
+    /** {@inheritDoc IPivotTable.toJSON} */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IPivotTable.JSON | null;
+    /** {@inheritDoc IPivotTable.isIPivotTable} */
+    get isIPivotTable(): true;
+}
+/**
+ * Interfaces for creating `PivotTable` items.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link PivotTable}
+ */
+export declare namespace PivotTable {
+    /**
+     * Options for creating a PivotTable.
+     */
+    interface ConstructorOptions {
+        json: IPivotTable.JSON;
+        /**
+         * The sheet the table is laid out on.
+         */
+        sheet: ISheet;
+        /**
+         * Returns an IResource from the resourceId or null if not found.
+         */
+        fromResourceId?: (resourceId: number) => IResource;
+    }
+}
+//# sourceMappingURL=PivotTable.d.ts.map

package/types/src/pivot/PivotTableCollection.d.ts

@@ -0,0 +1,25 @@
+import { AbstractCollection } from '../type';
+import { IPivotTable } from './IPivotTable';
+import { IPivotTableCollection } from './IPivotTableCollection';
+/**
+ * Implementation for {@link IPivotTableCollection}.
+ *
+ * @remarks
+ * A front over storage held elsewhere — the sheet's own tables, or a walk over every sheet's for
+ * the workbook — so the same class serves both. Nothing edits a pivot table yet, so there is
+ * nothing to announce.
+ */
+export declare class PivotTableCollection extends AbstractCollection<IPivotTable> implements IPivotTableCollection {
+    private _getItemsDelegate;
+    /**
+     * @param getItems Returns the tables, as an array the caller may keep.
+     */
+    constructor(getItems: () => IPivotTable[]);
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(): IPivotTable[];
+    /** {@inheritDoc IPivotTableCollection.getByName} */
+    getByName(name: string): IPivotTable | null;
+    /** {@inheritDoc IPivotTableCollection.isIPivotTableCollection} */
+    get isIPivotTableCollection(): true;
+}
+//# sourceMappingURL=PivotTableCollection.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * @hidden
+ */
+export * from './IPivotTable';
+export * from './IPivotTableCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/primitives/CompositeRangeStats.d.ts

@@ -24,6 +24,8 @@ export declare class CompositeRangeStats implements IRangeStats {
     protected _typedCounts: Readonly<Record<ScalarType, number>> | undefined;
     protected _frequencies: Readonly<IRangeStats.IFrequency> | undefined;
     constructor(children: readonly IRangeStats[]);
+    /** @inheritdoc IRangeStats.getCoords */
+    getCoords(): IRange.Coords | null;
     /** @inheritdoc IRangeStats.getSize */
     getSize(): number;
     /** @inheritdoc IRangeStats.getCount */

package/types/src/primitives/Criteria.d.ts

@@ -30,6 +30,6 @@ export declare const Criteria: {
      * Parse criteria and return a predicate function for testing values against it.
      * Each operator gets its own closure, avoiding repeated branching on every call.
      */
-    createEvaluator: (context: IFormulaContext, criteria: Scalar) => IFormulaContext.CriteriaEvaluator;
+    createEvaluator: (context: IFormulaContext, criteria: Scalar, options?: IFormulaContext.CriteriaOptions) => IFormulaContext.CriteriaEvaluator;
 };
 //# sourceMappingURL=Criteria.d.ts.map

package/types/src/primitives/LambdaBrand.d.ts

@@ -0,0 +1,21 @@
+import { LambdaCallable } from '../calculation/formula/LambdaValue';
+/**
+ * The brand a function value carries — what `LAMBDA(…)` evaluates to (`LambdaValue`) and what a
+ * bare function name eta-reduces to (`FunctionValue`).
+ *
+ * @remarks
+ * CALCULATION-PRIVATE, like the values it brands: no public API accepts or returns one, and a
+ * function author never sees one — a lambda-typed parameter is marshalled to a plain callable
+ * (`Lambda`) before the body runs. The brand exists so that the value-layer sites — coercion, the
+ * operators, a range's typed read — can RECOGNIZE a function value and refuse it without importing
+ * the calculation layer — the same structural pattern, and for the same reason, as `CalcSignal`.
+ */
+export interface ILambdaValue {
+    /** The brand itself — the property every recognizing site reads. */
+    readonly isLambda: true;
+    /** Marshals the value into the callable a lambda-typed parameter receives. */
+    makeCallable(): LambdaCallable;
+}
+/** `true` for a function value — see {@link ILambdaValue}. */
+export declare const isLambdaValue: (value: unknown) => value is ILambdaValue;
+//# sourceMappingURL=LambdaBrand.d.ts.map