@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/validation.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Data validation, Excel's: a rule over some cells says what may be typed
+ * into them, and an entry that breaks it is stopped (or warned about)
+ * before it lands. Only typed entries are checked, as in Excel: paste, fill
+ * and the commands write what they are given.
+ *
+ * Rules keep their rectangles by position and move with an insert or
+ * delete; the last rule that covers a cell is the one that applies, which
+ * is what lets a later rule over a smaller block override an earlier one.
+ * Bounds and custom rules are text (a literal or a formula) evaluated in
+ * the sheet through the context the shell supplies, so `=$B$1` as a
+ * maximum follows B1.
+ */
+import { type CellValue } from './ast.js';
+import type { StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+export type ValidationAllow = 'any' | 'whole' | 'decimal' | 'list' | 'date' | 'textLength' | 'custom';
+export type ValidationOperator = 'between' | 'notBetween' | 'equal' | 'notEqual' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual';
+/** Everything a rule is but where it applies: what the dialog hands back. */
+export type ValidationSpec = Omit<ValidationRule, 'id' | 'rects'>;
+export type ValidationRule = {
+    id: string;
+    rects: ReadonlyArray<Rect>;
+    allow: ValidationAllow;
+    /** For whole, decimal, date and textLength. Default between. */
+    operator?: ValidationOperator;
+    /** The bound, the value, the list source or the custom formula: a
+     *  literal, a comma list, or a formula starting with '='. */
+    value1?: string;
+    /** The upper bound of between / notBetween. */
+    value2?: string;
+    ignoreBlank: boolean;
+    /** List rules: show the arrow and the picker on the cell. */
+    inCellDropdown: boolean;
+    alert: {
+        style: 'stop' | 'warning';
+        title?: string;
+        message?: string;
+    };
+    /** Excel's Input Message: shown under the cell while it is selected.
+     *  Absent when the rule has none. */
+    input?: {
+        title?: string;
+        message?: string;
+    };
+};
+/** How a rule reads the sheet: the shell wires the workbook in. */
+export type ValidationContext = {
+    /**
+     * A formula or a literal, evaluated in the sheet. With `entry`, the
+     * cell being checked reads as that text: Excel's custom rules refer to
+     * the cell they guard (`=A1>B1` on A1), and the entry is not written yet.
+     */
+    evaluate(text: string, entry?: {
+        row: number;
+        col: number;
+        text: string;
+    }): CellValue;
+    /** The values of a range reference or a name for one; null otherwise. */
+    range(text: string): CellValue[][] | null;
+};
+export type ValidationVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    style: 'stop' | 'warning';
+    title: string;
+    message: string;
+};
+/** Excel's own words when a rule has no message of its own. */
+export declare const DEFAULT_ALERT_MESSAGE = "This value doesn't match the data validation restrictions defined for this cell.";
+export declare const OPERATOR_LABELS: Record<ValidationOperator, string>;
+export declare function validationId(): string;
+/** The rule that applies to (r, c): the last one covering it. */
+export declare function ruleAt(rules: ReadonlyArray<ValidationRule>, r: number, c: number): ValidationRule | undefined;
+/** The rules touching any of the rectangles. */
+export declare function rulesIn(rules: ReadonlyArray<ValidationRule>, rects: ReadonlyArray<Rect>): ValidationRule[];
+/** A date as milliseconds: an ISO text, or an Excel serial. Null otherwise. */
+export declare function dateValue(v: CellValue): number | null;
+/**
+ * The choices a list rule offers: a comma list as written, or the cells of
+ * a range (or a name for one), blanks left out, as text.
+ */
+export declare function listChoices(rule: ValidationRule, ctx: ValidationContext): string[];
+/**
+ * Whether `text`, typed into (row, col), passes the rule. The verdict
+ * carries the alert to show when it does not.
+ */
+export declare function checkEntry(rule: ValidationRule, text: string, at: {
+    row: number;
+    col: number;
+}, ctx: ValidationContext): ValidationVerdict;
+/** The rules after an insert or delete. */
+export declare function shiftValidation(rules: ReadonlyArray<ValidationRule>, edit: StructuralEdit): ValidationRule[];
+/** The rules with the rectangles cut out of them: Excel's Clear All. */
+export declare function removeValidation(rules: ReadonlyArray<ValidationRule>, rects: ReadonlyArray<Rect>): ValidationRule[];
+/** A short description for a rule, the way Excel's dialog title reads it. */
+export declare function describeRule(rule: ValidationRule): string;
+/**
+ * Excel's Circle Invalid Data: every cell under a rule whose current text
+ * breaks it. Blank cells count when the rule says they do. The rectangles
+ * are clipped to `rows` by `cols`, the sheet's used extent, so a rule over
+ * a whole column costs the cells that hold something.
+ */
+export declare function invalidCells(rules: ReadonlyArray<ValidationRule>, ctx: ValidationContext, rawAt: (row: number, col: number) => string, rows: number, cols: number): Array<{
+    row: number;
+    col: number;
+}>;

