@pixerate/editor 0.24.0 → 0.26.0

package/dist/controller-BhLLAoi8.d.cts

@@ -1,1000 +0,0 @@
-type CellFormat = 'text' | 'number' | 'currency' | 'percentage' | 'date' | 'badge' | 'status' | 'assignee';
-type ColumnType = 'bound' | 'freeform' | 'formula';
-interface ColumnBinding {
-    dataSource: string;
-    field: string;
-}
-interface SpreadsheetColumn {
-    id: string;
-    key: string;
-    title: string;
-    width?: number;
-    type: ColumnType;
-    binding?: ColumnBinding;
-    formula?: string;
-    format?: CellFormat;
-    /**
-     * Number format code for the column's cells (e.g. `#,##0.00`,
-     * `"$"#,##0.00;[Red]("$"#,##0.00)`, `m/d/yyyy`). Cells without an explicit
-     * code of their own use it instead of the automatic one chosen for typed
-     * input. See `SpreadsheetController.setColumnNumberFormat`.
-     */
-    numberFormat?: string;
-    readOnly?: boolean;
-    hidden?: boolean;
-}
-type RowType = 'record' | 'freeform';
-interface SpreadsheetRow {
-    id: string;
-    index: number;
-    height?: number;
-    recordId?: string;
-    type: RowType;
-    hidden?: boolean;
-}
-interface CellCoordinate {
-    row: number;
-    col: number;
-    rowId?: string;
-    colId?: string;
-}
-interface CellRange {
-    startRow: number;
-    startCol: number;
-    endRow: number;
-    endCol: number;
-}
-interface CellData {
-    raw: string;
-    /**
-     * Evaluated value. Typed (non-formula) input is parsed: `"120"` → 120,
-     * `"TRUE"` → true, `"3/4/2026"` → `"2026-03-04"` (dates are ISO text),
-     * `"10:30"` → 0.4375 (a time alone is a fraction of a day); `'120` forces
-     * the text `"120"`. Formulas store their result.
-     */
-    value: any;
-    error?: string;
-    /** Why the formula failed, e.g. `Argument 2 of SUMIF must be a range.` Set alongside `error`. */
-    errorMessage?: string;
-    format?: CellFormat;
-    /**
-     * Excel number format code used to display the value (see
-     * `formatCellDisplay`). Set explicitly (`explicitNumberFormat`), inherited
-     * from the column's `numberFormat`, or chosen automatically for typed input,
-     * e.g. `"$"#,##0.00` for `$1,200.50`, `0%` for `10%`, `#,##0` for `1,234`,
-     * `m/d/yyyy` for `3/4/2026`, `h:mm` for `10:30`. Absent for General.
-     */
-    numberFormat?: string;
-    /**
-     * True when `numberFormat` was set explicitly (`setCellNumberFormat`):
-     * typing into the cell keeps it instead of choosing an automatic format.
-     */
-    explicitNumberFormat?: boolean;
-    readOnly?: boolean;
-    /**
-     * Set (only) on cells showing a value spilled from a dynamic array: the
-     * anchor cell holding the formula, e.g. `A1`. Spilled cells keep an empty
-     * `raw` and are never stored in the document.
-     */
-    spillAnchor?: string;
-}
-/** A dynamic array spilled from its anchor cell (the cell holding the formula). */
-interface SpreadsheetSpill {
-    /** Anchor cell key, e.g. `A1`. */
-    key: string;
-    anchor: {
-        row: number;
-        col: number;
-    };
-    /** Every cell the array covers, anchor included. */
-    range: CellRange;
-    /** The anchor's formula. */
-    formula: string;
-}
-interface SpreadsheetDocument {
-    id: string;
-    name: string;
-    columns: SpreadsheetColumn[];
-    rows: SpreadsheetRow[];
-    cells: Record<string, Record<string, CellData>>;
-    createdAt?: number;
-    updatedAt?: number;
-    table?: SpreadsheetTableSettings;
-}
-type SortDirection = 'asc' | 'desc';
-interface SortKey {
-    colId: string;
-    direction?: SortDirection;
-}
-type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between' | 'isBlank' | 'isNotBlank' | 'oneOf';
-interface FilterRule {
-    id: string;
-    colId: string;
-    operator: FilterOperator;
-    value?: string | number;
-    value2?: string | number;
-    values?: string[];
-}
-interface SpreadsheetFilterState {
-    enabled: boolean;
-    rules: FilterRule[];
-}
-type GroupAggregate = 'sum' | 'count' | 'average' | 'min' | 'max';
-interface GroupSummary {
-    colId: string;
-    aggregate: GroupAggregate;
-}
-interface SpreadsheetGrouping {
-    colId: string;
-    summaries: GroupSummary[];
-    collapsed: string[];
-}
-interface SpreadsheetTableSettings {
-    headerRowCount?: number;
-    footerRowCount?: number;
-    headerColumnCount?: number;
-    frozenRowCount?: number;
-    frozenColumnCount?: number;
-    merges?: CellRange[];
-    filter?: SpreadsheetFilterState;
-    grouping?: SpreadsheetGrouping;
-}
-interface SpreadsheetDataSourceField {
-    key: string;
-    label: string;
-    type: 'string' | 'number' | 'date' | 'boolean' | 'enum';
-    options?: Array<{
-        key: string;
-        label: string;
-        color?: string;
-    }>;
-}
-interface SpreadsheetDataSource {
-    id: string;
-    name: string;
-    getRecords(): Array<{
-        id: string;
-        [key: string]: any;
-    }>;
-    getFields(): SpreadsheetDataSourceField[];
-    updateRecord(recordId: string, field: string, value: any): Promise<void> | void;
-}
-
-type FormulaTokenType = 'NUMBER' | 'STRING' | 'BOOLEAN' | 'ERROR' | 'CELL_REF' | 'RANGE' | 'SPILL_REF' | 'PROPERTY_REF' | 'IDENTIFIER' | 'OPERATOR' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'EOF';
-interface FormulaToken {
-    type: FormulaTokenType;
-    value: string;
-    position: number;
-}
-declare function tokenizeFormula(formula: string): FormulaToken[];
-
-/** Row number used for the open end of whole-column ranges such as `A:A`. */
-declare const WHOLE_COLUMN_END_ROW = 1048576;
-type ASTNode = LiteralNode | CellRefNode | RangeNode | SpillRefNode | NameNode | PropertyRefNode | BinaryOpNode | UnaryOpNode | FunctionCallNode;
-interface LiteralNode {
-    type: 'Literal';
-    value: number | string | boolean;
-}
-interface CellRefNode {
-    type: 'CellRef';
-    ref: string;
-    col: string;
-    row: number;
-}
-interface RangeNode {
-    type: 'Range';
-    raw: string;
-    startCol: string;
-    startRow: number;
-    endCol: string;
-    endRow: number;
-}
-/** `A1#`: the whole spill range of the dynamic array anchored at A1. */
-interface SpillRefNode {
-    type: 'SpillRef';
-    /** Anchor cell, e.g. `A1`. */
-    ref: string;
-    col: string;
-    row: number;
-}
-/** A bare name: a LET variable, or `#NAME?` when nothing defines it. */
-interface NameNode {
-    type: 'Name';
-    name: string;
-}
-interface PropertyRefNode {
-    type: 'PropertyRef';
-    property: string;
-}
-interface BinaryOpNode {
-    type: 'BinaryOp';
-    op: string;
-    left: ASTNode;
-    right: ASTNode;
-}
-interface UnaryOpNode {
-    type: 'UnaryOp';
-    op: string;
-    argument: ASTNode;
-}
-interface FunctionCallNode {
-    type: 'FunctionCall';
-    name: string;
-    args: ASTNode[];
-}
-declare function parseCellReference(ref: string): {
-    col: string;
-    row: number;
-};
-declare function parseRange(rangeStr: string): RangeNode;
-declare class FormulaParser {
-    private tokens;
-    private current;
-    constructor(tokens: FormulaToken[]);
-    parse(): ASTNode;
-    private expression;
-    private comparison;
-    private concatenation;
-    private addition;
-    private multiplication;
-    private exponentiation;
-    private unary;
-    private primary;
-    private match;
-    private matchOperator;
-    private check;
-    private advance;
-    private isAtEnd;
-    private peek;
-    private previous;
-    private consume;
-}
-declare function parseFormula(formula: string): ASTNode;
-
-/** Spreadsheet error values. They propagate through operators and functions. */
-declare const FORMULA_ERRORS: Set<string>;
-type FormulaErrorCode = '#DIV/0!' | '#VALUE!' | '#REF!' | '#NAME?' | '#N/A' | '#NUM!' | '#CYCLE!' | '#ERROR!' | '#SPILL!' | '#CALC!';
-declare function isFormulaError(value: unknown): value is string;
-/**
- * Number to text as Excel converts it in `&` and General display: up to 15
- * significant digits, scientific for very large or very small magnitudes.
- */
-declare function numberToText(n: number): string;
-/**
- * Compares numbers the way Excel does: both are rounded to 15 significant
- * digits first, so binary noise such as `0.1+0.2` versus `0.3` counts as equal.
- */
-declare function compareNumbers(a: number, b: number): number;
-/**
- * Excel's comparison for the `=`, `<>`, `<`… operators: numbers < text <
- * booleans < errors, numbers compared at 15 significant digits, text
- * case-insensitively. A blank acts as 0, "" or FALSE depending on the other
- * side. Dates are ISO text: two ISO dates compare chronologically
- * ("2026-1-5" is before "2026-01-10"), and an ISO date against a number
- * compares as its serial number.
- */
-declare function compareValues(left: unknown, right: unknown): number;
-/**
- * Sort order (ascending): numbers, text, booleans, errors, then blanks last.
- * Errors are equal to each other, so sorting keeps their order.
- */
-declare function sortCompareValues(left: unknown, right: unknown): number;
-declare function colNameToIndex(col: string): number;
-declare function indexToColName(index: number): string;
-/**
- * A rectangular block of values. `values` is column-major (the order in which
- * `EvaluationContext.resolveRange` returns cells): `values[col * rows + row]`.
- */
-interface FormulaRange {
-    rows: number;
-    cols: number;
-    values: any[];
-}
-
-interface EvaluationContext {
-    resolveCell?: (col: string, row: number) => any;
-    /**
-     * Values of a rectangular range, column by column (all rows of the first
-     * column, then the next column). Lookup functions rely on this order.
-     */
-    resolveRange?: (startCol: string, startRow: number, endCol: string, endRow: number) => any[];
-    resolveProperty?: (property: string) => any;
-    /**
-     * The spilled array anchored at a cell, for `A1#` references: its shape and
-     * values (column-major, like `resolveRange`), or an error code (e.g.
-     * `#REF!` when the cell holds no array).
-     */
-    resolveSpill?: (col: string, row: number) => FormulaRange | string;
-    /**
-     * The cell holding the formula being evaluated, used by the implicit
-     * intersection operator (`=@A:A` reads the cell in the formula's row).
-     */
-    getFormulaCell?: () => {
-        col: string;
-        row: number;
-    } | null;
-}
-/** A human-readable reason for an error value. */
-interface FormulaDiagnostic {
-    code: FormulaErrorCode;
-    message: string;
-}
-interface FormulaEvaluationResult {
-    /** The computed value; an error code such as `#VALUE!` when the formula fails. */
-    value: any;
-    /** The error code when `value` is an error. */
-    error?: FormulaErrorCode;
-    /** Why the formula failed, e.g. `Argument 2 of SUMIF must be a range.` */
-    message?: string;
-    /**
-     * Set when the formula returned an array of more than one value (a
-     * dynamic array). `value` is then its top-left value; a spreadsheet spills
-     * the whole array into the cells below and to the right.
-     */
-    array?: FormulaRange;
-}
-/** Generic explanation of an error code, used when no specific reason was recorded. */
-declare function describeFormulaError(code: string): string;
-/** Largest array a formula may build (SEQUENCE, RANDARRAY, broadcasting). */
-declare const MAX_FORMULA_ARRAY_SIZE = 1000000;
-declare class FormulaEvaluator {
-    private context;
-    private diagnostics;
-    private scopes;
-    constructor(context?: EvaluationContext);
-    /**
-     * Evaluates a formula. Errors in the formula are returned as error values
-     * (`#VALUE!` etc.); malformed formulas and missing resolvers throw.
-     */
-    evaluate(astOrFormula: ASTNode | string): any;
-    /**
-     * Evaluates a formula and explains errors. Never throws: malformed formulas
-     * return `#ERROR!` with the parser's message. A result with several values
-     * (a range or a dynamic array) is returned in `array`, with its top-left
-     * value as `value`; a one-value array is just that value.
-     */
-    evaluateWithDiagnostics(astOrFormula: ASTNode | string): FormulaEvaluationResult;
-    /** Records why an error happened and returns the error code. */
-    private fail;
-    private evaluateNode;
-    private unary;
-    /** A binary operator on two single values. */
-    private binary;
-    /**
-     * Dates are ISO text: date +/- days is a date, date - date is a number of
-     * days (fractional when times are involved).
-     */
-    private dateArithmetic;
-    /**
-     * `@` (implicit intersection): a range reference reads the cell in the
-     * formula's row (one column) or column (one row); arrays give their
-     * top-left value.
-     */
-    private implicitIntersection;
-    private evaluateSpillRef;
-    private evaluateRange;
-    private callFunction;
-    private finishCall;
-    private lazyArguments;
-    /**
-     * Applies a scalar function element by element when it receives arrays
-     * (`=LEN(A1:A3)`, `=IF(A1:A3>1, "y", "n")`). Arguments typed `range` are
-     * passed whole. Returns undefined when no trigger argument is a
-     * multi-value array.
-     */
-    private liftOverArrays;
-    /** LET(name1, value1, [name2, value2, ...], calculation). */
-    private evaluateLet;
-    private createContext;
-}
-
-interface CellDep {
-    col: string;
-    row: number;
-}
-/**
- * Dependency key for "every cell in column `col`", used by whole-column ranges
- * (`A:A`) instead of expanding a million cell keys.
- */
-declare const columnDependencyKey: (col: string) => string;
-declare function extractCellDependencies(node: ASTNode): CellDep[];
-declare class DependencyGraph {
-    private dependencies;
-    private dependents;
-    private spillDependencies;
-    private spillDependents;
-    private spillEdges;
-    setCellFormula(cellKey: string, formulaStr: string | null): void;
-    /** Removes every registered formula and dependency. */
-    clear(): void;
-    /**
-     * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
-     * previous ones: every key in `spilledKeys` (cells holding its spilled
-     * values) depends on the anchor, and the anchor depends on every key in
-     * `blockingKeys` (cells that stop it spilling). Pass empty lists to remove
-     * the anchor's edges.
-     */
-    setSpillEdges(anchorKey: string, spilledKeys: Iterable<string>, blockingKeys?: Iterable<string>): void;
-    /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
-    getSpilledKeys(anchorKey: string): string[];
-    /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
-    getDependencies(cellKey: string): string[];
-    /** Cells depending on `cellKey`, through formulas or spills. */
-    getDependents(cellKey: string): string[];
-    /**
-     * Detects if there is a cycle containing cellKey.
-     */
-    hasCycle(cellKey: string): boolean;
-    /**
-     * Returns cells affected by updating cellKey in topological order.
-     */
-    getEvaluationOrder(startCellKey: string): {
-        order: string[];
-        hasCycle: boolean;
-    };
-    /**
-     * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
-     * cell that transitively depends on them). Returns the keys in evaluation
-     * order (dependencies first) and the set of keys that are part of a cycle,
-     * which must be marked `#CYCLE!` instead of evaluated. Every member of a
-     * cycle is reported, not just the cell that closed it.
-     */
-    getEvaluationPlan(cellKeys: Iterable<string>, options?: {
-        includeDependents?: boolean;
-    }): {
-        order: string[];
-        cyclic: Set<string>;
-    };
-}
-
-/**
- * A row or column insertion/deletion. `index` is the 0-based position of the
- * inserted or deleted row/column.
- */
-interface StructuralChange {
-    axis: 'row' | 'col';
-    index: number;
-    type: 'insert' | 'delete';
-}
-/**
- * Rewrites the cell and range references in `formula` after a row or column
- * is inserted or deleted, the way spreadsheet apps do: references after the
- * change shift, ranges grow or shrink, and references to a deleted row/column
- * become `#REF!`. Absolute (`$`) markers are kept. String literals, property
- * references and function names are left untouched.
- */
-declare function shiftFormulaReferences(formula: string, change: StructuralChange): string;
-/**
- * Calls `rewrite` with the source text of every cell or range reference in
- * `formula` (e.g. `"$A1"`, `"B2:C10"`, `"A:A"`) and splices in its result.
- * For a spill reference (`A1#`) it receives the anchor (`"A1"`) and the `#`
- * is kept, unless the rewrite returns `#REF!`. String literals, property references and function names (e.g. `LOG10(`)
- * are skipped. Formulas that fail to tokenize are returned unchanged.
- */
-declare function mapFormulaReferences(formula: string, rewrite: (reference: string) => string): string;
-/**
- * Moves a formula by (`rowOffset`, `colOffset`), as copy/paste and autofill
- * do: relative row/column parts shift, `$`-absolute parts stay. A reference
- * pushed above row 1 or left of column A becomes `#REF!`.
- */
-declare function offsetFormulaReferences(formula: string, rowOffset: number, colOffset: number): string;
-/** A 0-based cell position. */
-interface CellPosition {
-    row: number;
-    col: number;
-}
-/**
- * Rewrites references when cells *move* (sort, transpose): references follow
- * the cell they point at, whether relative or absolute. `moveCell` returns a
- * cell's new position, or null when it did not move. A range is remapped only
- * when its cells moved together as a rectangle of the same size (e.g. a
- * one-row range inside a sorted row, or a range inside a transposed block);
- * otherwise it is kept, since it still covers the same rows and columns.
- */
-declare function remapFormulaReferences(formula: string, moveCell: (position: CellPosition) => CellPosition | null): string;
-
-declare class DataSourceBinder {
-    private dataSources;
-    register(dataSource: SpreadsheetDataSource): void;
-    unregister(dataSourceId: string): void;
-    getDataSource(id: string): SpreadsheetDataSource | undefined;
-    /**
-     * Generates or reconciles spreadsheet rows from a primary data source.
-     */
-    syncRows(currentRows: SpreadsheetRow[], dataSourceId: string): SpreadsheetRow[];
-    /**
-     * Resolves a record's bound field value.
-     */
-    resolveBoundValue(dataSourceId: string, recordId: string, field: string): any;
-    /**
-     * Dispatches an update to the underlying data source.
-     */
-    commitBoundValue(dataSourceId: string, recordId: string, field: string, value: any): Promise<void>;
-}
-
-/**
- * Spreadsheet clipboard formats. Copying writes three representations:
- *
- * - `text/plain`: TSV of the displayed values (pastes into any app)
- * - `text/html`: an HTML `<table>` (pastes into docs, mail, other sheets)
- * - `application/x.pixerate.spreadsheet+json`: raw inputs and formulas, so a
- *   paste into a pixerate spreadsheet is lossless; formulas are re-based to
- *   the paste position like a spreadsheet copy/paste
- *
- * Pasting prefers the custom format, then an HTML table, then TSV. All
- * functions here are pure and DOM-free.
- */
-
-declare const SPREADSHEET_CLIPBOARD_MIME = "application/x.pixerate.spreadsheet+json";
-interface SpreadsheetClipboardCell {
-    raw: string;
-    value: unknown;
-    /** Display text for `text/plain` and `text/html` (e.g. `10%` for 0.1); defaults to the value as text. Not stored in the JSON payload. */
-    text?: string;
-}
-interface SpreadsheetClipboardPayload {
-    type: 'pixerate-spreadsheet';
-    version: 1;
-    /** Position of the copied block's top-left cell, used to re-base formulas. */
-    origin: CellPosition;
-    cells: SpreadsheetClipboardCell[][];
-}
-/** MIME type -> data, as written to `DataTransfer.setData`. */
-type SpreadsheetClipboardData = Record<string, string>;
-/** Anything clipboard data can be read from: a `DataTransfer` or a plain record. */
-type SpreadsheetClipboardSource = {
-    getData(format: string): string;
-} | Record<string, string | undefined>;
-interface ParsedSpreadsheetClipboard {
-    format: 'internal' | 'html' | 'text';
-    /** Raw inputs to write, row by row. */
-    rows: string[][];
-    /** For internal pastes: where the block was copied from. */
-    origin?: CellPosition;
-}
-/** Serializes displayed values as an HTML table. Line breaks become `<br>`. */
-declare function serializeHtmlTable(values: ReadonlyArray<ReadonlyArray<unknown>>): string;
-/**
- * Extracts cell texts from the first `<table>` in `html` (as written by
- * spreadsheet apps and browsers). `colspan`/`rowspan` cells are expanded with
- * blank cells so positions line up. Returns null when there is no table.
- */
-declare function parseHtmlTable(html: string): string[][] | null;
-/** Builds the three clipboard representations of a copied block. */
-declare function createSpreadsheetClipboardData(cells: SpreadsheetClipboardCell[][], origin: CellPosition): SpreadsheetClipboardData;
-/**
- * Reads clipboard data, preferring the lossless internal format, then an
- * HTML table, then TSV text. Returns null when there is nothing to paste.
- */
-declare function readSpreadsheetClipboard(source: SpreadsheetClipboardSource): ParsedSpreadsheetClipboard | null;
-/**
- * Moves formulas copied from `origin` so they keep their relative references
- * when pasted at `target`. Non-formula inputs are returned unchanged.
- */
-declare function rebaseClipboardRows(rows: string[][], origin: CellPosition, target: CellPosition): string[][];
-
-/**
- * The render model of a spreadsheet: which rows and columns are shown, in
- * which order, with group header rows, frozen (sticky) offsets and merged
- * cell spans. Filters, hidden rows/columns and collapsed groups only affect
- * this view; the document keeps every row.
- */
-
-declare const DEFAULT_ROW_HEIGHT = 32;
-declare const DEFAULT_COLUMN_WIDTH = 130;
-type SpreadsheetRowSection = 'header' | 'body' | 'footer';
-interface SpreadsheetRowGroup {
-    key: string;
-    label: string;
-    rowIndices: number[];
-    collapsed: boolean;
-    summaries: Record<string, number | null>;
-}
-type SpreadsheetViewRow = {
-    kind: 'row';
-    row: SpreadsheetRow;
-    index: number;
-    section: SpreadsheetRowSection;
-    frozen: boolean;
-    stickyTop: number;
-    groupKey?: string;
-} | {
-    kind: 'group';
-    group: SpreadsheetRowGroup;
-};
-interface SpreadsheetViewColumn {
-    column: SpreadsheetColumn;
-    index: number;
-    header: boolean;
-    frozen: boolean;
-    stickyLeft: number;
-}
-interface SpreadsheetCellSpan {
-    rowSpan: number;
-    colSpan: number;
-    /** The cell whose content is shown (a merge's top-left cell). */
-    source: CellPosition;
-    merge?: CellRange;
-}
-interface SpreadsheetViewModel {
-    rows: SpreadsheetViewRow[];
-    columns: SpreadsheetViewColumn[];
-    groups: SpreadsheetRowGroup[];
-    /** Visible document row indices in display order (for keyboard navigation). */
-    rowOrder: number[];
-    /** Visible document column indices in display order. */
-    columnOrder: number[];
-    filteredOutCount: number;
-    hiddenRowCount: number;
-    hiddenColumnCount: number;
-    /**
-     * Span of the cell rendered at (row, col): `{ rowSpan: 1, colSpan: 1 }` for
-     * an ordinary cell, the visible extent for a merge's first visible cell, and
-     * null for cells covered by a merge (render nothing).
-     */
-    getCellSpan(row: number, col: number): SpreadsheetCellSpan | null;
-}
-type CellValueReader = (rowIndex: number, colIndex: number) => unknown;
-/** Header and footer row counts, clamped so they never overlap. */
-declare function getTableSections(doc: SpreadsheetDocument): {
-    headerRows: number;
-    footerRows: number;
-};
-declare function getRowSection(doc: SpreadsheetDocument, rowIndex: number): SpreadsheetRowSection;
-/** Whether a body row passes the active filters. Header/footer rows always do. */
-declare function rowPassesFilters(doc: SpreadsheetDocument, rowIndex: number, getValue: CellValueReader): boolean;
-/** Category groups of the (unhidden, unfiltered) body rows. */
-declare function computeRowGroups(doc: SpreadsheetDocument, getValue: CellValueReader): SpreadsheetRowGroup[];
-declare function buildSpreadsheetView(doc: SpreadsheetDocument, getValue: CellValueReader): SpreadsheetViewModel;
-
-interface CsvExportOptions {
-    range?: CellRange | null;
-    delimiter?: string;
-    lineEnding?: string;
-    bom?: boolean;
-    /** Export formulas as typed (`=SUM(A1:A3)`) instead of their values. */
-    formulas?: boolean;
-}
-interface CsvImportOptions {
-    startRow?: number;
-    startCol?: number;
-    delimiter?: string;
-}
-type NewFilterRule = Omit<FilterRule, 'id'> & {
-    id?: string;
-};
-interface SpreadsheetControllerOptions {
-    document?: Partial<SpreadsheetDocument>;
-    dataSources?: SpreadsheetDataSource[];
-    primaryDataSourceId?: string;
-    onDocumentChange?: (doc: SpreadsheetDocument) => void;
-    onSelectionChange?: (activeCell: CellCoordinate | null, range: CellRange | null) => void;
-    onCellCommit?: (rowId: string, colId: string, raw: string, value: any) => void;
-    /**
-     * Approximate memory budget for undo/redo snapshots, in bytes (UTF-16 size of
-     * the serialized documents). The oldest undo steps beyond it are dropped, but
-     * the most recent one is always kept. Defaults to 64 MiB; 0 = unlimited.
-     */
-    maxHistoryBytes?: number;
-}
-declare class SpreadsheetController {
-    document: SpreadsheetDocument;
-    activeCell: CellCoordinate | null;
-    selectedRange: CellRange | null;
-    editingCell: CellCoordinate | null;
-    draftValue: string;
-    readonly binder: DataSourceBinder;
-    readonly depGraph: DependencyGraph;
-    readonly evaluator: FormulaEvaluator;
-    private primaryDataSourceId?;
-    private onDocumentChange?;
-    private onSelectionChange?;
-    private onCellCommit?;
-    private undoStack;
-    private redoStack;
-    private isApplyingHistory;
-    private readonly maxHistoryBytes;
-    private batching;
-    private pendingCommits;
-    private evaluatingRowIndex;
-    private evaluatingCell;
-    private spills;
-    private spilledBy;
-    private spillCells;
-    private spillChanges;
-    constructor(options?: SpreadsheetControllerOptions);
-    loadDocument(document: SpreadsheetDocument): void;
-    /**
-     * Re-parses the value of every stored typed (non-formula) cell from its
-     * `raw` input, so documents saved before typed input was parsed (whose
-     * values are text such as `"120"`) compare and sort as numbers. Cells of
-     * bound columns in record rows keep their value: it belongs to the data
-     * source.
-     */
-    private rederiveTypedValues;
-    /**
-     * Value of typed (non-formula) input: a number, boolean, ISO date, error
-     * or text (see `parseCellInput`), its automatic number format, and the
-     * `CellFormat` to use: the automatic one (currency, percentage, date,
-     * number) when `format` is unset or `text` (the default of new columns).
-     */
-    private typedCell;
-    /**
-     * The number format a cell keeps whatever is typed into it: its explicit
-     * one, else its column's. Undefined lets typed input choose one.
-     */
-    private fixedNumberFormat;
-    /** `numberFormat` / `explicitNumberFormat` fields for a formula, bound or spilled cell. */
-    private fixedNumberFormatFields;
-    /**
-     * Typed input for a bound field, coerced by the field's declared type:
-     * number, boolean and date fields get a number, boolean or ISO date when
-     * the input parses as one; string and enum fields (and unknown fields)
-     * keep the text exactly as typed.
-     */
-    private boundInputValue;
-    registerDataSource(ds: SpreadsheetDataSource): void;
-    setPrimaryDataSource(dataSourceId: string | undefined): void;
-    syncWithDataSource(): void;
-    private recomputeRowIndices;
-    getColumn(colIdOrKey: string): SpreadsheetColumn | undefined;
-    getRow(rowIdOrIndex: string | number): SpreadsheetRow | undefined;
-    getCell(rowId: string, colId: string): CellData;
-    /** Value of a cell with no stored data: bound record value, column formula, or blank. */
-    private getDerivedCell;
-    setCellValue(rowId: string, colId: string, raw: string): void;
-    private getCellKey;
-    /**
-     * Recalculates a cell and everything that depends on it, in dependency
-     * order. Every cell in a reference cycle is marked `#CYCLE!`.
-     */
-    recalculateCell(rowId: string, colId: string): void;
-    /**
-     * Recalculates `keys` (and, with `includeDependents`, their dependents) in
-     * dependency order. Spill ranges are only known after evaluating their
-     * anchors, so when a pass changes which cells hold spilled values (and so
-     * the dependency graph), the dependents of those cells are recalculated in
-     * another pass, until nothing changes.
-     */
-    private recalculateKeys;
-    /**
-     * Rebuilds the dependency graph from scratch and recalculates every formula
-     * in dependency order.
-     */
-    recalculateAll(): void;
-    private runEvaluationPlan;
-    private locateCellKey;
-    private markCycle;
-    private evalSingleCellByKey;
-    /**
-     * Spills `array` from the anchor at (row, col) into the cells below and to
-     * the right. Returns why it can't (the anchor then shows `#SPILL!`), or
-     * null once placed. The grid never grows to fit an array, as in Excel.
-     */
-    private placeSpill;
-    /** Removes the array spilled from `anchor`. With `keepEdges`, its dependency edges stay. */
-    private clearSpill;
-    private forgetSpilledCell;
-    private resolveSpillByCoord;
-    private toSpill;
-    /**
-     * The dynamic array covering (row, col), whether it is the anchor (the cell
-     * holding the formula) or a spilled cell; null when there is none.
-     */
-    getSpillAt(row: number, col: number): SpreadsheetSpill | null;
-    /** Every dynamic array currently spilled. */
-    getSpills(): SpreadsheetSpill[];
-    /** Whether `range` overlaps a spilled array (its anchor or spilled cells). */
-    private intersectsSpill;
-    private resolveCellByCoord;
-    private resolveRangeByCoords;
-    private resolveCurrentRowProperty;
-    selectCell(row: number, col: number, extendSelection?: boolean): void;
-    selectRange(range: CellRange): void;
-    startEditing(row?: number, col?: number, initialValue?: string): void;
-    commitEditing(valueToCommit?: string): void;
-    cancelEditing(): void;
-    moveCursor(direction: 'up' | 'down' | 'left' | 'right', extendSelection?: boolean): void;
-    insertColumn(index: number, config?: Partial<SpreadsheetColumn>): void;
-    deleteColumn(colId: string): void;
-    insertRow(index: number, config?: Partial<SpreadsheetRow>): void;
-    deleteRow(rowId: string): void;
-    private generateId;
-    /**
-     * Rewrites references in every cell formula (and, for column changes, every
-     * column formula) so they keep pointing at the same cells.
-     */
-    private shiftReferences;
-    setColumnWidth(colId: string, width: number): void;
-    autoFitColumnWidth(colId: string, customWidth?: number): void;
-    /**
-     * Exports cell values as TSV: the whole sheet, or only `range` (e.g. the
-     * current selection) when given.
-     */
-    exportToTsv(range?: CellRange | null): string;
-    /**
-     * Pastes tab-separated values starting at (startRow, startCol), adding rows
-     * and columns as needed. The whole paste is a single undo step.
-     */
-    importFromTsv(tsvData: string, startRow?: number, startCol?: number): void;
-    /** Adds rows/columns at the end until (rowIndex, colIndex) exists. */
-    private growGrid;
-    /**
-     * Writes raw inputs starting at (startRow, startCol), growing the grid as
-     * needed, as a single undo step with one recalculation.
-     */
-    private writeMatrix;
-    /**
-     * Runs `fn` as one undo step: cell writes inside it are batched and
-     * recalculated once, then listeners are notified.
-     */
-    private runBatch;
-    /**
-     * Exports the sheet (or `range`) as RFC 4180 CSV. Values are exported as
-     * displayed unless `formulas` is set.
-     */
-    exportToCsv(options?: CsvExportOptions): string;
-    /**
-     * Imports CSV text at (startRow, startCol) (default A1), growing the grid
-     * as needed. The whole import is a single undo step.
-     */
-    importFromCsv(csv: string, options?: CsvImportOptions): void;
-    /**
-     * Writes already-parsed rows of raw inputs (e.g. from an import adapter)
-     * starting at (startRow, startCol), as a single undo step.
-     */
-    importRows(rows: string[][], options?: Omit<CsvImportOptions, 'delimiter'>): void;
-    /** The cells of `range` (or the whole sheet), row by row. */
-    private readMatrix;
-    /**
-     * Builds clipboard data for `range` (default: the selection) as TSV,
-     * an HTML table and the lossless internal JSON format. Write every entry
-     * with `clipboardData.setData(type, data)` in a `copy` event.
-     */
-    copyToClipboardData(range?: CellRange | null): SpreadsheetClipboardData;
-    /**
-     * Pastes clipboard data at `target` (default: the selection's top-left).
-     * Prefers the internal format (formulas re-based to the target), then an
-     * HTML table, then TSV. Returns false when there was nothing to paste.
-     */
-    pasteClipboardData(source: SpreadsheetClipboardSource, target?: CellPosition): boolean;
-    private spillAnchorInRange;
-    private getSelectionTopLeft;
-    /** The table settings object, created on first use. */
-    private get table();
-    /** Records an undo step, applies `fn`, then notifies listeners. */
-    private applyTableChange;
-    /** First and last (inclusive) body row: rows between header and footer rows. */
-    private getBodyRowBounds;
-    private getCellValueAt;
-    /** Rewrites every formula so references follow cells that moved. */
-    private remapAllFormulas;
-    /**
-     * Keeps merges in place when rows/columns are inserted or deleted:
-     * merges after the change shift, merges across it grow or shrink, and
-     * merges reduced to a single cell are dropped.
-     */
-    private adjustTableForStructuralChange;
-    /**
-     * Sorts rows by one or more columns (stable; numbers before text, blanks
-     * last). Without a range (or with a range spanning every column) whole rows
-     * move; with a range only the cells inside it move. Header and footer rows
-     * never move. References follow the moved cells. Returns false when the
-     * sort is rejected (no valid keys, a key outside the range, or merged
-     * cells in the sorted area).
-     */
-    sortRows(keys: SortKey[], options?: {
-        range?: CellRange | null;
-    }): boolean;
-    getFilterState(): SpreadsheetFilterState;
-    /** Replaces all filter rules (and turns filters on when there are any). */
-    setFilterRules(rules: NewFilterRule[]): void;
-    /** Adds a filter rule (AND-combined with the others) and turns filters on. Returns its id. */
-    addFilterRule(rule: NewFilterRule): string;
-    updateFilterRule(ruleId: string, changes: Partial<Omit<FilterRule, 'id'>>): void;
-    removeFilterRule(ruleId: string): void;
-    clearFilters(): void;
-    /** Turns filtering on or off, keeping the rules. */
-    setFiltersEnabled(enabled: boolean): void;
-    toggleFilters(): void;
-    private generateFilterId;
-    setHeaderRowCount(count: number): void;
-    setFooterRowCount(count: number): void;
-    setHeaderColumnCount(count: number): void;
-    /** Keeps the first `count` rows visible while scrolling. 0 unfreezes. */
-    setFrozenRowCount(count: number): void;
-    /** Keeps the first `count` columns visible while scrolling. 0 unfreezes. */
-    setFrozenColumnCount(count: number): void;
-    private setTableCount;
-    /**
-     * Sets an explicit number format code (e.g. `0.00`, `"$"#,##0.00`,
-     * `m/d/yyyy`, `[Red]0;[Blue]-0`) on every cell in `range`, including blank
-     * cells, so values typed later keep it. `null` removes explicit formats: the
-     * cells go back to their column's format or the one chosen for typed input.
-     * Undoable as one step. Returns false when there is no range.
-     */
-    setCellNumberFormat(range: CellRange | null, code: string | null): boolean;
-    /**
-     * Sets the number format code of a column (`null` or `General` clears it).
-     * Its cells without an explicit format of their own use it, including
-     * values typed later; when cleared they go back to the format chosen for
-     * typed input. Undoable.
-     */
-    setColumnNumberFormat(colId: string, code: string | null): void;
-    /** The column's format, or the one typed input chose (typed cells only). */
-    private implicitNumberFormat;
-    /** A copy of `cell` with `numberFormat` set, or removed when undefined. */
-    private withNumberFormat;
-    /** Re-applies the stored cell's (or the column's) format to a spilled value shown there. */
-    private refreshSpilledNumberFormat;
-    hideRows(indices: number[]): void;
-    unhideRows(indices: number[]): void;
-    hideColumns(indices: number[]): void;
-    unhideColumns(indices: number[]): void;
-    /** Unhides every hidden row and column (filters are unaffected). */
-    unhideAll(): void;
-    private setHidden;
-    getMerges(): CellRange[];
-    /** The merge containing (row, col), or null. */
-    getMergeAt(row: number, col: number): CellRange | null;
-    /** Grows `range` until no merge crosses its edge. Keeps the drag direction. */
-    expandRangeToMerges(range: CellRange): CellRange;
-    /**
-     * Merges `range` (default: the selection) into one cell anchored on its
-     * top-left cell; the other cells are cleared. Merges fully inside the range
-     * are absorbed. Returns false for single cells and for ranges that
-     * partially overlap an existing merge.
-     */
-    mergeCells(range?: CellRange | null): boolean;
-    /** Removes every merge intersecting `range` (default: the selection). */
-    unmergeCells(range?: CellRange | null): boolean;
-    /**
-     * Fills `target` from `source` like dragging the fill handle. `target` is
-     * the extended range (source included) and must extend `source` down, up,
-     * right or left. Numbers and dates continue their series, text ending in a
-     * number counts up, other text repeats, and formulas are copied with
-     * their relative references shifted (`$` parts stay). Returns false when
-     * the ranges don't line up.
-     */
-    autofill(source: CellRange, target: CellRange): boolean;
-    /**
-     * Groups body rows by the value in `colId`, with optional per-group
-     * summaries (e.g. `[{ colId, aggregate: 'sum' }]`).
-     */
-    groupRowsBy(colId: string, summaries?: GroupSummary[]): void;
-    ungroupRows(): void;
-    /** Sets (or with `null`, removes) the group summary for a column. */
-    setGroupSummary(colId: string, aggregate: GroupAggregate | null): void;
-    setGroupCollapsed(key: string, collapsed: boolean): void;
-    toggleGroupCollapsed(key: string): void;
-    /** The current row groups with their summaries (empty when not grouped). */
-    getGroups(): SpreadsheetRowGroup[];
-    /**
-     * Transposes `range` (default: the selection) in place around its top-left
-     * cell: rows become columns. Cells left uncovered are cleared, the grid
-     * grows if needed, and references follow the moved cells. Returns false
-     * for single cells or when merged cells are involved.
-     */
-    transposeRange(range?: CellRange | null): boolean;
-    /**
-     * What to render: visible rows (with group headers) and columns in display
-     * order, frozen offsets and merged-cell spans. Filters, hidden rows/columns
-     * and collapsed groups only affect this view, never the document.
-     */
-    getViewModel(): SpreadsheetViewModel;
-    private recordSnapshot;
-    /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
-    private trimHistory;
-    /** Approximate bytes held by the undo/redo snapshots (UTF-16 size). */
-    getHistoryByteSize(): number;
-    /** Number of undo / redo snapshots currently held. */
-    getHistoryDepth(): {
-        undo: number;
-        redo: number;
-    };
-    undo(): void;
-    redo(): void;
-    private notifyChange;
-}
-
-export { type SpreadsheetDataSource as $, type ASTNode as A, type BinaryOpNode as B, type CellCoordinate as C, DEFAULT_COLUMN_WIDTH as D, type EvaluationContext as E, FORMULA_ERRORS as F, type GroupAggregate as G, type NewFilterRule as H, type PropertyRefNode as I, type RowType as J, SPREADSHEET_CLIPBOARD_MIME as K, type LiteralNode as L, MAX_FORMULA_ARRAY_SIZE as M, type NameNode as N, type SortDirection as O, type ParsedSpreadsheetClipboard as P, type SortKey as Q, type RangeNode as R, SpreadsheetController as S, type SpillRefNode as T, type SpreadsheetCellSpan as U, type SpreadsheetClipboardCell as V, type SpreadsheetClipboardData as W, type SpreadsheetClipboardPayload as X, type SpreadsheetClipboardSource as Y, type SpreadsheetColumn as Z, type SpreadsheetControllerOptions as _, type CellData as a, type SpreadsheetDataSourceField as a0, type SpreadsheetDocument as a1, type SpreadsheetFilterState as a2, type SpreadsheetGrouping as a3, type SpreadsheetRow as a4, type SpreadsheetRowGroup as a5, type SpreadsheetRowSection as a6, type SpreadsheetSpill as a7, type SpreadsheetTableSettings as a8, type SpreadsheetViewColumn as a9, rebaseClipboardRows as aA, remapFormulaReferences as aB, rowPassesFilters as aC, serializeHtmlTable as aD, shiftFormulaReferences as aE, sortCompareValues as aF, tokenizeFormula as aG, type SpreadsheetViewModel as aa, type SpreadsheetViewRow as ab, type StructuralChange as ac, type UnaryOpNode as ad, WHOLE_COLUMN_END_ROW as ae, buildSpreadsheetView as af, colNameToIndex as ag, columnDependencyKey as ah, compareNumbers as ai, compareValues as aj, computeRowGroups as ak, createSpreadsheetClipboardData as al, describeFormulaError as am, extractCellDependencies as an, getRowSection as ao, getTableSections as ap, indexToColName as aq, isFormulaError as ar, mapFormulaReferences as as, numberToText as at, offsetFormulaReferences as au, parseCellReference as av, parseFormula as aw, parseHtmlTable as ax, parseRange as ay, readSpreadsheetClipboard as az, type CellDep as b, type CellFormat as c, type CellPosition as d, type CellRange as e, type CellRefNode as f, type CellValueReader as g, type ColumnBinding as h, type ColumnType as i, type CsvExportOptions as j, type CsvImportOptions as k, DEFAULT_ROW_HEIGHT as l, DataSourceBinder as m, DependencyGraph as n, type FilterOperator as o, type FilterRule as p, type FormulaDiagnostic as q, type FormulaErrorCode as r, type FormulaEvaluationResult as s, FormulaEvaluator as t, FormulaParser as u, type FormulaRange as v, type FormulaToken as w, type FormulaTokenType as x, type FunctionCallNode as y, type GroupSummary as z };