@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

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

@@ -0,0 +1,500 @@
+import { Scalar, IRange, FormulaError } from '@sheetxl/primitives';
+import { ReferenceableClipboard } from '@sheetxl/utils';
+import { ITypes } from '../../type';
+import { IListener } from '../../listener';
+import { IHistory } from '../../history';
+import { ISpatialQuery, ISpatialMap, ISparseGrid, Tuple } from '../../collections';
+import { IFormulaBlock } from '../formula';
+import { ContentfulSpatialValue, SpillEntry } from '../spatial';
+import { ReferenceCoords, NamedReference } from '../Types';
+import { ICalculation } from '../ICalculation';
+/**
+ * The CalcGrid holds input and outputs of in a 2D space to a scope (usually a sheet).
+ *
+ * @remarks
+ * If inputValues are externally managed then formulas update must also be provided.
+ */
+export interface ICalcGrid {
+    /**
+     * Set a group of cells and formula ranges.
+     *
+     * @param values A set of input values as BoundedTuples
+     * @param ranges A set of formula strings as ranged entries.
+     */
+    setInputs(values: Tuple.BoundedTuples<Scalar> | null, formulas: readonly ISpatialMap.Entry<string>[] | null): IRange.Coords[];
+    /**
+     * Remove all values within a range.
+     *
+     * @param coords The coordinates to remove.
+     */
+    remove(coords: IRange.Coords): IRange.Coords[];
+    /**
+     * Execute a calculate on a single grid.
+     *
+     * @param full If true, performs a full calculation; otherwise, performs a partial calculation.
+     * @returns A promise that will be resolved when the calculation is completed.
+     *
+     * @remarks
+     * For async functions this will return before they are completed.
+     * This simply calls Calculation.calculate.
+     */
+    calculate(full?: boolean): Promise<ICalculation.Status>;
+    /**
+     * Mark a range invalid. This will call the area to be recalculated on the next calculate call.
+     *
+     * @param coords An array of coordinates.
+     *
+     * @remarks
+     * This allows for incremental dirty updates.
+     */
+    markDirtyRegions(coords: IRange.Coords[]): void;
+    /**
+     * Returns true if there are any dirty regions that need to be calculated.
+     */
+    getDirtyRegions(): ISpatialQuery;
+    /**
+     * Returns the formula block at the given coordinates.
+     *
+     * @param row The row of the cell to evaluate.
+     * @param column The column of the cell to evaluate.
+     */
+    getFormulaBlockAt(row: number, column: number): IFormulaBlock | null;
+    /**
+     * Returns a queryable spatial index of all formulas in the graph.
+     *
+     * @remark
+     * Used by sheet
+     */
+    getFormulas(): ISpatialQuery<IFormulaBlock>;
+    /**
+     * Returns the current values on the grid.
+     */
+    getValues(): ISparseGrid<Scalar>;
+    /**
+     * Shifts all values in the graph in a given direction.
+     *
+     * @param options The options for the shift.
+     */
+    shift(options: ICalcGrid.ShiftOptions): this;
+    /**
+     * Returns a snapshot of the graph that can be used for copying.
+     */
+    getSnapshot(options?: ICalcGrid.GetSnapshotOptions): ICalcGrid.ISnapshot;
+    /**
+     * Autofill the values from a single cell to the entire range.
+     *
+     * @remarks
+     * This is similar to getSnapshot but doesn't return a promise.
+     */
+    autoFill(template: IRange.Coords | string, destination: IRange.Coords | string): this;
+    /**
+     * Returns the dependents for a specific range.
+     *
+     * @param coords The coordinates of the range.
+     *
+     * @remarks
+     * A range a formula resolved at run time — `INDIRECT`, `OFFSET` — is reported like any other,
+     * with the caveat under {@link getDirectPrecedentsAt}.
+     */
+    getDirectDependentsAt(coords: IRange.Coords): IRange.Coords[];
+    /**
+     * Returns the precedents for a specific range.
+     *
+     * @param coords The coordinates of the range.
+     *
+     * @remarks
+     * A range a formula resolved at run time — `INDIRECT`, `OFFSET` — is reported like any other,
+     * but it is not the same KIND of fact and should not be cached as one. A written reference is a
+     * property of the formula's text: true before anything calculates, and unchanged until the text
+     * changes. A resolved one is a record of the last calculation, so it moves when the formula's own
+     * inputs move (`INDIRECT(B1&"!A1")` names a different sheet once `B1` does), and it is absent
+     * entirely for a block that has not been calculated yet.
+     *
+     * Its bounds are also the union of everything the block read, which for a scattered read is wider
+     * than the cells actually touched. Deliberately: over-reporting costs a caller a check that comes
+     * back clean, where under-reporting hands it an incomplete answer that looks complete.
+     */
+    getDirectPrecedentsAt(coords: IRange.Coords): IRange.Coords[];
+    /**
+     * Returns all ranges recursively, including those that depend on it indirectly
+     * through the full calculation chain.
+     *
+     * @remarks
+     * This performs a recursive search downstream to find the total impact of a value change.
+     */
+    getDependentsAt(coords: IRange.Coords): IRange.Coords[];
+    /**
+     * Returns all precedents recursively, including those referenced indirectly
+     * through the full calculation chain.
+     *
+     * @remarks
+     * This performs a recursive search upstream to find all root data sources.
+     */
+    getPrecedentsAt(coords: IRange.Coords): IRange.Coords[];
+    /**
+     * Returns the absolute direct precedents for a formula.
+     *
+     * @param row The row of the cell to evaluate.
+     * @param column The column of the cell to evaluate.
+     * @throws Error if there is not a formula at the coordinates.
+     */
+    getReferencesAt(row: number, column: number): ReferenceCoords[];
+    /**
+     * Sets the reference to an absolute range at a specific cell coordinate.
+     *
+     * @param row The row of the cell to evaluate.
+     * @param column The column of the cell to evaluate.
+     * @param index The index of the evaluation to use from the tokens.
+     * @param precedent The value to set — a {@link IRange.FixableCellCoords} (single cell) collapses an
+     *   existing range to a lone cell; a {@link IRange.FixableCoords} preserves the existing shape. See
+     *   {@link IFormulaBlock.setReferenceAt}.
+     * @throws Error if the cell is not a formula.
+     */
+    setReferenceAt(row: number, column: number, index: number, precedent: IRange.FixableCoords | IRange.FixableCellCoords | NamedReference | FormulaError.Ref): this;
+    /**
+     * Return true if the cell at row column is volatile.
+     *
+     * @param row The row of the cell to evaluate.
+     * @param column The column of the cell to evaluate.
+     *
+     * @remarks
+     *
+     * This is not used internally but is provided to allow api to query.
+     */
+    isVolatileAt(row: number, column: number): boolean;
+    /**
+     * Returns a copy on write clone.
+     *
+     * @param cloneKey A performance optimization that will avoid cloning if the same key is used.
+     *
+     * @remarks
+     * If the same clone key is used then the same instance will be returned.
+     */
+    clone(cloneKey?: any): this;
+    /**
+     * Add Listeners to graph.
+     */
+    addListeners(listeners: ICalcGrid.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Returns the entire coords for the IGrid
+     */
+    getEntireCoords(): IRange.Coords;
+    /**
+     * Returns the bounding range for the content.
+     *
+     * @remarks
+     * This includes values and formulas.
+     *
+     * @returns `null` if the grid has no content.
+     */
+    getBoundingRange(): IRange.Coords | null;
+    /**
+     * Loads the json into the graph.
+     *
+     * @param json The JSON to load.
+     * @param options {@link ICalcGrid.FromJSONOptions}
+     *
+     * @remarks
+     * This will clear all values and formulas including any pending changes or invalidation.
+     *
+     * @returns `undefined` when the calculation is not ready (the load is deferred until start).
+     */
+    fromJSON(json: ICalcGrid.JSON, options?: ICalcGrid.FromJSONOptions): ICalcGrid.Results | undefined;
+    /**
+     * Returns a JSON representation of the calcGrid.
+     *
+     * @param options The options for the JSON representation.
+     *
+     * @returns `null` if the grid has nothing to persist.
+     */
+    toJSON(options?: ICalcGrid.ToJSONOptions): Promise<ICalcGrid.JSON | null>;
+    /**
+     * Immutable instance id. Used for equality checks.
+     */
+    getId(): string;
+    /**
+     * Returns a record for new incremental updates.
+     *
+     * @remarks
+     * This will create a new record for tracking incremental updates.
+     */
+    beginUpdates(): ICalcGrid.IncrementalUpdates;
+    /**
+     * Remove the grid from the calculation.
+     */
+    delete(): void;
+}
+/**
+ * {@inheritDoc ICalcGrid}
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link ICalcGrid}
+ */
+export declare namespace ICalcGrid {
+    interface Results {
+        /**
+         * The id of the calculation that was completed.
+         *
+         * @remarks
+         * * Every calculation will have a unique id so this can be used to track the completion of a calculation.
+         * * If calculations was called but no calculation was performed and event will be fired with the
+         *   previous calcCompleteId.
+         */
+        cycleId: number;
+        /**
+         * When a full calculation is performed removes are not return and the client must clear all caches `true`.
+         *
+         * @defaultValue `false`
+         */
+        isFull?: boolean;
+        /**
+         * The bounds of the result updates including tuples, spills inserts and spills removes.
+         *
+         * @remarks
+         * This will be `null` if no calculation results were updated or if isFull.
+         */
+        bounds?: IRange.Coords | null;
+        /**
+         * The results of the calculation will either be as `Map` or as a `Tuple.BoundedTuples`.
+         *
+         * @see
+         * {@link CalculateOptions.asTuples}
+         */
+        valueInserts?: Tuple.BoundedTuples<Scalar>;
+        /**
+         * Values that have been cleared.
+         */
+        valueRemoves?: IRange.Coords[];
+        /**
+         * Contains any spills that were inserted. The value is the
+         * {@link ITypes.FormulaArrayKind | kind} of the block that produced it.
+         */
+        spillInserts?: ISpatialMap.Entry<ITypes.FormulaArrayKind>[];
+        /**
+         * Contains any spills that were removed.
+         */
+        spillRemoves?: ISpatialMap.Entry[];
+        /**
+         * Formatting updates due to functions.
+         *
+         * @remarks
+         * Formats are not cleared.
+         */
+        formatInserts?: ISpatialMap.Entry<string>[];
+        /**
+         * Contains any errors that were inserted.
+         */
+        errorInserts?: ISpatialMap.Entry<string>[];
+        /**
+         * Contains any error that were removed.
+         */
+        errorRemoves?: ISpatialMap.Entry[];
+        /**
+         * Indicates that a pending status has been added or removed.
+         * A `true` value indicates that the pending status has been added.
+         * A `false` value indicates that the pending status has been removed.
+         *
+         * @remarks
+         * These are guaranteed to not overlap.
+         */
+        pendingUpdates?: ISpatialMap.Entry<boolean>[];
+    }
+    /**
+     * Returns from `ICalcGrid.beginUpdates()`.
+     *
+     * @returns
+     * Contains values that are being calculated but have not yet been committed.
+     */
+    interface IncrementalUpdates {
+        readonly gridId: string;
+        values: ISparseGrid<Scalar>;
+        spillSpatial: ISpatialMap<SpillEntry>;
+        errorSpatial: ISpatialMap<string>;
+        pendingSpatial: ISpatialMap<boolean>;
+        contentfulSpatial: ISpatialMap<ContentfulSpatialValue>;
+        notifyValues: ISpatialMap;
+        notifySpillsInsert: ISpatialMap.Entry<SpillEntry>[];
+        notifySpillsRemove: IRange.Coords[];
+        notifyFormats: ISpatialMap;
+        notifyPending: ISpatialMap<boolean>;
+        pendingConflating: ISpatialMap.IConflatingEntries<boolean> | null;
+        errorRemovesConflating: ISpatialMap.IConflatingEntries<null> | null;
+        errorInsertsConflating: ISpatialMap.IConflatingEntries<string> | null;
+        formatsConflating: ISpatialMap.IConflatingEntries | null;
+        /**
+         * Called when the incremental updates are completed
+         *
+         * @param options
+         *
+         * @remarks
+         * If there are multiple incremental updates for a single calculation then only the last one
+         * will have done called.
+         */
+        done(cycleId: number, options: ICalculation.CalculateOptions): void;
+    }
+    interface GetSnapshotOptions extends ReferenceableClipboard.CopyOptions {
+        /**
+         * The range to capture the snapshot from. If omitted the entire range will be used.
+         */
+        range?: IRange.Coords | string;
+    }
+    /**
+     * Provides destination details for the Snapshot when using `IHistory.ISnapshot.copyTo`.
+     */
+    interface SnapshotDestination {
+        /**
+         * The destination calc graph to copy to.
+         */
+        calcGrid: ICalcGrid;
+        /**
+         * The range to copy the snapshot to.
+         */
+        range: IRange.Coords | string;
+    }
+    interface ISnapshot extends IHistory.ISnapshot<ICalcGrid.SnapshotDestination, ICalcGrid, IRange.Coords> {
+        /**
+         * Called when the table is copied to a new collection.
+         */
+        copyTo(destination: ICalcGrid.SnapshotDestination, options?: ICalcGrid.CopyOptions): Promise<IRange.Coords>;
+    }
+    /**
+     * Options for {@link ISnapshot.copyTo}.
+     */
+    interface CopyOptions extends ReferenceableClipboard.CopyOptions {
+        /**
+         * When pasting from a smaller range to a larger range copy will repeat or 'wallpaper' the
+         * source values.
+         *
+         * @remarks
+         * Note - If the destination range is only a single cell then fitDestination will always be applied.
+         */
+        fitDestination?: boolean;
+        /**
+         * Have the data transposed for the original axis.
+         * @defaultValue false
+         */
+        transpose?: boolean;
+    }
+    interface Error {
+        /**
+         * The error message.
+         */
+        message?: string;
+        /**
+         * Some error types will give an indicate of the range location.
+         */
+        coords?: string[];
+    }
+    /**
+     * Options for shifting the calc graph.
+     */
+    interface ShiftOptions {
+        /**
+         * The range to shift.
+         */
+        range: IRange.Coords;
+        /**
+         * The direction to shift.
+         */
+        direction: IRange.Direction;
+        /**
+         * If `true` the this will return a clone instance of the graph if there are any modifications.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * This allows for a 0-1 clone on write.
+         */
+        cloneIfUpdate?: boolean;
+    }
+    /**
+     * Events for {@link ICalcGrid}.
+     */
+    interface Events {
+        /**
+         * Called when the calculation has been updated and a calculation has not been started.
+         */
+        onInvalidate?(source: ICalcGrid): void;
+        /**
+         * Called when a calculation is started.
+         */
+        onStart?(source: ICalcGrid): void;
+        /**
+         * Called when a calculation is completed.
+         */
+        onComplete?(source: ICalcGrid, results: ICalcGrid.Results): void;
+        /**
+         * Called when the calculation engine is unable to calc.
+         *
+         * @remarks
+         * This is not when a specific function fails, but when the calculation engine is unable to complete the calculation.
+         */
+        onError?(source: ICalcGrid): void;
+        /**
+         * Called when the CalcGrid is closed.
+         */
+        onClose?(source: ICalcGrid): void;
+    }
+    interface IListeners extends IListener.Callbacks<ICalcGrid, ICalcGrid.Events> {
+    }
+    interface JSON {
+        /**
+         * The input and calced data.
+         *
+         * @remarks
+         * This is usually empty as the data is managed by the client of the graph.
+         */
+        data?: Tuple.GridTuple<Scalar>;
+        /**
+         * The formulas.
+         */
+        formulas?: IRange.JSONReferenceTuple<string>[];
+        /**
+         * The extent occupied by an array formula, and which of the three
+         * {@link ITypes.FormulaArrayKind | kinds} of array formula it is.
+         *
+         * @remarks
+         * See {@link ISheet.JSON.formulaArray} for what does and does not earn an entry.
+         */
+        formulaArray?: IRange.JSONReferenceTuple<ITypes.FormulaArrayKind>[];
+        /**
+         * Indicates the range contains volatile functions.
+         *
+         * @remarks
+         * For built-in functions volatile will be auto added.
+         */
+        volatile?: IRange.Address[];
+    }
+    /**
+     * Options for {@link ICalcGrid.fromJSON}.
+     */
+    interface FromJSONOptions {
+        /**
+         * A structural transform applied to each formula's parsed tree (pre-link) as it loads —
+         * the READ half of the dialect hook. A format reader (io-xlsx) supplies its legacy unwrap
+         * here; native loads pass nothing.
+         *
+         * @see {@link ICalculation.FormulaTransform}
+         */
+        formulaTransform?: ICalculation.FormulaTransform;
+    }
+    interface ToJSONOptions {
+        /**
+         * If `true` the values will not be included in the JSON.
+         *
+         * @defaultValue `false`
+         */
+        includeData?: boolean;
+        /**
+         * A structural transform applied to each formula as it serializes (once per formula
+         * block, on the compiled AST) — how the xlsx writer applies its legacy spellings
+         * (see io-xlsx `LegacyFormula.ts`).
+         *
+         * @see {@link ICalculation.FormulaTransform}
+         */
+        formulaTransform?: ICalculation.FormulaTransform;
+    }
+}
+//# sourceMappingURL=ICalcGrid.d.ts.map

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

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

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

@@ -0,0 +1,5 @@
+export * from './ICalculation';
+export * from './INamedFormulasCollection';
+export * from './builtInNames';
+export * from './FormulaLiterals';
+//# sourceMappingURL=index.d.ts.map

package/types/src/calculation/spatial/ContentfulSpatialValue.d.ts

@@ -0,0 +1,25 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+import { Tuple, ISpatialMap } from '../../collections';
+/**
+ * Used for identifying contiguously filled ranges.
+ */
+export declare class ContentfulSpatialValue {
+    private _c;
+    private _a;
+    constructor(coords: IRange.Coords, axis: IRange.Axis);
+    getCoords(): IRange.Coords;
+    getAxis(): IRange.Axis;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getMerged} */
+    getMerged(_other: this, coords: IRange.Coords, _axis: IRange.Axis): this;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], _axis: IRange.Axis): [this, this] | undefined;
+    getState(): IRange.Coords;
+}
+/**
+ * Wraps each value in a ContentfulSpatialValue
+ */
+export declare function tuplesToContentfulEntries2(gridTuples: Tuple.GridTuple<Scalar>, scope: string, isColumn: boolean): ISpatialMap.Entry<ContentfulSpatialValue>[];
+export declare function rangeToContentfulEntries(entries: readonly ISpatialMap.Entry[], isColumn: boolean): ISpatialMap.Entry<ContentfulSpatialValue>[];
+//# sourceMappingURL=ContentfulSpatialValue.d.ts.map

