@ex-grid/data-xlsx 0.0.0-stage → 0.2.0-beta.3

package/dist/index.d.ts

@@ -0,0 +1,810 @@
+/**
+ * `argb` lightened or darkened by `tint`, as ECMA-376 Part 1, §18.8.19 says: the colour taken to hue, luminance and
+ * saturation, its luminance scaled toward black (`L × (1 + tint)`) or toward white (`L × (1 − tint) + tint`), and taken
+ * back, each channel rounded to the nearest of 0 to 255. Alpha is kept.
+ * @param tint - From -1 (black) to 1 (white).
+ */
+export declare function applyTint(argb: number, tint: number): number;
+
+/** The automatic colour. */
+export declare const automaticColor: XlsxColor;
+
+/** The cells a batch holds at most. */
+export declare const batchSize = 4096;
+
+/** The name of the column `column`, from zero: 0 is `A`, 26 is `AA`. */
+export declare function columnName(column: number): string;
+
+/** A writer of an `.xlsx` workbook (`XlsxWriter`).
+ * @param options - What the workbook says of itself; the defaults when left out. */
+export declare function createXlsxWriter(options?: XlsxWriteOptions): XlsxWriter;
+
+/** The alignment of a cell that writes none. */
+export declare const defaultAlignment: XlsxAlignment;
+
+/** The default indexed palette's 64 colours (ECMA-376 Part 1, §18.8.27), as ARGB values. */
+export declare const defaultIndexedColors: readonly number[];
+
+/** The cells a read allows when the options name none. */
+export declare const defaultMaxCells = 10000000;
+
+/** The uncompressed bytes a read allows when the options name none: 1 GiB. */
+export declare const defaultMaxUncompressedBytes: number;
+
+/** The styles of a workbook that styles nothing: Calibri 11, no fill (and the reserved grey), no border, and one cell
+ * format of all four. */
+export declare const defaultStyles: XlsxStyles;
+
+/** The children an `XlsxElement` keeps of each element, in the file's order. */
+export declare const elementMaxChildren = 16;
+
+/** The levels of children an `XlsxElement` keeps below a worksheet's element. */
+export declare const elementMaxDepth = 3;
+
+/** The characters of an element's own text that an `XlsxElement` keeps. */
+export declare const elementMaxText = 1024;
+
+/** The first Number Format id a styles part defines for itself; the ones below it are built in. */
+export declare const firstCustomNumberFormat = 164;
+
+/** The cell at `row` and `column`, both from zero, as `B7`. */
+export declare function formatCell(row: number, column: number): string;
+
+/** The 12.5% grey pattern Excel reserves as every styles part's second fill. */
+export declare const gray125Fill: XlsxFill;
+
+/** An entry of the indexed palette, 0 to 65. */
+export declare function indexedColor(index: number, tint?: number): XlsxColor;
+
+/**
+ * Whether `name` is a name Excel gives a Table: a letter, `_` or `\`, then letters, digits, `_` and `.`; at most 255
+ * characters; not a cell's address (`A1`, `A01`), not an R1C1 one, `R` or `C`, and not `TRUE` or `FALSE`. Whether another
+ * table or a defined name has it is the workbook's to say.
+ */
+export declare function isValidTableName(name: string): boolean;
+
+/** The columns a worksheet has: 16,384 (A to XFD). */
+export declare const maxColumns = 16384;
+
+/** The rows a worksheet has: 1,048,576. */
+export declare const maxRows = 1048576;
+
+/** No border: the first border of every styles part. */
+export declare const noBorder: XlsxBorder;
+
+/** No line. */
+export declare const noBorderEdge: XlsxBorderEdge;
+
+/** No fill: the first fill of every styles part. */
+export declare const noFill: XlsxFill;
+
+/**
+ * Opens the workbook in `file`, reading its workbook part, shared strings, styles and theme, or refuses it by name
+ * (`XlsxError`). A Blob — a File — is read where its bytes are asked for, through `slice`, and never whole.
+ * @param file - The file's bytes, or a Blob.
+ * @param options - The limits, progress and pacing; the defaults when left out.
+ */
+export declare function openXlsx(file: Uint8Array | ArrayBuffer | Blob, options?: XlsxReadOptions): Promise<XlsxReader>;
+
+/** Reads `B7` into its row and column, from zero; `undefined` for text that is not a cell inside the grid. `$` marks are
+ * allowed. */
+export declare function parseCell(text: string): XlsxPlaceOfCell | undefined;
+
+/** The cell's place as `B7`. */
+export declare function referenceOf(cell: {
+    readonly row: number;
+    readonly column: number;
+}): string;
+
+/** An ARGB value, as `0xFF4472C4`. */
+export declare function rgbColor(argb: number, tint?: number): XlsxColor;
+
+/** A solid fill of `color`. */
+export declare function solidFill(color: XlsxColor): XlsxFill;
+
+/** The cells the table covers, its header's included, as `A1:C4`. */
+export declare function tableReference(table: XlsxTable): string;
+
+/** A theme slot, with a tint: 0 Background 1, 1 Text 1, 2 Background 2, 3 Text 2, 4 to 9 Accents 1 to 6, 10 Hyperlink,
+ * 11 Followed Hyperlink. */
+export declare function themeColor(slot: number, tint?: number): XlsxColor;
+
+/** A cell's alignment, as an `<alignment>` writes it. */
+export declare interface XlsxAlignment {
+    /** Where the text lies across the cell. */
+    readonly horizontal: XlsxHorizontalAlignment;
+    /** Where the text lies up and down the cell. */
+    readonly vertical: XlsxVerticalAlignment;
+    /** Whether the text wraps onto more lines. */
+    readonly wrapText: boolean;
+    /** The indent, in steps. */
+    readonly indent: number;
+    /** The rotation, as the file writes it: 0 to 180, or 255 for stacked text. */
+    readonly textRotation: number;
+    /** Whether the text shrinks to fit the cell's width. */
+    readonly shrinkToFit: boolean;
+}
+
+/** A border of the styles part: four edges and a diagonal. */
+export declare interface XlsxBorder {
+    /** The left edge. */
+    readonly left: XlsxBorderEdge;
+    /** The right edge. */
+    readonly right: XlsxBorderEdge;
+    /** The top edge. */
+    readonly top: XlsxBorderEdge;
+    /** The bottom edge. */
+    readonly bottom: XlsxBorderEdge;
+    /** The diagonal line, drawn where `diagonalUp` or `diagonalDown` says. */
+    readonly diagonal: XlsxBorderEdge;
+    /** Whether the diagonal rises from bottom left to top right. */
+    readonly diagonalUp: boolean;
+    /** Whether the diagonal falls from top left to bottom right. */
+    readonly diagonalDown: boolean;
+}
+
+/** One edge of a border: its line style and colour. */
+export declare interface XlsxBorderEdge {
+    /** The line's style; `none` for no line. */
+    readonly style: XlsxBorderStyle;
+    /** The line's colour, or null for none written. */
+    readonly color: XlsxColor | null;
+}
+
+/** A border line's style: none, or one of Excel's thirteen (ECMA-376 `ST_BorderStyle`). */
+export declare type XlsxBorderStyle = 'none' | 'thin' | 'medium' | 'dashed' | 'dotted' | 'thick' | 'double' | 'hair' | 'mediumDashed' | 'dashDot' | 'mediumDashDot' | 'dashDotDot' | 'mediumDashDotDot' | 'slantDashDot';
+
+/**
+ * One cell as a worksheet writes it (ADR-0330 §9): its place, its type, its value as written, its Formula and its
+ * style. Nothing is interpreted: a number is its text, a Formula its stored text, a style its index into the styles'
+ * cell formats.
+ */
+export declare interface XlsxCell {
+    /** The cell's row, from zero (row 1 is 0). */
+    readonly row: number;
+    /** The cell's column, from zero (column A is 0). */
+    readonly column: number;
+    /** What the value is. */
+    readonly type: XlsxCellType;
+    /** The value as written (`<v>`), or null for a cell with none: a cell that carries only a style, or an inline string. */
+    readonly value: string | null;
+    /** The text of a shared or inline string; otherwise null. */
+    readonly text: string | null;
+    /** The Formula, or null. */
+    readonly formula: XlsxFormula | null;
+    /** The index into the styles' cell formats (`s`); 0 when the cell names none. */
+    readonly styleIndex: number;
+    /** Whether the text came in runs of their own formatting, which are not carried; the text is. */
+    readonly isRichText: boolean;
+}
+
+/** A cell format (`<xf>` of `cellXfs`): what a cell's style index points at. */
+export declare interface XlsxCellFormat {
+    /** The Number Format's id: a built-in one below 164, or one of the styles' own. */
+    readonly numberFormatId: number;
+    /** The index of its font in the styles' fonts. */
+    readonly fontId: number;
+    /** The index of its fill in the styles' fills. */
+    readonly fillId: number;
+    /** The index of its border in the styles' borders. */
+    readonly borderId: number;
+    /** The alignment, or null when the format writes none. */
+    readonly alignment: XlsxAlignment | null;
+}
+
+/** A cell to write. A shared string is written from its `text`, whatever its `value` says. */
+export declare interface XlsxCellInput {
+    /** The cell's row, from zero. */
+    readonly row: number;
+    /** The cell's column, from zero. */
+    readonly column: number;
+    /** What the value is. */
+    readonly type: XlsxCellType;
+    /** The value as written; none when left out. */
+    readonly value?: string | null;
+    /** The text of a shared or inline string. */
+    readonly text?: string | null;
+    /** The Formula. */
+    readonly formula?: XlsxFormulaInput | null;
+    /** The index into the styles' cell formats; 0 when left out. */
+    readonly styleIndex?: number;
+}
+
+/** What a cell's value is, as its `t` attribute writes it (ECMA-376 `ST_CellType`). */
+export declare type XlsxCellType = 
+/** A number (`t="n"`, or no `t`): the value is its decimal text, invariant. A cell with no value is a number with none. */
+'number'
+/** Text held in the shared strings (`t="s"`): the value is its index, and the cell's `text` the text. */
+| 'sharedString'
+/** Text written in the cell itself (`t="inlineStr"`): the cell's `text` is the text. */
+| 'inlineString'
+/** A Formula's text result (`t="str"`): the value is the text. */
+| 'formulaString'
+/** A boolean (`t="b"`): the value is `0` or `1`. */
+| 'boolean'
+/** An Error Value (`t="e"`): the value is its text, as `#DIV/0!`. */
+| 'error'
+/** A date in ISO 8601 (`t="d"`), which Excel itself never writes. */
+| 'date';
+
+/** A colour as the file writes it: an ARGB value, a theme slot, an indexed entry or the automatic colour, each with a
+ * tint. `XlsxTheme.resolve` turns it into the RGB Excel paints (ADR-0330 §8). */
+export declare interface XlsxColor {
+    /** What the colour names. */
+    readonly kind: XlsxColorKind;
+    /** The ARGB value for `rgb` (alpha in the high byte, unsigned), the theme slot for `theme`, the palette index for
+     * `indexed`; 0 for `automatic`. */
+    readonly value: number;
+    /** How far the colour is lightened (positive, up to 1) or darkened (negative, down to -1); 0 for none. */
+    readonly tint: number;
+}
+
+/** What a colour names (ECMA-376 `CT_Color`). */
+export declare type XlsxColorKind = 
+/** The automatic colour (`auto="1"`): the window's text or background, as the place it colours decides. */
+'automatic'
+/** An ARGB value (`rgb`). */
+| 'rgb'
+/** A slot of the workbook's theme (`theme`), resolved through `XlsxTheme`. */
+| 'theme'
+/** An entry of the legacy indexed palette (`indexed`). */
+| 'indexed';
+
+/** A column range's width, as `<col>` writes it. */
+export declare interface XlsxColumn {
+    /** The first column of the range, from zero. */
+    readonly first: number;
+    /** The last column of the range, from zero. */
+    readonly last: number;
+    /** The width in Excel's own unit (characters of the default font's widest digit, with padding), or null when the range
+     * sets none. */
+    readonly width: number | null;
+    /** Whether the columns are hidden. */
+    readonly hidden: boolean;
+    /** The style the columns' empty cells take, or 0. */
+    readonly styleIndex: number;
+    /** Whether the width is marked as fitted to what the columns hold (`bestFit`): where a typed entry widened the column,
+     * or where it was fitted on purpose; the file does not say which. */
+    readonly bestFit: boolean;
+    /** Whether the width is one set for the columns (`customWidth`), rather than the default width written only so that a
+     * range that records a style has a width. */
+    readonly customWidth: boolean;
+}
+
+/** A column range to write; a key left out is the record's default. */
+export declare interface XlsxColumnInput {
+    /** The first column of the range, from zero. */
+    readonly first: number;
+    /** The last column of the range, from zero. */
+    readonly last: number;
+    /** The width in Excel's own unit; none when left out. */
+    readonly width?: number | null;
+    /** Whether the columns are hidden; false when left out. */
+    readonly hidden?: boolean;
+    /** The style the columns' empty cells take; 0 when left out. */
+    readonly styleIndex?: number;
+    /** Whether the width is marked as fitted; false when left out. */
+    readonly bestFit?: boolean;
+    /** Whether the width is one set for the columns; true when left out. */
+    readonly customWidth?: boolean;
+}
+
+/** A defined name, as the workbook part writes it. */
+export declare interface XlsxDefinedName {
+    /** The name, as `Rate`, or a built-in one such as `_xlnm.Print_Area`. */
+    readonly name: string;
+    /** What it refers to, as a Formula's text. */
+    readonly text: string;
+    /** The index of the sheet it is local to, or null for a name of the whole workbook. */
+    readonly localSheet: number | null;
+    /** Whether it is hidden. */
+    readonly hidden: boolean;
+}
+
+/** A defined name to write. */
+export declare interface XlsxDefinedNameInput {
+    /** The name, as `Rate`, or a built-in one such as `_xlnm.Print_Area`. */
+    readonly name: string;
+    /** What it refers to, as a Formula's text. */
+    readonly text: string;
+    /** The index of the sheet it is local to; none, for a name of the whole workbook, when left out. */
+    readonly localSheet?: number | null;
+    /** Whether it is hidden; false when left out. */
+    readonly hidden?: boolean;
+}
+
+/**
+ * An element of a worksheet that the reader does not read, kept as far as a reader of the file needs to judge what it
+ * holds: its name, its attributes, its text, and its children to `elementMaxDepth` levels, the first `elementMaxChildren`
+ * of each. It is never the whole element, and is not written back.
+ */
+export declare interface XlsxElement {
+    /** The element's local name, as `pageMargins`; an extension's without its prefix, as `conditionalFormattings`. */
+    readonly name: string;
+    /** Its attributes by local name (`r:id` is `id`), namespace declarations left out, in the file's order. */
+    readonly attributes: ReadonlyMap<string, string>;
+    /** Its child elements, the first `elementMaxChildren`, to `elementMaxDepth` levels below the worksheet's element. */
+    readonly children: readonly XlsxElement[];
+    /** Its own text, its first `elementMaxText` characters; null when it holds none. */
+    readonly text: string | null;
+    /** Whether it held children that `children` leaves out, past the limits. */
+    readonly childrenCut: boolean;
+}
+
+/**
+ * A file refused by name (ADR-0330 §4, §9): the reason, and the part, the Sheet and the cell it met, as far as the
+ * refusal is about one. Nothing is read from a refused file: `Sheet 'Trades', cell B7: …`.
+ */
+export declare class XlsxError extends Error {
+    /** Why the file was refused. */
+    readonly reason: XlsxRefusal;
+    /** The package part the refusal met, as `xl/worksheets/sheet1.xml`; `undefined` when it is about the file as a whole. */
+    readonly part: string | undefined;
+    /** The name of the Sheet the refusal met; `undefined` when it is not about one Sheet. */
+    readonly sheet: string | undefined;
+    /** The cell the refusal met, as `B7`; `undefined` when it is not about one cell. */
+    readonly cell: string | undefined;
+    /**
+     * A refusal naming what it met.
+     * @param reason - Why the file is refused.
+     * @param message - What was wrong, as a sentence that follows the Sheet and the cell.
+     * @param where - The part, the Sheet and the cell it met, as far as it is about one.
+     * @param options - What caused it, when it was another error.
+     */
+    constructor(reason: XlsxRefusal, message: string, where?: XlsxPlace, options?: ErrorOptions);
+}
+
+/** A fill of the styles part. */
+export declare interface XlsxFill {
+    /** The pattern, as ECMA-376 `ST_PatternType` names it: `none`, `solid`, `gray125`, …; null for a gradient fill. */
+    readonly pattern: string | null;
+    /** The pattern's foreground colour — a solid fill's colour — or null. */
+    readonly foreground: XlsxColor | null;
+    /** The pattern's background colour, or null. */
+    readonly background: XlsxColor | null;
+    /** Whether it is a gradient fill, which carries no pattern. */
+    readonly isGradient: boolean;
+}
+
+/** A font of the styles part. */
+export declare interface XlsxFont {
+    /** The typeface, as `Calibri`, or null. */
+    readonly name: string | null;
+    /** The size in points, or null. */
+    readonly size: number | null;
+    /** Whether it is bold. */
+    readonly bold: boolean;
+    /** Whether it is italic. */
+    readonly italic: boolean;
+    /** How it is underlined. */
+    readonly underline: XlsxUnderline;
+    /** Whether it is struck through. */
+    readonly strike: boolean;
+    /** Its colour, or null for none written. */
+    readonly color: XlsxColor | null;
+}
+
+/** A cell's Formula as the file writes it: its text, without the leading `=`, and how it is shared. */
+export declare interface XlsxFormula {
+    /** The Formula's text as stored, Excel's `_xlfn.` and `_xlws.` prefixes included; empty for a cell that takes a shared
+     * formula from its master. */
+    readonly text: string;
+    /** How it is written. */
+    readonly kind: XlsxFormulaKind;
+    /** The range a shared formula's master or an array formula covers, as `A1:A10`; otherwise null. */
+    readonly reference: string | null;
+    /** A shared formula's group (`si`); otherwise null. */
+    readonly sharedIndex: number | null;
+    /** Whether an array formula is a dynamic array that spills (Excel 365), as the workbook's cell metadata marks one. */
+    readonly isDynamicArray: boolean;
+}
+
+/** A Formula to write: its text, and how it is shared where it is not a cell's own. */
+export declare interface XlsxFormulaInput {
+    /** The Formula's text, without the leading `=`, Excel's prefixes included; empty for a cell that takes a shared formula. */
+    readonly text: string;
+    /** How it is written; `normal` when left out. */
+    readonly kind?: XlsxFormulaKind;
+    /** The range a shared formula's master or an array formula covers; an array formula left without one covers its cell. */
+    readonly reference?: string | null;
+    /** A shared formula's group. */
+    readonly sharedIndex?: number | null;
+    /** Whether an array formula is a dynamic array that spills. */
+    readonly isDynamicArray?: boolean;
+}
+
+/** How a Formula is written (ECMA-376 `ST_CellFormulaType`). */
+export declare type XlsxFormulaKind = 
+/** A Formula of the cell's own. */
+'normal'
+/** A shared formula: the master carries the text, the range it covers and its index; every other cell of the group
+* carries only the index, and its Formula is the master's moved to it. */
+| 'shared'
+/** An array formula over its range: a dynamic array that spills when it says so, and a legacy multi-cell array formula
+* otherwise. */
+| 'array'
+/** A What-If data table. */
+| 'dataTable';
+
+/** A cell's horizontal alignment (ECMA-376 `ST_HorizontalAlignment`). */
+export declare type XlsxHorizontalAlignment = 'general' | 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed';
+
+/** Where a refusal met what it refuses: the part, the Sheet and the cell, as far as it is about one. */
+export declare interface XlsxPlace {
+    /** The package part, as `xl/worksheets/sheet1.xml`. */
+    readonly part?: string | undefined;
+    /** The Sheet's name. */
+    readonly sheet?: string | undefined;
+    /** The cell, as `B7`. */
+    readonly cell?: string | undefined;
+}
+
+/** A cell's place, both from zero. */
+export declare interface XlsxPlaceOfCell {
+    /** The row, from zero (row 1 is 0). */
+    readonly row: number;
+    /** The column, from zero (column A is 0). */
+    readonly column: number;
+}
+
+/** How far a read has come. */
+export declare interface XlsxProgress {
+    /** The index of the worksheet being read, or -1 while the shared strings are. */
+    readonly sheet: number;
+    /** The sheets the workbook lists. */
+    readonly sheets: number;
+    /** The cells read so far, every worksheet counted. */
+    readonly cells: number;
+    /** The worksheets' bytes inflated so far; while the shared strings are read, theirs. */
+    readonly bytes: number;
+    /** The worksheets' uncompressed bytes, as the zip declares them; while the shared strings are read, theirs. */
+    readonly totalBytes: number;
+}
+
+/**
+ * An `.xlsx` workbook opened for reading (ADR-0330 §1, §9): its sheets, defined names, shared strings, styles and theme,
+ * read when it is opened; each worksheet's cells read as a stream through `openSheet`. The model is the file's own: a
+ * number is its text, a Formula its stored text with its prefixes, a style an index. Made by `openXlsx`.
+ */
+export declare interface XlsxReader {
+    /** The workbook part's name, as `xl/workbook.xml`. */
+    readonly workbookPart: string;
+    /** The workbook's sheets, in its order: the order of its tabs. */
+    readonly sheets: readonly XlsxSheetInfo[];
+    /** The index into `sheets` of the sheet the workbook shows (`activeTab`), 0 when it names none. */
+    readonly activeSheet: number;
+    /** Whether the workbook counts dates from 1904 (`date1904`), whose serials are 1,462 less than 1900's for the same day. */
+    readonly date1904: boolean;
+    /** The workbook's defined names. */
+    readonly definedNames: readonly XlsxDefinedName[];
+    /** The shared strings, held whole. */
+    readonly sharedStrings: XlsxSharedStrings;
+    /** The styles, as far as ADR-0330 §4 carries them; `defaultStyles` when the package has no styles part. */
+    readonly styles: XlsxStyles;
+    /** The theme's colours; `XlsxTheme.office` when the package has no theme part (`hasTheme`). */
+    readonly theme: XlsxTheme;
+    /** Whether the package has a theme part of its own. */
+    readonly hasTheme: boolean;
+    /** Every part the package holds, by name, as `xl/comments1.xml`: what else it holds than what is read. */
+    readonly parts: readonly string[];
+    /** The cells read so far, every worksheet counted. */
+    readonly cellsRead: number;
+    /** The worksheets' uncompressed bytes, as the zip declares them. */
+    readonly sheetBytes: number;
+    /** Opens the worksheet at `index` for reading its cells as a stream. One worksheet is read at a time: close the reader
+     * before opening the next. */
+    openSheet(index: number): Promise<XlsxSheetReader>;
+    /** Reads the worksheet at `index` whole: its columns, its cells and what else it holds. For a sheet that is small, or a
+     * test; a large one is read a batch at a time through `openSheet`. */
+    readSheet(index: number): Promise<XlsxWorksheet>;
+}
+
+/** The limits, progress and pacing of a read. A key left out takes the default its comment names. */
+export declare interface XlsxReadOptions {
+    /**
+     * The uncompressed bytes the package may hold, every part counted, as the zip declares them, and that a part may
+     * inflate to: past it the file is refused as `tooLarge`. 1 GiB when left out.
+     */
+    readonly maxUncompressedBytes?: number;
+    /** The cells a read may hold, every worksheet counted: past it the file is refused as `tooManyCells`. 10,000,000
+     * when left out. */
+    readonly maxCells?: number;
+    /** Told how far the read has come after every slice, and once more at the end of the shared strings and of each
+     * worksheet. */
+    readonly onProgress?: (progress: XlsxProgress) => void;
+    /** How long one slice works, in milliseconds, before the read yields; 30 when left out. A slice always does some work,
+     * so 0 yields after every batch. */
+    readonly sliceBudgetMs?: number;
+    /** What the read awaits between slices; a macrotask (`setTimeout(…, 0)`) when left out, which gives a browser a turn
+     * of its event loop to paint in. */
+    readonly yield?: () => Promise<void>;
+    /** Cancels the read: it rejects with the signal's reason, looked at between slices. */
+    readonly signal?: AbortSignal;
+}
+
+/** Why a file was refused (ADR-0330 §4, §9). A refused file is never read in part. */
+export declare type XlsxRefusal = 
+/** The bytes are not a zip package, or the zip is damaged. */
+'notAZip'
+/** A zip package, but not a spreadsheet: it has no workbook part (a `.docx`, a `.pptx`, any other zip). */
+| 'notAWorkbook'
+/** A workbook with macros (`.xlsm`, `.xltm`, `.xlam`): its content types name a macro-enabled workbook or a VBA project. */
+| 'macroEnabled'
+/** A binary workbook (`.xlsb`). */
+| 'binary'
+/** A legacy Excel 97–2003 workbook (`.xls`): an OLE compound file that holds no encrypted package. */
+| 'legacy'
+/** An encrypted (password-protected) workbook: an OLE compound file holding an `EncryptedPackage`. */
+| 'encrypted'
+/** A workbook written as Strict Open XML, whose parts use other namespaces than the transitional ones Excel saves by default. */
+| 'strictOpenXml'
+/** A part declares a document type (`<!DOCTYPE`), which a workbook never needs and an attack uses. */
+| 'dtd'
+/** A part is not well-formed XML, or does not hold what its place in the package says it does. */
+| 'malformed'
+/** The file holds more uncompressed bytes than a read allows; or a workbook written would hold more than a write allows. */
+| 'tooLarge'
+/** The workbook holds more cells than a read allows. */
+| 'tooManyCells';
+
+/** A row that records a cell format of its own (`<row s="…" customFormat="1">`): the format its cells take where the row
+ * holds no cell, in place of their columns'. */
+export declare interface XlsxRow {
+    /** The row, from zero (row 1 is 0). */
+    readonly row: number;
+    /** The index into the styles' cell formats its empty cells take; 0 is the default format, which still stands in place
+     * of the columns'. */
+    readonly styleIndex: number;
+}
+
+/** The workbook's shared strings, held whole, in the part's order, and which of them came in runs of their own
+ * formatting. */
+export declare class XlsxSharedStrings {
+    #private;
+    /** A workbook with no shared strings. */
+    static readonly empty: XlsxSharedStrings;
+    /** The strings `texts`, those at the indexes in `rich` marked as having come in runs. */
+    constructor(texts: readonly string[], rich: ReadonlySet<number>);
+    /** The strings, in the part's order: a cell's `<v>` is an index into them. */
+    get texts(): readonly string[];
+    /** How many there are. */
+    get count(): number;
+    /** Whether the string at `index` came in runs of their own formatting, which are not carried; its text is. */
+    isRich(index: number): boolean;
+}
+
+/** A worksheet as the workbook part lists it. */
+export declare interface XlsxSheetInfo {
+    /** Its name, as its tab shows it. */
+    readonly name: string;
+    /** Its `sheetId`. */
+    readonly sheetId: number;
+    /** Whether it is shown. */
+    readonly visibility: XlsxSheetVisibility;
+    /** The package part that holds it, as `xl/worksheets/sheet1.xml`, or null for a sheet that is not a worksheet. */
+    readonly part: string | null;
+    /** What kind of sheet it is. */
+    readonly kind: XlsxSheetKind;
+}
+
+/** What kind of sheet a workbook lists. */
+export declare type XlsxSheetKind = 
+/** A worksheet of cells. */
+'worksheet'
+/** A chart sheet, or any other sheet that holds no cells. */
+| 'other';
+
+/**
+ * One worksheet's cells read as a stream (ADR-0330 §9): `read` reads the next batch into `cells`, row by row as the file
+ * holds them, and between batches the read reports its progress and yields once a slice has spent its budget. Made by
+ * `XlsxReader.openSheet`; close it before opening the next.
+ */
+export declare interface XlsxSheetReader {
+    /** The sheet as the workbook lists it. */
+    readonly sheet: XlsxSheetInfo;
+    /** The cells of the batch the last `read` read, in the file's order. */
+    readonly cells: readonly XlsxCell[];
+    /** The rows the last `read` began that record a cell format of their own (`customFormat`), in the file's order. A row
+     * comes in the batch that holds its first cell, or in an earlier one. */
+    readonly rows: readonly XlsxRow[];
+    /** The worksheet's column widths, complete once the first `read` has returned: they come before the cells. */
+    readonly columns: readonly XlsxColumn[];
+    /**
+     * Every element of the worksheet the reader does not read, beside its cells and columns, in the file's order, complete
+     * once `read` has returned false: `dimension`, `sheetViews` (of which only `frozenPanes` is read), `sheetFormatPr`,
+     * `mergeCells`, `conditionalFormatting`, `dataValidations`, `hyperlinks`, `drawing`, `legacyDrawing` (notes),
+     * `tableParts`, `sheetProtection`, `pageMargins`, `pageSetup`, `extLst` and the rest, each as far as `XlsxElement`
+     * keeps it. None of it is judged here: whether an element holds anything that matters is for the reader of the file to
+     * say.
+     */
+    readonly otherElements: readonly XlsxElement[];
+    /** Whether a row read so far sets a height of its own. */
+    readonly customRowHeights: boolean;
+    /** Whether a row read so far is hidden. */
+    readonly hiddenRows: boolean;
+    /** Whether the sheet's view freezes panes; known once the first `read` has returned. */
+    readonly frozenPanes: boolean;
+    /** Reads the next batch of cells into `cells`; false when the worksheet has no more. Refuses the file by name
+     * (`XlsxError`) on a cell it cannot read, or past the read's cells. */
+    read(): Promise<boolean>;
+    /** Closes the worksheet's part. */
+    close(): Promise<void>;
+}
+
+/** Whether a sheet is shown. */
+export declare type XlsxSheetVisibility = 
+/** Shown. */
+'visible'
+/** Hidden, and listed in Excel's Unhide. */
+| 'hidden'
+/** Hidden, and not listed in Excel's Unhide. */
+| 'veryHidden';
+
+/**
+ * One worksheet being written (`XlsxWriter.addSheet`): its cells, row by row and left to right. A cell out of that order,
+ * or one written twice, is refused.
+ */
+export declare interface XlsxSheetWriter {
+    /** The sheet's name. */
+    readonly name: string;
+    /**
+     * Adds an Excel Table over cells of this sheet (`tableParts`, and a table part of its own), before the first cell of its
+     * header's row is written. Each cell of its header must then be written, as text equal to its column's name (a shared
+     * or inline string, no Formula), or the cell, or the sheet's end, is refused; its rows of data hold whatever is written
+     * there. A table whose name is another table's or a defined name's in the workbook, in any case, or that overlaps
+     * another table of the sheet, is refused.
+     */
+    addTable(table: XlsxTable): void;
+    /** Begins `row` with the cell format of its own that its empty cells take (`customFormat`), after every row written
+     * before it; the row's cells, if any, are then written as any others. A row written before, or one that already holds
+     * a cell, is refused. */
+    writeRow(row: XlsxRow): void;
+    /** Writes `cell`, after every cell written before it in the sheet's order. A shared string is written from its `text`
+     * into the workbook's shared strings, whatever its `value` says. */
+    write(cell: XlsxCellInput): void;
+    /** Writes every cell of `cells` in turn, flushing between batches. */
+    writeAll(cells: Iterable<XlsxCellInput>): Promise<void>;
+    /** Awaits the deflating of what is written so far, so that memory holds it compressed: call it between batches of a
+     * large sheet. */
+    flush(): Promise<void>;
+}
+
+/**
+ * The styles part as far as ADR-0330 §4 carries it: the custom Number Formats, the fonts, fills and borders, and the cell
+ * formats that cells point at. What else the part holds (named cell styles, differential formats, table styles) is not
+ * read.
+ */
+export declare interface XlsxStyles {
+    /** The custom Number Formats by id (164 and above, or a built-in id written over), each its format code. */
+    readonly numberFormats: ReadonlyMap<number, string>;
+    /** The fonts, which a cell format names by index. */
+    readonly fonts: readonly XlsxFont[];
+    /** The fills, the first two of which Excel reserves: `none` and `gray125`. */
+    readonly fills: readonly XlsxFill[];
+    /** The borders, which a cell format names by index. */
+    readonly borders: readonly XlsxBorder[];
+    /** The cell formats, which a cell's style index names; the first is the one a cell of no style takes. */
+    readonly cellFormats: readonly XlsxCellFormat[];
+    /** The indexed palette written over (`<colors><indexedColors>`), as ARGB values, or null when the file keeps the default one. */
+    readonly indexedColors: readonly number[] | null;
+}
+
+/**
+ * An Excel Table on a worksheet (ECMA-376 Part 1, §18.5), as a sheet writer's `addTable` writes it: a header row holding
+ * each column's name, its rows of data below, an AutoFilter over them and Excel's default table style.
+ */
+export declare interface XlsxTable {
+    /** The name a Formula reads it by (`Positions[PV]`), as Excel names a Table (`isValidTableName`), and no other table's or
+     * defined name's in the workbook, in any case. */
+    readonly name: string;
+    /** The header's row, from zero. */
+    readonly headerRow: number;
+    /** The first column, from zero. */
+    readonly firstColumn: number;
+    /** The columns' names, in order: at least one, none empty, no two the same in any case. */
+    readonly columns: readonly string[];
+    /** The rows of data below the header: at least one, as Excel holds a table of none as one empty row. */
+    readonly dataRows: number;
+    /** Whether the header's cells carry an AutoFilter's buttons, as a table Excel makes does; true when left out. */
+    readonly autoFilter?: boolean;
+}
+
+/**
+ * The colours of a workbook's theme (`<a:clrScheme>`), and the resolution of any colour a style writes into the RGB
+ * Excel paints (ADR-0330 §8): a theme slot through these colours, an indexed entry through the palette, and the tint
+ * applied to the result as ECMA-376 Part 1, §18.8.19 says.
+ */
+export declare class XlsxTheme {
+    /**
+     * The theme of Office 2013–2022, which a workbook with no theme part takes: dark 1 `000000`, light 1 `FFFFFF`,
+     * `44546A`, `E7E6E6`, the accents `4472C4`, `ED7D31`, `A5A5A5`, `FFC000`, `5B9BD5`, `70AD47`, and the hyperlinks
+     * `0563C1` and `954F72`.
+     */
+    static readonly office: XlsxTheme;
+    /** The scheme's twelve colours as ARGB values, in the scheme's order: dark 1, light 1, dark 2, light 2, accents 1 to 6,
+     * hyperlink, followed hyperlink. */
+    readonly schemeColors: readonly number[];
+    /** A theme of the twelve colours its scheme lists, as ARGB values in the scheme's own order. */
+    constructor(schemeColors: readonly number[]);
+    /**
+     * The colour a style's theme slot names. A style numbers the first four slots in another order than the scheme lists
+     * them — 0 is light 1 (Background 1), 1 dark 1 (Text 1), 2 light 2, 3 dark 2 — and the rest as listed.
+     */
+    slotColor(slot: number): number;
+    /**
+     * The RGB value, as `0xFFRRGGBB`, that `color` paints, or `undefined` for the automatic colour (and the indexed entries
+     * 64 and 65, which name the window's text and background), whose meaning the place it colours decides.
+     * @param indexedColors - The styles part's own indexed palette, or none for the default one.
+     */
+    resolve(color: XlsxColor, indexedColors?: readonly number[] | null): number | undefined;
+}
+
+/** How a font underlines (ECMA-376 `ST_UnderlineValues`). */
+export declare type XlsxUnderline = 'none' | 'single' | 'double' | 'singleAccounting' | 'doubleAccounting';
+
+/** A cell's vertical alignment (ECMA-376 `ST_VerticalAlignment`). */
+export declare type XlsxVerticalAlignment = 'bottom' | 'top' | 'center' | 'justify' | 'distributed';
+
+/** A worksheet read whole (`XlsxReader.readSheet`). */
+export declare interface XlsxWorksheet {
+    /** The sheet as the workbook lists it. */
+    readonly sheet: XlsxSheetInfo;
+    /** Its column widths. */
+    readonly columns: readonly XlsxColumn[];
+    /** Its cells, in the file's order: row by row, left to right. */
+    readonly cells: readonly XlsxCell[];
+    /** What else it holds, as `XlsxSheetReader.otherElements` lists it. */
+    readonly otherElements: readonly XlsxElement[];
+    /** The rows that record a cell format of their own, in order; empty for none. */
+    readonly rows: readonly XlsxRow[];
+    /** Whether a row sets a height of its own. */
+    readonly customRowHeights: boolean;
+    /** Whether a row is hidden. */
+    readonly hiddenRows: boolean;
+    /** Whether the sheet's view freezes panes. */
+    readonly frozenPanes: boolean;
+}
+
+/** What a written workbook says of itself, beside its sheets. A key left out takes the default its comment names. */
+export declare interface XlsxWriteOptions {
+    /** The styles the cells' style indexes point into; `defaultStyles` when left out. */
+    readonly styles?: XlsxStyles;
+    /** The index of the sheet the workbook shows when it opens; 0 when left out. */
+    readonly activeSheet?: number;
+    /** Whether the workbook counts dates from 1904; the serials written are the caller's. False when left out. */
+    readonly date1904?: boolean;
+    /** Whether the workbook asks to be calculated in full when Excel opens it (`fullCalcOnLoad`): every Formula is written
+     * with its Value, and Excel computes them again (ADR-0330 §6). False when left out. */
+    readonly fullCalculationOnLoad?: boolean;
+    /** The defined names the workbook part writes; none when left out. */
+    readonly definedNames?: readonly XlsxDefinedNameInput[];
+    /**
+     * The uncompressed bytes the package's parts may hold together, 1 to 1 GiB; 1 GiB, the most a file is read with by
+     * default, when left out, so that what is written opens again. A write that would go past it is refused by name
+     * (`XlsxError`, `tooLarge`), naming the part, and the sheet, it met; the workbook is then abandoned.
+     */
+    readonly maxUncompressedBytes?: number;
+}
+
+/**
+ * Writes an `.xlsx` workbook as a stream (ADR-0330 §1): each worksheet's cells go into the package as they are written,
+ * and the parts that need every sheet at `complete`. Made by `createXlsxWriter`.
+ */
+export declare interface XlsxWriter {
+    /**
+     * Begins the next worksheet, after the ones before it, ending the one being written. Its cells are then written in the
+     * order of the sheet: row by row, left to right.
+     * @param name - The sheet's name: 1 to 31 characters, none of `[ ] : * ? / \` and no control character or half of a
+     * surrogate pair, not beginning or ending with `'`, and no other sheet's in any case.
+     * @param columns - The column widths: ranges that do not overlap, each naming a cell format the styles hold.
+     * @param visibility - Whether the sheet is shown; `visible` when left out.
+     */
+    addSheet(name: string, columns?: readonly XlsxColumnInput[], visibility?: XlsxSheetVisibility): XlsxSheetWriter;
+    /** Ends the last worksheet, writes the parts that need every sheet, and returns the package. The workbook needs a sheet,
+     * and the options' active sheet must name one of them. */
+    complete(): Promise<Blob>;
+    /** Abandons a workbook not completed, writing nothing more. */
+    abandon(): Promise<void>;
+}
+
+export { }