package/dist/sheet/validation.js

@@ -0,0 +1,278 @@
+/**
+ * Data validation, Excel's: a rule over some cells says what may be typed
+ * into them, and an entry that breaks it is stopped (or warned about)
+ * before it lands. Only typed entries are checked, as in Excel: paste, fill
+ * and the commands write what they are given.
+ *
+ * Rules keep their rectangles by position and move with an insert or
+ * delete; the last rule that covers a cell is the one that applies, which
+ * is what lets a later rule over a smaller block override an earlier one.
+ * Bounds and custom rules are text (a literal or a formula) evaluated in
+ * the sheet through the context the shell supplies, so `=$B$1` as a
+ * maximum follows B1.
+ */
+import { isError } from './ast.js';
+import { toText } from './coerce.js';
+import { parseEntry } from './entry.js';
+import { translateFormula } from './refs.js';
+import { rectContains, shiftRects, subtractRect, rectsIntersect } from './rects.js';
+/** Excel's own words when a rule has no message of its own. */
+export const DEFAULT_ALERT_MESSAGE = "This value doesn't match the data validation restrictions defined for this cell.";
+export const OPERATOR_LABELS = {
+    between: 'between',
+    notBetween: 'not between',
+    equal: 'equal to',
+    notEqual: 'not equal to',
+    greater: 'greater than',
+    less: 'less than',
+    greaterOrEqual: 'greater than or equal to',
+    lessOrEqual: 'less than or equal to',
+};
+let nextId = 1;
+export function validationId() {
+    nextId += 1;
+    return `v${Date.now().toString(36)}${nextId}`;
+}
+/** The rule that applies to (r, c): the last one covering it. */
+export function ruleAt(rules, r, c) {
+    for (let i = rules.length - 1; i >= 0; i -= 1) {
+        const rule = rules[i];
+        if (rule.rects.some((rect) => rectContains(rect, r, c)))
+            return rule;
+    }
+    return undefined;
+}
+/** The rules touching any of the rectangles. */
+export function rulesIn(rules, rects) {
+    return rules.filter((rule) => rule.rects.some((a) => rects.some((b) => rectsIntersect(a, b))));
+}
+/** What the typed text is worth: a formula's result, or the literal coerced. */
+function entered(text, ctx) {
+    const t = text.trim();
+    if (t.startsWith('='))
+        return ctx.evaluate(t);
+    const parsed = parseEntry(t);
+    const plain = parsed ? parsed.value : t;
+    const n = Number(plain);
+    if (plain !== '' && Number.isFinite(n))
+        return n;
+    const upper = plain.toUpperCase();
+    if (upper === 'TRUE')
+        return true;
+    if (upper === 'FALSE')
+        return false;
+    return plain;
+}
+/** A date as milliseconds: an ISO text, or an Excel serial. Null otherwise. */
+export function dateValue(v) {
+    if (typeof v === 'number')
+        return Date.UTC(1899, 11, 30) + v * 86400000;
+    if (typeof v !== 'string' || !v.trim())
+        return null;
+    if (!/^\d{4}-\d{2}-\d{2}/.test(v.trim()))
+        return null;
+    const ms = Date.parse(v.trim().length === 10 ? `${v.trim()}T00:00:00Z` : v.trim());
+    return Number.isNaN(ms) ? null : ms;
+}
+/**
+ * A bound or a source, moved from the rule's top-left cell to the cell being
+ * checked, as Excel moves a relative reference in a rule: `=A2` as the
+ * minimum of G2:G17 reads A5 on G5, while `=$B$1` stays put.
+ */
+function relative(text, rule, at) {
+    if (text === undefined || !text.trim().startsWith('='))
+        return text;
+    const origin = rule.rects[0];
+    if (!origin)
+        return text;
+    return String(translateFormula(text.trim(), at.row - origin[0], at.col - origin[1]));
+}
+function bound(text, ctx, as) {
+    if (text === undefined || text.trim() === '')
+        return null;
+    const v = ctx.evaluate(text);
+    if (isError(v))
+        return null;
+    if (as === 'date')
+        return dateValue(v);
+    if (typeof v === 'boolean')
+        return null;
+    const n = typeof v === 'number' ? v : Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+function compareTo(x, op, a, b) {
+    if (a === null)
+        return false;
+    switch (op) {
+        case 'between': return b !== null && x >= Math.min(a, b) && x <= Math.max(a, b);
+        case 'notBetween': return b !== null && (x < Math.min(a, b) || x > Math.max(a, b));
+        case 'equal': return x === a;
+        case 'notEqual': return x !== a;
+        case 'greater': return x > a;
+        case 'less': return x < a;
+        case 'greaterOrEqual': return x >= a;
+        case 'lessOrEqual': return x <= a;
+    }
+}
+/**
+ * The choices a list rule offers: a comma list as written, or the cells of
+ * a range (or a name for one), blanks left out, as text.
+ */
+export function listChoices(rule, ctx) {
+    const source = (rule.value1 ?? '').trim();
+    if (!source)
+        return [];
+    if (source.startsWith('=')) {
+        const grid = ctx.range(source);
+        if (grid) {
+            const out = [];
+            for (const row of grid)
+                for (const v of row) {
+                    if (v === '' || v == null)
+                        continue;
+                    out.push(isError(v) ? v.error : toText(v));
+                }
+            return out;
+        }
+        const v = ctx.evaluate(source);
+        return isError(v) ? [] : [toText(v)];
+    }
+    return source.split(',').map((s) => s.trim()).filter((s) => s !== '');
+}
+/**
+ * Whether `text`, typed into (row, col), passes the rule. The verdict
+ * carries the alert to show when it does not.
+ */
+export function checkEntry(rule, text, at, ctx) {
+    const fail = () => ({
+        ok: false,
+        style: rule.alert.style,
+        title: rule.alert.title?.trim() || 'Data validation',
+        message: rule.alert.message?.trim() || DEFAULT_ALERT_MESSAGE,
+    });
+    if (rule.allow === 'any')
+        return { ok: true };
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return rule.ignoreBlank ? { ok: true } : fail();
+    const op = rule.operator ?? 'between';
+    switch (rule.allow) {
+        case 'whole':
+        case 'decimal': {
+            const v = entered(text, ctx);
+            if (typeof v !== 'number' || !Number.isFinite(v))
+                return fail();
+            if (rule.allow === 'whole' && !Number.isInteger(v))
+                return fail();
+            return compareTo(v, op, bound(relative(rule.value1, rule, at), ctx, 'number'), bound(relative(rule.value2, rule, at), ctx, 'number')) ? { ok: true } : fail();
+        }
+        case 'date': {
+            const ms = dateValue(entered(text, ctx));
+            if (ms === null)
+                return fail();
+            return compareTo(ms, op, bound(relative(rule.value1, rule, at), ctx, 'date'), bound(relative(rule.value2, rule, at), ctx, 'date')) ? { ok: true } : fail();
+        }
+        case 'textLength': {
+            const v = entered(text, ctx);
+            const length = isError(v) ? 0 : toText(v).length;
+            return compareTo(length, op, bound(relative(rule.value1, rule, at), ctx, 'number'), bound(relative(rule.value2, rule, at), ctx, 'number')) ? { ok: true } : fail();
+        }
+        case 'list': {
+            // Excel matches a list entry without regard to case.
+            const v = entered(text, ctx);
+            const shown = isError(v) ? v.error : toText(v);
+            const needle = shown.toLowerCase();
+            return listChoices(rule, ctx).some((choice) => choice.toLowerCase() === needle) ? { ok: true } : fail();
+        }
+        case 'custom': {
+            const formula = (rule.value1 ?? '').trim();
+            if (!formula)
+                return fail();
+            // The formula is written for the rule's top-left cell and moves with
+            // the cell it checks, as a copied formula would.
+            const origin = rule.rects[0];
+            const source = formula.startsWith('=') ? formula : `=${formula}`;
+            const moved = origin
+                ? String(translateFormula(source, at.row - origin[0], at.col - origin[1]))
+                : source;
+            const v = ctx.evaluate(moved, { row: at.row, col: at.col, text });
+            if (isError(v))
+                return fail();
+            const truthy = typeof v === 'boolean' ? v : typeof v === 'number' ? v !== 0 : false;
+            return truthy ? { ok: true } : fail();
+        }
+        default:
+            return { ok: true };
+    }
+}
+/** The rules after an insert or delete. */
+export function shiftValidation(rules, edit) {
+    return shiftRects(rules, edit);
+}
+/** The rules with the rectangles cut out of them: Excel's Clear All. */
+export function removeValidation(rules, rects) {
+    const out = [];
+    for (const rule of rules) {
+        let kept = [...rule.rects];
+        for (const hole of rects)
+            kept = kept.flatMap((rect) => subtractRect(rect, hole));
+        if (kept.length)
+            out.push({ ...rule, rects: kept });
+    }
+    return out;
+}
+/** A short description for a rule, the way Excel's dialog title reads it. */
+export function describeRule(rule) {
+    const op = OPERATOR_LABELS[rule.operator ?? 'between'];
+    const v1 = rule.value1 ?? '';
+    const v2 = rule.value2 ?? '';
+    const range = (rule.operator ?? 'between') === 'between' || rule.operator === 'notBetween'
+        ? `${v1} and ${v2}`
+        : v1;
+    switch (rule.allow) {
+        case 'any': return 'Any value';
+        case 'whole': return `Whole number ${op} ${range}`;
+        case 'decimal': return `Decimal ${op} ${range}`;
+        case 'date': return `Date ${op} ${range}`;
+        case 'textLength': return `Text length ${op} ${range}`;
+        case 'list': return `List: ${v1}`;
+        case 'custom': return `Custom: ${v1}`;
+    }
+}
+/**
+ * Excel's Circle Invalid Data: every cell under a rule whose current text
+ * breaks it. Blank cells count when the rule says they do. The rectangles
+ * are clipped to `rows` by `cols`, the sheet's used extent, so a rule over
+ * a whole column costs the cells that hold something.
+ */
+export function invalidCells(rules, ctx, rawAt, rows, cols) {
+    const out = [];
+    const seen = new Set();
+    for (const rule of rules) {
+        if (rule.allow === 'any')
+            continue;
+        for (const [r1, c1, r2, c2] of rule.rects) {
+            const rowEnd = Math.min(r2, rows - 1);
+            const colEnd = Math.min(c2, cols - 1);
+            for (let r = Math.max(0, r1); r <= rowEnd; r += 1) {
+                for (let c = Math.max(0, c1); c <= colEnd; c += 1) {
+                    const key = r * 1048576 + c;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    // The rule that applies is the last one covering the cell, which
+                    // may not be this one.
+                    const applies = ruleAt(rules, r, c);
+                    if (!applies || applies.allow === 'any')
+                        continue;
+                    const text = rawAt(r, c);
+                    if (text.trim() === '' && applies.ignoreBlank)
+                        continue;
+                    if (!checkEntry(applies, text, { row: r, col: c }, ctx).ok)
+                        out.push({ row: r, col: c });
+                }
+            }
+        }
+    }
+    return out;
+}

package/dist/sheet/workbook.d.ts

@@ -0,0 +1,217 @@
+import { type SheetFunction } from './functions.js';
+import { isError, type CellValue } from './ast.js';
+import { type TableRegion, type TableRegistry } from './tables.js';
+import { type SheetNames } from './names.js';
+import { type CellMove, type StructuralEdit } from './refs.js';
+import { type SheetEngine } from './engine.js';
+export type SheetData = {
+    name: string;
+    /** Row-major raw text. Ragged is fine; a missing cell reads as empty. */
+    cells: string[][];
+};
+/**
+ * Excel's Enable iterative calculation, under File > Options > Formulas.
+ *
+ * A circular reference is normally an error: every cell in the loop shows
+ * #CYCLE!. Some models are written as one on purpose, though, because the
+ * answer is a fixed point rather than a mistake: a bonus that is a share of
+ * the profit the bonus is subtracted from, an interest charge on a balance
+ * the charge is added to. Excel solves those by running the loop over and
+ * over from the values it last had, and stopping when either the answer
+ * stops moving or the passes run out.
+ */
+export type IterationSettings = {
+    /** Off by default, which is Excel's default and keeps a cycle an error. */
+    enabled: boolean;
+    /** Passes before the answer is taken as it stands. Excel's default is 100. */
+    maxIterations: number;
+    /** The largest move that still counts as settled. Excel's default is 0.001. */
+    maxChange: number;
+};
+export declare const DEFAULT_ITERATION: IterationSettings;
+/** Excel's text prefix. A cell typed as `'007` holds the text `007`: the
+ *  apostrophe says "what follows is text", and it is not part of the value,
+ *  so it is never displayed, printed, exported or compared. */
+export declare const TEXT_PREFIX = "'";
+/** The value a typed text stands for once the prefix is taken off. */
+export declare const withoutTextPrefix: (text: string) => string;
+export type WorkbookOptions = {
+    /** Extra functions merged over the built-ins. */
+    functions?: Record<string, SheetFunction>;
+    /** Fires after a recalculation, with the cells whose value changed. */
+    onRecalc?(changed: ReadonlyArray<{
+        sheet: string;
+        row: number;
+        col: number;
+        value: CellValue;
+    }>): void;
+    /**
+     * Fires for every RAW WRITE, with the text as typed rather than the value
+     * it computes: one call per `setRaw` that changed something, and one per
+     * cell a structural edit rewrote. This is the seam a delta stream reads
+     * (`sheet/delta.ts`), since a collaborator has to receive `=SUM(A1:A9)`
+     * rather than 42.
+     */
+    onWrite?(change: {
+        sheet: string;
+        row: number;
+        col: number;
+        text: string;
+    }): void;
+    /**
+     * What works a formula out. The built-in parser and evaluator unless an
+     * application hands over an evaluator of its own. The workbook keeps the
+     * dependency graph, the cache, the cycles and the spills whichever engine
+     * answers.
+     */
+    engine?: SheetEngine;
+    /** Tables the workbook starts with, for a document being restored. */
+    tables?: ReadonlyArray<TableRegion>;
+    /** Iterative calculation, off unless a model needs it. */
+    iteration?: Partial<IterationSettings>;
+};
+/** One cell read as text that has not been written: what a validation rule checks. */
+export type CellOverride = {
+    row: number;
+    col: number;
+    text: string;
+};
+export type Workbook = {
+    readonly sheets: ReadonlyArray<string>;
+    readonly active: string;
+    readonly names: SheetNames;
+    /**
+     * Excel's tables, which is what a structured reference resolves through.
+     * Defining one here is what makes `=SUM(Orders[Amount])` mean anything;
+     * the shell's Insert > Table does it, and a document restores it.
+     */
+    readonly tables: TableRegistry;
+    setActive(name: string): void;
+    addSheet(name?: string, at?: number): string;
+    removeSheet(name: string): boolean;
+    renameSheet(from: string, to: string): boolean;
+    moveSheet(name: string, to: number): boolean;
+    /**
+     * Copy a sheet's cells into a new sheet placed right after it, named
+     * `to` or Excel's "Name (2)", and make it active. The new sheet's
+     * formulas read their own sheet where the old ones read theirs, because
+     * an unqualified reference is relative to the sheet it sits on. Returns
+     * the new name, or null when `from` is unknown or `to` is taken.
+     */
+    copySheet(from: string, to?: string): string | null;
+    /** The raw text of a cell: the formula as typed, or the literal. */
+    getRaw(sheet: string, row: number, col: number): string;
+    /** Write raw text and recalculate whatever depends on it. */
+    setRaw(sheet: string, row: number, col: number, text: string): void;
+    /** The computed value. */
+    getValue(sheet: string, row: number, col: number): CellValue;
+    /** Every cell of a sheet, computed. */
+    snapshot(sheet: string): CellValue[][];
+    /**
+     * What `text` would be worth in a cell of `sheet`, without putting it in
+     * one: a formula is evaluated there (names and other sheets included), a
+     * literal is coerced the way a typed one is. Data validation checks its
+     * bounds and custom rules through this, and conditional formatting its
+     * formula rules, with `at` naming the cell the text is read for.
+     */
+    evaluateText(sheet: string, text: string, override?: CellOverride, at?: {
+        row: number;
+        col: number;
+    }): CellValue;
+    /**
+     * The values of a range reference, or of a name that refers to one, as a
+     * grid; null when `text` is not a reference. A list source.
+     */
+    evaluateRange(sheet: string, text: string): CellValue[][] | null;
+    /**
+     * Tell the workbook which rows are folded away, and by what: `'filter'`
+     * for an AutoFilter, `'hand'` for Hide Rows, null for a row on the
+     * screen. Only `SUBTOTAL` reads it, which is how a total under a filtered
+     * list follows the filter. Pass null to forget the source again.
+     */
+    setHiddenRows(source: ((sheet: string, row: number) => 'filter' | 'hand' | null) | null): void;
+    /** Apply a structural edit to one sheet, rewriting every formula in the
+     *  WORKBOOK that pointed into it. */
+    applyStructuralEdit(sheet: string, edit: StructuralEdit): void;
+    /**
+     * A block of cells has been MOVED (cut and pasted, or dragged): point
+     * every reference to those cells at where they now are, across the whole
+     * workbook and the defined names, as Excel does. The cells themselves are
+     * moved by whoever did the moving; this is only the repointing.
+     */
+    repointAfterMove(move: CellMove): void;
+    /**
+     * Excel's Trace Precedents: the cells a formula reads directly, on any
+     * sheet. Empty for a literal. A whole-column reference contributes its
+     * used rows.
+     */
+    precedents(sheet: string, row: number, col: number): Array<{
+        sheet: string;
+        row: number;
+        col: number;
+    }>;
+    /**
+     * Excel's Trace Dependents: the formulas that read a cell directly. Every
+     * formula in the workbook is evaluated first, so a dependent that was
+     * never on screen is found too.
+     */
+    dependents(sheet: string, row: number, col: number): Array<{
+        sheet: string;
+        row: number;
+        col: number;
+    }>;
+    /**
+     * Hear about every raw write, with the text as typed. Returns the
+     * unsubscribe. The delta stream reads this; a mirror of the cells in
+     * another store can too.
+     */
+    subscribeWrites(listener: (change: {
+        sheet: string;
+        row: number;
+        col: number;
+        text: string;
+    }) => void): () => void;
+    /** Recompute everything. Rarely needed; `setRaw` keeps itself current. */
+    recalculate(): void;
+    /** How circular references are treated, as the Formulas tab sets it. */
+    readonly iteration: IterationSettings;
+    /**
+     * Turn iterative calculation on or off, or change its limits, and
+     * recalculate: the cells in a cycle go from #CYCLE! to their fixed point,
+     * or back.
+     */
+    setIteration(next: Partial<IterationSettings>): void;
+    /**
+     * The spill a cell belongs to: the anchor holding the array formula and
+     * the rectangle its answer covers, for the anchor itself and every cell
+     * it spills into; null for a cell that is neither.
+     */
+    spillOf(sheet: string, row: number, col: number): {
+        anchor: {
+            row: number;
+            col: number;
+        };
+        rect: readonly [number, number, number, number];
+    } | null;
+    /** Every spill on a sheet, anchors computed, for a writer that saves the ranges. */
+    spills(sheet: string): Array<{
+        row: number;
+        col: number;
+        rect: readonly [number, number, number, number];
+    }>;
+    rowCount(sheet: string): number;
+    colCount(sheet: string): number;
+    serialize(): {
+        sheets: SheetData[];
+        active: string;
+        names: Record<string, string>;
+        tables?: TableRegion[];
+        iteration?: IterationSettings;
+    };
+};
+/** A name Excel would accept for a sheet. */
+export declare function isValidSheetName(name: string): boolean;
+/** Iteration settings with the defaults filled in and the numbers sane. */
+export declare function cleanIteration(next?: Partial<IterationSettings> | null): IterationSettings;
+export declare function createWorkbook(initial?: ReadonlyArray<SheetData>, options?: WorkbookOptions): Workbook;
+export { isError };