package/types/src/calculation/spatial/FormulaSpatialValue.d.ts

@@ -0,0 +1,120 @@
+import { FormulaError, IRange } from '@sheetxl/primitives';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+import { IFormulaBlock } from '../formula';
+import { CalcNode, IContextContainer } from '../state';
+import { ReferenceCoords, SetReferenceOptions } from '../Types';
+import { ICalculation } from '../ICalculation';
+/**
+ * This extends IFormulaBlock with spatial behavior.
+ */
+export declare class FormulaSpatialValue implements IFormulaBlock, ISpatialMap.IUpdatableValue<FormulaSpatialValue> {
+    protected _container: IContextContainer;
+    gridId: string | null;
+    /**
+     * The block's extent.
+     *
+     * Invariant: whenever this block is stored in the formula spatial map, `ref` equals that entry's
+     * coords — every construction site builds the block from the coords of the entry it is stored under,
+     * and `getSplit` mints a new block per piece rather than narrowing an entry over a shared block.
+     *
+     * Consumers rely on this to treat a formula-sourced entry as the block's own extent (no offset to
+     * map through). Reusing one block across entries of differing coords would silently break the dirty
+     * windowing in `doCollectDirtyCalcs`.
+     */
+    ref: IRange.Coords;
+    formula: IFormulaBlock | null;
+    calcs: CalcNode[][];
+    /**
+     * The precedent entries that were actually registered for this block.
+     *
+     * Removal cannot re-derive these: it resolves the block's references against *current* state, and a
+     * reference may no longer resolve by then (deleting a named formula makes its dependents resolve to
+     * `#NAME?`, which the remove loop skips). The entry then survives holding a back-pointer to this —
+     * now stale — block, so the cell is reachable through both the stale precedent and its recompiled
+     * formula, yielding two CalcNodes for one cell and a duplicate push in the value builder.
+     *
+     * Recording what was inserted lets removal evict by identity instead. Only populated by the
+     * `updatePrecedentsSpatial` insert path; other paths leave it null and fall back to resolution.
+     */
+    registeredPrecedents: ISpatialMap.Entry<any>[] | null;
+    /**
+     * `true` when {@link ref} is a synthetic anchor rather than a position in a real grid — a named
+     * formula's body (stored at (0,0) in its virtual grid) or the editor's temporary formula.
+     *
+     * @remarks
+     * A **relative** reference is stored as an offset from `ref`, so on these blocks its absolute
+     * position (`ref + offset`) is fiction: there is no cell it names, and nothing to compare against
+     * a shift boundary. Structural change must therefore leave relative endpoints alone — the offset
+     * IS the definition. Measured against Excel: a relative name's `RefersTo` never changes under
+     * insert/delete/move, while an absolute one always does (`$`-fixed endpoints carry a real
+     * coordinate that owes nothing to the anchor, so they shift normally on these blocks too).
+     *
+     * Deliberately NOT "is a named body". Anything holding a formula at a synthetic anchor wants the
+     * same treatment, and the shift code should not have to know what a name is.
+     *
+     * Required at construction rather than defaulted: the block is immutable and re-minted on every
+     * reference rewrite, so an unthreaded copy would silently revert to `false` on the first
+     * `setReferenceAt` — which is exactly what a shift performs.
+     */
+    readonly unanchored: boolean;
+    constructor(coords: IRange.Coords, gridId: string | null, formula: IFormulaBlock | null, container: IContextContainer, unanchored: boolean, calcs?: CalcNode[][]);
+    protected _createCalcs(formula: IFormulaBlock | null, gridId: string | null, coords: IRange.Coords): CalcNode[][];
+    protected _cloneCalcs(calcs: CalcNode[][], colStart: number, rowStart: number, gridId?: string | null): CalcNode[][];
+    toJSON(r1c1?: boolean, formulaTransform?: ICalculation.FormulaTransform): [coords: string, text: string];
+    getCoords(): IRange.Coords;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getMerged} */
+    getMerged(other: this, coords: IRange.Coords, axis: IRange.Axis): this | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], axis: IRange.Axis, offset: number): [this, this] | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.copyTo} */
+    copyTo(destination: IRange.Coords, options?: FormulaCopyToOptions): ISpatialMap.Entry<this> | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.canTile} */
+    canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    onRemove?(entry: ISpatialMap.Entry<FormulaSpatialValue>): void;
+    /** {@inheritDoc IFormulaBlock.evaluateAt} */
+    evaluateAt(row: number, column: number, evalIndex?: number): any;
+    /** {@inheritDoc IFormulaBlock.finalizeValue} */
+    finalizeValue(value: any): any;
+    /** {@inheritDoc IFormulaBlock.finalizeValueForCell} */
+    finalizeValueForCell(value: any): any;
+    /** {@inheritDoc IFormulaBlock.getTokensAt} */
+    getTokensAt(row: number, column: number, evalIndex?: number): ICalculation.FormulaToken[];
+    /** {@inheritDoc IFormulaBlock.getTextAt} */
+    getTextAt(row: number, column: number, r1c1?: boolean, formulaTransform?: ICalculation.FormulaTransform): string;
+    /** {@inheritDoc IFormulaBlock.resolvedPrecedentsAt} */
+    resolvedPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean, verticalAbs?: boolean[], horizontalAbs?: boolean[]): readonly (Readonly<IRange.FixableCoords> | FormulaError.Known)[];
+    /** {@inheritDoc IFormulaBlock.getReferences} */
+    getReferences(row: number, column: number): ReferenceCoords[];
+    /** {@inheritDoc IFormulaBlock.getReferenceAt} */
+    getReferenceAt(row: number, column: number, index: number): ReferenceCoords;
+    /** {@inheritDoc IFormulaBlock.setReferenceAt} */
+    setReferenceAt(index: number, reference: ReferenceCoords, options?: SetReferenceOptions): this;
+    /** {@inheritDoc IFormulaBlock.reanchorReferences} */
+    reanchorReferences(toGridId: string, force?: boolean): this;
+    /** {@inheritDoc IFormulaBlock.replaceSheetReferences} */
+    replaceSheetReferences(fromSheetDisplay: string, toSheetDisplay: string): this;
+    /** {@inheritDoc IFormulaBlock.wrapImplicit} */
+    wrapImplicit(rowIndex: number, colIndex: number, setSpillCells: Set<string>): this;
+    /** {@inheritDoc IFormulaBlock.getError} */
+    getError(): FormulaError.Parse | null;
+    /** {@inheritDoc IFormulaBlock.getNamedIds} */
+    getNamedIds(): string[];
+    /** {@inheritDoc IFormulaBlock.getReferencedSymbolIds} */
+    getReferencedSymbolIds(): string[];
+    /** {@inheritDoc IFormulaBlock.hasTotals} */
+    hasTotals(): boolean;
+    /** @inheritdoc IFormulaBlock.isReferenceOnly */
+    isReferenceOnly(): boolean;
+    /** {@inheritDoc IFormulaBlock.isEquals} */
+    isEquals(other: IFormulaBlock): boolean;
+}
+export interface FormulaCopyToOptions extends ISpatialMap.CopyOptions {
+    /**
+     * For cut operations: the source range being cut. Used to determine which relative edges to adjust.
+     */
+    cutFrom?: IRange.Coords;
+}
+//# sourceMappingURL=FormulaSpatialValue.d.ts.map