@xlvane/compat 0.0.0-stage → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,3661 @@
+import { StreamSheetSpec, Workbook as Workbook$1, WorkbookProperties as WorkbookProperties$1 } from "xlvane";
+/**
+ * A cell location of a defined name, as exceljs keeps it.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS, { type NameCell } from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.definedNames.add('Data!$B$2', 'total');
+ * workbook.definedNames.forEach((name: string, cell: NameCell) => console.log(name, cell.sheetName, cell.address)); // total Data B2
+ * ```
+ */
+interface NameCell {
+  sheetName: string | undefined;
+  address: string;
+  row: number;
+  col: number;
+  /** @internal Used while grouping cells into ranges. */
+  mark?: boolean;
+}
+/**
+ * A location parsed by exceljs `colCache.decodeEx`: one cell, a range, or an error reference.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS, { type DecodedLocation } from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * const location: DecodedLocation = { sheetName: 'Data', row: 2, col: 2 };
+ * workbook.definedNames.addEx(location, 'total');
+ * console.log(workbook.definedNames.getNamesEx(location)); // ['total']
+ * ```
+ */
+interface DecodedLocation {
+  sheetName?: string | undefined;
+  row?: number | undefined;
+  col?: number | undefined;
+  top?: number;
+  left?: number;
+  bottom?: number;
+  right?: number;
+  error?: string;
+}
+/**
+ * The cells of one defined name, as exceljs `CellMatrix`: sheet → row → column.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.definedNames.add('Data!$A$1:$A$3', 'items');
+ * workbook.definedNames.getMatrix('items').forEach((cell) => console.log(cell.address)); // A1 A2 A3
+ * ```
+ */
+export declare class CellMatrix {
+  /** @internal */
+  readonly sheets: Map<string | undefined, (NameCell | undefined)[][]>;
+  addCell(addressStr: string): void;
+  getCell(addressStr: string): NameCell | undefined;
+  findCell(addressStr: string): NameCell | undefined;
+  findCellAt(sheetName: string | undefined, rowNumber: number, colNumber: number): NameCell | undefined;
+  addCellEx(address: DecodedLocation): void;
+  getCellEx(address: DecodedLocation): NameCell | undefined;
+  findCellEx(address: DecodedLocation, create: boolean): NameCell | undefined;
+  getCellAt(sheetName: string | undefined, rowNumber: number, colNumber: number): NameCell;
+  removeCellEx(address: DecodedLocation): void;
+  forEachInSheet(sheetName: string | undefined, callback: (cell: NameCell, row: number, col: number) => void): void;
+  forEach(callback: (cell: NameCell) => void): void;
+  /**
+   * @internal The keys of `sheets` that name `sheetName`, ignoring case as spreadsheet
+   * applications compare sheet names (xlvane addition; exceljs compares exactly).
+   */
+  sheetKeys(sheetName: string | undefined): (string | undefined)[];
+  /** Removes `numDelete` rows at `start` and inserts `numInsert` empty ones (cell-matrix.js L138). */
+  spliceRows(sheetName: string | undefined, start: number, numDelete: number, numInsert: number): void;
+  /** Removes `numDelete` columns at `start` and inserts `numInsert` empty ones (cell-matrix.js L150). */
+  spliceColumns(sheetName: string | undefined, start: number, numDelete: number, numInsert: number): void;
+  map<T>(callback: (cell: NameCell) => T): T[];
+}
+/**
+ * Defined names of a workbook, as exceljs `workbook.definedNames`. A name is a set of cells; when
+ * the workbook is written, the cells are grouped into rectangles with absolute references
+ * (`Sheet!$A$1:$B$2`), and names that hold no cells are left out, as in exceljs.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.addWorksheet('Data');
+ * workbook.definedNames.add('Data!$A$1:$B$2', 'block');
+ * console.log(workbook.definedNames.getRanges('block')); // { name: 'block', ranges: ['Data!$A$1:$B$2'] }
+ * console.log(workbook.definedNames.getNames('Data!B2')); // ['block']
+ * ```
+ */
+export declare class DefinedNames {
+  /** @internal */
+  matrixMap: Map<string, CellMatrix>;
+  getMatrix(name: string): CellMatrix;
+  /** Adds the cells of `locStr` (`Sheet!$A$1` or `Sheet!$A$1:$B$2`) to the name. */
+  add(locStr: string, name: string): void;
+  addEx(location: DecodedLocation, name: string): void;
+  remove(locStr: string, name: string): void;
+  removeEx(location: DecodedLocation, name: string): void;
+  removeAllNames(location: DecodedLocation): void;
+  forEach(callback: (name: string, cell: NameCell) => void): void;
+  /** The names that include the cell `addressStr` (`Sheet!A1`). */
+  getNames(addressStr: string): string[];
+  getNamesEx(address: DecodedLocation): string[];
+  private explore;
+  /** Gives moved cells their new row and column (lib/doc/defined-names.js L147). */
+  normaliseMatrix(matrix: CellMatrix, sheetName: string | undefined): void;
+  spliceRows(sheetName: string | undefined, start: number, numDelete: number, numInsert: number): void;
+  spliceColumns(sheetName: string | undefined, start: number, numDelete: number, numInsert: number): void;
+  /**
+   * xlvane addition: after `numInsert` rows (or columns) were inserted at `start`, adds the
+   * inserted cells to every name that has cells on both sides of them in the same column (or row),
+   * so a named range grows as in a spreadsheet application. exceljs leaves a gap (X4-15).
+   */
+  fillInserted(sheetName: string | undefined, axis: "row" | "col", start: number, numInsert: number): void;
+  /** The cells of a name grouped into ranges, as exceljs `getRanges` (lib/doc/defined-names.js L125). */
+  getRanges(name: string, matrix?: CellMatrix): {
+    name: string;
+    ranges: string[];
+  };
+  /** Every name with at least one cell, as `{ name, ranges }`. */
+  get model(): {
+    name: string;
+    ranges: string[];
+  }[];
+  set model(value: {
+    name: string;
+    ranges: string[];
+  }[]);
+}
+/** Workbook-level data written with the sheets: document properties and defined names. */
+interface WorkbookMeta {
+  readonly properties?: WorkbookProperties$1;
+  readonly definedNames?: readonly {
+    name: string;
+    ranges: string[];
+  }[];
+  /** The workbook's images, by exceljs image id (`workbook.addImage`). */
+  readonly media?: readonly ImageData[];
+  /** `false` writes no cell or column styles, as exceljs `xlsx.write(…, { useStyles: false })` (dates keep format 14). */
+  readonly useStyles?: boolean;
+  /** `workbook.views` (workbook windows). */
+  readonly views?: readonly Record<string, unknown>[];
+  /** `workbook.calcProperties`. */
+  readonly calcProperties?: Record<string, unknown>;
+}
+/**
+ * Options of `xlsx.load`, `read` and `readFile`, as exceljs `XlsxReadOptions` (index.d.ts L1460;
+ * lib/xlsx/xlsx.js L257, lib/xlsx/xform/sheet/worksheet-xform.js L95, L372; X4-25).
+ *
+ * @example
+ * ```ts
+ * import type { XlsxReadOptions } from '@xlvane/compat';
+ *
+ * const options: XlsxReadOptions = { ignoreNodes: ['dataValidations'], maxRows: 100_000 };
+ * ```
+ */
+interface XlsxReadOptions {
+  /** Worksheet elements to skip, by element name (`sheetData`, `mergeCells`, `hyperlinks`, `dataValidations`, …). */
+  ignoreNodes?: string[];
+  /** Refuse a worksheet with more rows than this (`XLV_E_LIMIT_EXCEEDED`). */
+  maxRows?: number;
+  /** Refuse a row with more cells than this (`XLV_E_LIMIT_EXCEEDED`). */
+  maxCols?: number;
+  /** `load` only: the data is a base64 string. */
+  base64?: boolean;
+}
+/**
+ * Options of `xlsx.writeBuffer`, `write` and `writeFile`, as exceljs `XlsxWriteOptions`
+ * (index.d.ts L1447–1472; lib/xlsx/xlsx.js L602–603). `useSharedStrings: false` writes inline
+ * strings; `zip: { compression: 'STORE' }` or `zip: { compressionOptions: { level } }` sets the
+ * Deflate level (0–9).
+ *
+ * @example
+ * ```ts
+ * import type { XlsxWriteOptions } from '@xlvane/compat';
+ *
+ * const options: XlsxWriteOptions = { useStyles: false };
+ * ```
+ */
+interface XlsxWriteOptions {
+  /** `false` writes no cell or column styles; dates keep format 14, as in exceljs. */
+  useStyles?: boolean;
+  useSharedStrings?: boolean;
+  zip?: Record<string, unknown>;
+}
+/** A writable Node.js stream, as accepted by `xlsx.write()`. */
+interface WritableLike$1 {
+  write(chunk: Uint8Array): unknown;
+  end(callback?: () => void): unknown;
+  once?(event: string, listener: (error?: unknown) => void): unknown;
+}
+/**
+ * The `xlsx` property of a {@link Workbook}: reading and writing XLSX files.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.addWorksheet('Data').getCell('A1').value = 'Hello';
+ * const buffer = await workbook.xlsx.writeBuffer();
+ * const copy = await new ExcelJS.Workbook().xlsx.load(buffer);
+ * console.log(copy.getWorksheet('Data')?.getCell('A1').value); // Hello
+ * ```
+ */
+export declare class XlsxIO {
+  private readonly workbook;
+  /** @internal */
+  constructor(workbook: Workbook);
+  /** Reads XLSX bytes into the workbook (its sheets are replaced) and returns the workbook. */
+  load(data: Uint8Array | ArrayBuffer | string, options?: XlsxReadOptions): Promise<Workbook>;
+  /** Reads an XLSX file (Node.js). */
+  readFile(path: string, options?: XlsxReadOptions): Promise<Workbook>;
+  /** Reads XLSX data from a readable stream (Node.js stream or any async iterable of bytes). */
+  read(stream: AsyncIterable<Uint8Array>, options?: XlsxReadOptions): Promise<Workbook>;
+  /** Writes the workbook and returns the file contents (a Buffer in Node.js). */
+  writeBuffer(options?: XlsxWriteOptions): Promise<Uint8Array>;
+  /** Writes the workbook to a file, replacing an existing file as exceljs does (Node.js). */
+  writeFile(path: string, options?: XlsxWriteOptions): Promise<void>;
+  /** Writes the workbook to a writable stream and ends it. */
+  write(stream: WritableLike$1, options?: XlsxWriteOptions): Promise<void>;
+  /** Removed in exceljs 4 (it throws there too); use `read`. */
+  createInputStream(): never;
+  /** Reads image files given by `filename`, as exceljs does when it writes (xlsx.js L426–429). */
+  private loadFiles;
+  private book;
+  private bytes;
+}
+/**
+ * A workbook, as exceljs `Workbook`. Use `xlsx` to read and write files.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.creator = 'Me';
+ * const sheet = workbook.addWorksheet('My Sheet');
+ * sheet.addRow(['Name', 'Total']);
+ * sheet.addRow(['Tea', 3.5]);
+ * await workbook.xlsx.writeFile('report.xlsx');
+ * ```
+ */
+export declare class Workbook {
+  /** Written to `docProps/core.xml`; `"Unknown"` when not set, as exceljs (lib/doc/workbook.js L155). */
+  creator: string | undefined;
+  lastModifiedBy: string | undefined;
+  created: Date | undefined;
+  modified: Date | undefined;
+  lastPrinted: Date | undefined;
+  title: string | undefined;
+  subject: string | undefined;
+  keywords: string | undefined;
+  category: string | undefined;
+  description: string | undefined;
+  language: string | undefined;
+  revision: string | number | undefined;
+  contentStatus: string | undefined;
+  /** Written to `docProps/app.xml`, always (`company || ''`), as exceljs (X4-13). */
+  company: string | undefined;
+  /** Written to `docProps/app.xml` when defined, as exceljs (X4-13). */
+  manager: string | undefined;
+  /** Workbook properties; `date1904: true` selects the 1904 date system. */
+  properties: {
+    date1904?: boolean;
+    [key: string]: unknown;
+  };
+  calcProperties: Record<string, unknown>;
+  views: Record<string, unknown>[];
+  /** @internal */
+  _sheets: (Worksheet | undefined)[];
+  private _xlsx;
+  private _csv;
+  get xlsx(): XlsxIO;
+  /** CSV reading and writing, as exceljs `workbook.csv` (X4-23, X4-24). */
+  get csv(): CsvIO;
+  private readonly _definedNames;
+  /** Defined names, as exceljs `workbook.definedNames`. */
+  get definedNames(): DefinedNames;
+  /** @internal The document properties and defined names to write, as exceljs `workbook.model`. */
+  _meta(): WorkbookMeta;
+  /** @internal */
+  get _date1904(): boolean;
+  /** @internal Names of the other sheets, for the duplicate check of Worksheet.name. */
+  readonly _names: (exclude: Worksheet) => string[];
+  /** The id the next worksheet gets (lib/doc/workbook.js `nextId`). */
+  get nextId(): number;
+  /** Adds a worksheet. Names follow exceljs rules (31 characters at most; longer names are cut). */
+  addWorksheet(name?: string, options?: WorksheetOptions): Worksheet;
+  removeWorksheet(id: number | string): void;
+  /** Removes a worksheet by id or name, as `removeWorksheet` (lib/doc/workbook.js L77). */
+  removeWorksheetEx(worksheet: Worksheet): void;
+  /**
+   * exceljs keeps the theme of a loaded file and `clearThemes()` drops it (lib/doc/workbook.js
+   * L137). xlvane never keeps or writes a theme part, so there is nothing to clear.
+   */
+  clearThemes(): void;
+  /**
+   * A plain-data snapshot of the workbook, as exceljs `workbook.model` (lib/doc/workbook.js L153):
+   * the document properties, `views`, `calcProperties`, the defined names, the media and the
+   * worksheets' `model`. The setter rebuilds the workbook from such a snapshot (X4-30).
+   */
+  get model(): Record<string, unknown>;
+  set model(value: Record<string, unknown>);
+  /** A worksheet by id or name; the first worksheet without an argument; `undefined` if none. */
+  getWorksheet(id?: number | string): Worksheet | undefined;
+  /** Worksheets in workbook order. */
+  get worksheets(): Worksheet[];
+  eachSheet(iteratee: (sheet: Worksheet, id: number) => void): void;
+  /** @internal Images of the workbook, as exceljs `workbook.media`. */
+  _media: ImageData[];
+  /**
+   * Adds an image (PNG, JPEG or GIF, or EMF or WMF as Excel stores them; recognised from its bytes) and returns its id for
+   * `worksheet.addImage` and `addBackgroundImage`, as exceljs `workbook.addImage`. Give `buffer`,
+   * `base64` or `filename`; a file is read when the workbook is written (Node.js, Bun, Deno), as
+   * in exceljs.
+   */
+  addImage(image: ImageData): number;
+  /**
+   * The image with this id, as exceljs `workbook.getImage`. Typed `Image` as in exceljs
+   * (index.d.ts L1780); at run time an unknown id gives `undefined`, as in exceljs
+   * (lib/doc/workbook.js L149-151).
+   */
+  getImage(id: number): Image;
+  /**
+   * @internal Replaces the sheets with those of a workbook read by xlvane. `options.ignoreNodes`
+   * skips what exceljs skips for those worksheet elements, and `maxRows`/`maxCols` refuse
+   * bigger worksheets (worksheet-xform.js L95, L372; list-xform.js L75; row-xform.js L119; X4-25).
+   */
+  _fill(read: Workbook$1, options?: XlsxReadOptions): void;
+}
+/**
+ * Options of `workbook.csv.read` and `readFile`, as exceljs `CsvReadOptions`.
+ *
+ * @example
+ * ```ts
+ * import type { CsvReadOptions } from '@xlvane/compat';
+ *
+ * const options: CsvReadOptions = { sheetName: 'Data', parserOptions: { delimiter: ';' } };
+ * ```
+ */
+interface CsvReadOptions {
+  /** Formats tried, in order, for text that is not a number (dayjs tokens, strict, local time). */
+  dateFormats?: string[];
+  /** Turns each field into a cell value; replaces the default conversion. */
+  map?(value: string, index: number): unknown;
+  /** Name of the worksheet that is added; exceljs's default name `sheetN` otherwise. */
+  sheetName?: string;
+  /** fast-csv parser options: `delimiter`, `quote`, `escape`, `trim`, `ltrim`, `rtrim`, `ignoreEmpty`, `comment`, `skipLines`, `skipRows`, `maxRows`, `headers`, `renameHeaders`, `encoding`. */
+  parserOptions?: Record<string, unknown>;
+}
+/**
+ * Options of `workbook.csv.write`, `writeFile` and `writeBuffer`, as exceljs `CsvWriteOptions`,
+ * plus `formulaInjection`.
+ *
+ * @example
+ * ```ts
+ * import type { CsvWriteOptions } from '@xlvane/compat';
+ *
+ * const options: CsvWriteOptions = { sheetName: 'Data', dateFormat: 'DD/MM/YYYY', formatterOptions: { delimiter: ';' } };
+ * ```
+ */
+interface CsvWriteOptions {
+  /** dayjs format for dates; ISO 8601 with offset otherwise. */
+  dateFormat?: string;
+  /** Format dates in UTC instead of local time. */
+  dateUTC?: boolean;
+  sheetName?: string;
+  sheetId?: number;
+  /** Character set of `writeFile`: `utf8` (default), `utf16le` or `latin1`. */
+  encoding?: string;
+  /** Turns each cell value into a field; replaces the default conversion. */
+  map?(value: unknown, index: number): unknown;
+  /** Blank lines for missing rows (default `true`). */
+  includeEmptyRows?: boolean;
+  /** fast-csv formatter options: `delimiter`, `rowDelimiter`, `quote`, `escape`, `quoteColumns`, `headers`, `writeHeaders`, `includeEndRowDelimiter`, `writeBOM`. */
+  formatterOptions?: Record<string, unknown>;
+  /**
+   * `"escape"` (default): text that starts with `=`, `+`, `-`, `@`, tab, CR or LF (or their
+   * full-width forms) is written with a leading `'`, so spreadsheet applications show it as text
+   * (OWASP CSV Injection). `"off"`: written unchanged, as exceljs does. An xlvane option.
+   */
+  formulaInjection?: "escape" | "off";
+}
+/**
+ * The `csv` property of a {@link Workbook}: CSV reading and writing as exceljs `workbook.csv`.
+ * Reading adds a worksheet; writing takes one worksheet. Formula-like text is escaped on writing
+ * unless `formulaInjection: "off"` is given.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * workbook.addWorksheet('Data').addRow(['Tea', 3.5]);
+ * const buffer = await workbook.csv.writeBuffer();
+ * console.log(new TextDecoder().decode(buffer)); // Tea,3.5
+ * ```
+ */
+export declare class CsvIO {
+  private readonly workbook;
+  /** @internal */
+  constructor(workbook: Workbook);
+  /** Reads CSV from a stream into a new worksheet and returns it. */
+  read(stream: unknown, options?: CsvReadOptions): Promise<Worksheet>;
+  /** Reads a CSV file (Node.js, Bun, Deno) into a new worksheet. */
+  readFile(path: string, options?: CsvReadOptions): Promise<Worksheet>;
+  /** Writes a worksheet as CSV to a stream and ends it. */
+  write(stream: unknown, options?: CsvWriteOptions): Promise<void>;
+  /** Writes a worksheet to a CSV file (Node.js, Bun, Deno), replacing it. */
+  writeFile(path: string, options?: CsvWriteOptions): Promise<void>;
+  /** The CSV of a worksheet as bytes (a Buffer in Node.js), UTF-8 encoded. */
+  writeBuffer(options?: CsvWriteOptions): Promise<Uint8Array>;
+  /** Removed in exceljs 4 (it throws there too); use `read`. */
+  createInputStream(): never;
+  private text;
+}
+/**
+ * The bytes exceljs returns from `writeBuffer()` (a Node.js Buffer in Node.js, a `Uint8Array` elsewhere); exceljs `Buffer` (index.d.ts L1).
+ *
+ * @example
+ * ```ts
+ * import type { Buffer } from '@xlvane/compat';
+ * const value: Buffer | undefined = new Uint8Array(0);
+ * console.log(value);
+ * ```
+ */
+type Buffer = Uint8Array;
+/**
+ * Paper sizes of `pageSetup.paperSize`, as exceljs `PaperSize` (index.d.ts L18).
+ *
+ * @example
+ * ```ts
+ * import { PaperSize } from '@xlvane/compat';
+ *
+ * const size: PaperSize = PaperSize.A4;
+ * console.log(size); // 9
+ * ```
+ */
+export declare const PaperSize: {
+  readonly Legal: 5;
+  readonly Executive: 7;
+  readonly A4: 9;
+  readonly A5: 11;
+  readonly B5: 13;
+  readonly Envelope_10: 20;
+  readonly Envelope_DL: 27;
+  readonly Envelope_C5: 28;
+  readonly Envelope_B5: 34;
+  readonly Envelope_Monarch: 37;
+  readonly Double_Japan_Postcard_Rotated: 82;
+  readonly K16_197x273_mm: 119;
+};
+/** A value of {@link PaperSize}. */
+export type PaperSize = (typeof PaperSize)[keyof typeof PaperSize];
+/**
+ * One colour stop of a gradient fill (exceljs `GradientStop`, index.d.ts L174).
+ *
+ * @example
+ * ```ts
+ * import type { GradientStop } from '@xlvane/compat';
+ * const value: GradientStop | undefined = { position: 0, color: { argb: 'FFFFFFFF' } };
+ * console.log(value);
+ * ```
+ */
+interface GradientStop {
+  position: number;
+  color: Partial<Color>;
+}
+/**
+ * A linear gradient fill (exceljs `FillGradientAngle`, index.d.ts L179).
+ *
+ * @example
+ * ```ts
+ * import type { FillGradientAngle } from '@xlvane/compat';
+ * const value: FillGradientAngle | undefined = { type: 'gradient', gradient: 'angle', degree: 90, stops: [{ position: 0, color: { argb: 'FFFFFFFF' } }, { position: 1, color: { argb: 'FF0070C0' } }] };
+ * console.log(value);
+ * ```
+ */
+interface FillGradientAngle {
+  type: "gradient";
+  gradient: "angle";
+  degree: number;
+  stops: GradientStop[];
+}
+/**
+ * A path gradient fill (exceljs `FillGradientPath`, index.d.ts L197).
+ *
+ * @example
+ * ```ts
+ * import type { FillGradientPath } from '@xlvane/compat';
+ * const value: FillGradientPath | undefined = { type: 'gradient', gradient: 'path', center: { left: 0.5, top: 0.5 }, stops: [] };
+ * console.log(value);
+ * ```
+ */
+interface FillGradientPath {
+  type: "gradient";
+  gradient: "path";
+  center: {
+    left: number;
+    top: number;
+  };
+  stops: GradientStop[];
+}
+/**
+ * A diagonal border (exceljs `BorderDiagonal`, index.d.ts L253).
+ *
+ * @example
+ * ```ts
+ * import type { BorderDiagonal } from '@xlvane/compat';
+ * const value: BorderDiagonal | undefined = { style: 'thin', color: { argb: 'FF000000' }, up: true, down: false };
+ * console.log(value);
+ * ```
+ */
+interface BorderDiagonal extends Border {
+  up: boolean;
+  down: boolean;
+}
+/**
+ * Page margins in inches (exceljs `Margins`, index.d.ts L266).
+ *
+ * @example
+ * ```ts
+ * import type { Margins } from '@xlvane/compat';
+ * const value: Margins | undefined = { top: 0.75, left: 0.7, bottom: 0.75, right: 0.7, header: 0.3, footer: 0.3 };
+ * console.log(value);
+ * ```
+ */
+interface Margins {
+  top: number;
+  left: number;
+  bottom: number;
+  right: number;
+  header: number;
+  footer: number;
+}
+/**
+ * Operators of a data validation (exceljs `DataValidationOperator`, index.d.ts L304).
+ *
+ * @example
+ * ```ts
+ * import type { DataValidationOperator } from '@xlvane/compat';
+ * const value: DataValidationOperator | undefined = 'between';
+ * console.log(value);
+ * ```
+ */
+type DataValidationOperator = "between" | "notBetween" | "equal" | "notEqual" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual";
+/**
+ * One run of rich text (exceljs `RichText`, index.d.ts L336).
+ *
+ * @example
+ * ```ts
+ * import type { RichText } from '@xlvane/compat';
+ * const value: RichText | undefined = { text: 'Bold', font: { bold: true } };
+ * console.log(value);
+ * ```
+ */
+interface RichText {
+  text: string;
+  font?: Partial<Font>;
+}
+/**
+ * A rich-text cell value (exceljs `CellRichTextValue`, index.d.ts L341).
+ *
+ * @example
+ * ```ts
+ * import type { CellRichTextValue } from '@xlvane/compat';
+ * const value: CellRichTextValue | undefined = { richText: [{ text: 'a' }, { text: 'b', font: { italic: true } }] };
+ * console.log(value);
+ * ```
+ */
+interface CellRichTextValue {
+  richText: RichText[];
+}
+/**
+ * A hyperlink cell value (exceljs `CellHyperlinkValue`, index.d.ts L345).
+ *
+ * @example
+ * ```ts
+ * import type { CellHyperlinkValue } from '@xlvane/compat';
+ * const value: CellHyperlinkValue | undefined = { text: 'Site', hyperlink: 'https://example.com' };
+ * console.log(value);
+ * ```
+ */
+interface CellHyperlinkValue {
+  text: string;
+  hyperlink: string;
+  tooltip?: string;
+}
+/**
+ * A decoded cell address (exceljs `Address`, index.d.ts L1622).
+ *
+ * @example
+ * ```ts
+ * import type { Address } from '@xlvane/compat';
+ * const value: Address | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface Address {
+  sheetName?: string;
+  address: string;
+  col: string;
+  row: string;
+  $col$row: string;
+}
+/**
+ * The data of one cell as exceljs `CellModel` (index.d.ts L410). `cell.model` returns xlvane's own snapshot with these fields where they apply.
+ *
+ * @example
+ * ```ts
+ * import type { CellModel } from '@xlvane/compat';
+ * const value: CellModel | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface CellModel {
+  address: string;
+  style: Partial<Style>;
+  type: ValueType;
+  text?: string;
+  hyperlink?: string;
+  value?: CellValue;
+  master?: string;
+  formula?: string;
+  sharedFormula?: string;
+  result?: unknown;
+  comment?: unknown;
+}
+/**
+ * The data of one row (exceljs `RowModel`, index.d.ts L511).
+ *
+ * @example
+ * ```ts
+ * import type { RowModel } from '@xlvane/compat';
+ * const value: RowModel | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface RowModel {
+  cells: CellModel[];
+  number: number;
+  min: number;
+  max: number;
+  height: number;
+  style: Partial<Style>;
+  hidden: boolean;
+  outlineLevel: number;
+  collapsed: boolean;
+}
+/**
+ * The autofilter of a worksheet (exceljs `AutoFilter`, index.d.ts L864).
+ *
+ * @example
+ * ```ts
+ * import type { AutoFilter } from '@xlvane/compat';
+ * const value: AutoFilter | undefined = 'A1:C1';
+ * console.log(value);
+ * ```
+ */
+type AutoFilter = string | {
+  from: string | {
+    row: number;
+    column: number;
+  };
+  to: string | {
+    row: number;
+    column: number;
+  };
+};
+/**
+ * An image for `workbook.addImage()` (exceljs `Image`, index.d.ts L887). `filename` works only in Node.js, Bun and Deno.
+ *
+ * @example
+ * ```ts
+ * import type { Image } from '@xlvane/compat';
+ * const value: Image | undefined = { extension: 'png', base64: 'iVBORw0KGgo=' };
+ * console.log(value);
+ * ```
+ */
+interface Image {
+  extension: "jpeg" | "png" | "gif";
+  base64?: string;
+  filename?: string;
+  buffer?: Uint8Array;
+}
+/**
+ * Two corners of a picture (exceljs `ImageRange`, index.d.ts L915).
+ *
+ * @example
+ * ```ts
+ * import type { ImageRange } from '@xlvane/compat';
+ * const value: ImageRange | undefined = { tl: { col: 0, row: 0 }, br: { col: 2, row: 3 } };
+ * console.log(value);
+ * ```
+ */
+interface ImageRange {
+  tl: IAnchorPosition;
+  br: IAnchorPosition;
+}
+/**
+ * A picture corner given by column and row, counted from 0 (the `tl`/`br` positions of exceljs `ImageRange`).
+ *
+ * @example
+ * ```ts
+ * import type { IAnchorPosition } from '@xlvane/compat';
+ * const value: IAnchorPosition | undefined = { col: 1, row: 2 };
+ * console.log(value);
+ * ```
+ */
+interface IAnchorPosition {
+  col: number;
+  row: number;
+}
+/**
+ * A picture corner plus a size in pixels (exceljs `ImagePosition`, index.d.ts L920).
+ *
+ * @example
+ * ```ts
+ * import type { ImagePosition } from '@xlvane/compat';
+ * const value: ImagePosition | undefined = { tl: { col: 0, row: 0 }, ext: { width: 120, height: 60 } };
+ * console.log(value);
+ * ```
+ */
+interface ImagePosition {
+  tl: {
+    col: number;
+    row: number;
+  };
+  ext: {
+    width: number;
+    height: number;
+  };
+}
+/**
+ * The link of a picture (exceljs `ImageHyperlinkValue`, index.d.ts L925).
+ *
+ * @example
+ * ```ts
+ * import type { ImageHyperlinkValue } from '@xlvane/compat';
+ * const value: ImageHyperlinkValue | undefined = { hyperlink: 'https://example.com' };
+ * console.log(value);
+ * ```
+ */
+interface ImageHyperlinkValue {
+  hyperlink: string;
+  tooltip?: string;
+}
+/**
+ * A rectangle of cells, 1-based (exceljs `Location`, index.d.ts L1630).
+ *
+ * @example
+ * ```ts
+ * import type { Location } from '@xlvane/compat';
+ * const value: Location | undefined = { top: 1, left: 1, bottom: 3, right: 2 };
+ * console.log(value);
+ * ```
+ */
+interface Location {
+  top: number;
+  left: number;
+  bottom: number;
+  right: number;
+}
+/**
+ * A range of cells as exceljs `Range` (index.d.ts L930), the type of `worksheet.dimensions`.
+ *
+ * @example
+ * ```ts
+ * import type { Range } from '@xlvane/compat';
+ * const value: Range | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface Range extends Location {
+  readonly tl: string;
+  readonly br: string;
+  readonly range: string;
+  readonly shortRange: string;
+  readonly $range: string;
+  readonly count: number;
+  readonly model: Location & {
+    sheetName?: string;
+  };
+  toString(): string;
+}
+/**
+ * A picture of a workbook (exceljs `Media`, index.d.ts L1615).
+ *
+ * @example
+ * ```ts
+ * import type { Media } from '@xlvane/compat';
+ * const value: Media | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface Media {
+  type: string;
+  name: string;
+  extension: string;
+  buffer: Uint8Array;
+}
+/**
+ * Visibility of a worksheet (exceljs `WorksheetState`, index.d.ts L997).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetState } from '@xlvane/compat';
+ * const value: WorksheetState | undefined = 'hidden';
+ * console.log(value);
+ * ```
+ */
+type WorksheetState = "visible" | "hidden" | "veryHidden";
+/**
+ * Operators of a `cellIs` conditional formatting rule (exceljs index.d.ts L999).
+ *
+ * @example
+ * ```ts
+ * import type { CellIsOperators } from '@xlvane/compat';
+ * const value: CellIsOperators | undefined = 'between';
+ * console.log(value);
+ * ```
+ */
+type CellIsOperators = "equal" | "greaterThan" | "lessThan" | "between";
+/**
+ * Operators of a `containsText` rule (exceljs index.d.ts L1001).
+ *
+ * @example
+ * ```ts
+ * import type { ContainsTextOperators } from '@xlvane/compat';
+ * const value: ContainsTextOperators | undefined = 'containsText';
+ * console.log(value);
+ * ```
+ */
+type ContainsTextOperators = "containsText" | "containsBlanks" | "notContainsBlanks" | "containsErrors" | "notContainsErrors";
+/**
+ * Periods of a `timePeriod` rule (exceljs index.d.ts L1003).
+ *
+ * @example
+ * ```ts
+ * import type { TimePeriodTypes } from '@xlvane/compat';
+ * const value: TimePeriodTypes | undefined = 'today';
+ * console.log(value);
+ * ```
+ */
+type TimePeriodTypes = "lastWeek" | "thisWeek" | "nextWeek" | "yesterday" | "today" | "tomorrow" | "last7Days" | "lastMonth" | "thisMonth" | "nextMonth";
+/**
+ * Icon sets of an `iconSet` rule (exceljs index.d.ts L1006).
+ *
+ * @example
+ * ```ts
+ * import type { IconSetTypes } from '@xlvane/compat';
+ * const value: IconSetTypes | undefined = '3Arrows';
+ * console.log(value);
+ * ```
+ */
+type IconSetTypes = "5Arrows" | "5ArrowsGray" | "5Boxes" | "5Quarters" | "5Rating" | "4Arrows" | "4ArrowsGray" | "4Rating" | "4RedToBlack" | "4TrafficLights" | "NoIcons" | "3Arrows" | "3ArrowsGray" | "3Flags" | "3Signs" | "3Stars" | "3Symbols" | "3Symbols2" | "3TrafficLights1" | "3TrafficLights2" | "3Triangles";
+/**
+ * Value types of a conditional formatting value object (exceljs index.d.ts L1010).
+ *
+ * @example
+ * ```ts
+ * import type { CfvoTypes } from '@xlvane/compat';
+ * const value: CfvoTypes | undefined = 'min';
+ * console.log(value);
+ * ```
+ */
+type CfvoTypes = "percentile" | "percent" | "num" | "min" | "max" | "formula" | "autoMin" | "autoMax";
+/**
+ * A conditional formatting value object (exceljs `Cvfo`, index.d.ts L1012).
+ *
+ * @example
+ * ```ts
+ * import type { Cvfo } from '@xlvane/compat';
+ * const value: Cvfo | undefined = { type: 'percentile', value: 50 };
+ * console.log(value);
+ * ```
+ */
+interface Cvfo {
+  type: CfvoTypes;
+  value?: number;
+}
+/**
+ * A `expression` conditional formatting rule (exceljs `ExpressionRuleType`, index.d.ts L1020).
+ *
+ * @example
+ * ```ts
+ * import type { ExpressionRuleType } from '@xlvane/compat';
+ * const value: ExpressionRuleType | undefined = { type: 'expression' } as ExpressionRuleType;
+ * console.log(value);
+ * ```
+ */
+interface ExpressionRuleType {
+  type: "expression";
+  priority?: number;
+  style?: Partial<Style>;
+  formulae?: unknown[];
+}
+/**
+ * A `cellIs` conditional formatting rule (exceljs `CellIsRuleType`, index.d.ts L1025).
+ *
+ * @example
+ * ```ts
+ * import type { CellIsRuleType } from '@xlvane/compat';
+ * const value: CellIsRuleType | undefined = { type: 'cellIs' } as CellIsRuleType;
+ * console.log(value);
+ * ```
+ */
+interface CellIsRuleType {
+  type: "cellIs";
+  priority?: number;
+  style?: Partial<Style>;
+  formulae?: unknown[];
+  operator?: CellIsOperators;
+}
+/**
+ * A `aboveAverage` conditional formatting rule (exceljs `AboveAverageRuleType`, index.d.ts L1038).
+ *
+ * @example
+ * ```ts
+ * import type { AboveAverageRuleType } from '@xlvane/compat';
+ * const value: AboveAverageRuleType | undefined = { type: 'aboveAverage' } as AboveAverageRuleType;
+ * console.log(value);
+ * ```
+ */
+interface AboveAverageRuleType {
+  type: "aboveAverage";
+  priority?: number;
+  style?: Partial<Style>;
+  aboveAverage: boolean;
+}
+/**
+ * A `colorScale` conditional formatting rule (exceljs `ColorScaleRuleType`, index.d.ts L1043).
+ *
+ * @example
+ * ```ts
+ * import type { ColorScaleRuleType } from '@xlvane/compat';
+ * const value: ColorScaleRuleType | undefined = { type: 'colorScale' } as ColorScaleRuleType;
+ * console.log(value);
+ * ```
+ */
+interface ColorScaleRuleType {
+  type: "colorScale";
+  priority?: number;
+  style?: Partial<Style>;
+  cfvo?: Cvfo[];
+  color?: Partial<Color>[];
+}
+/**
+ * A `iconSet` conditional formatting rule (exceljs `IconSetRuleType`, index.d.ts L1049).
+ *
+ * @example
+ * ```ts
+ * import type { IconSetRuleType } from '@xlvane/compat';
+ * const value: IconSetRuleType | undefined = { type: 'iconSet' } as IconSetRuleType;
+ * console.log(value);
+ * ```
+ */
+interface IconSetRuleType {
+  type: "iconSet";
+  priority?: number;
+  style?: Partial<Style>;
+  showValue?: boolean;
+  reverse?: boolean;
+  custom?: boolean;
+  iconSet?: IconSetTypes;
+  cfvo?: Cvfo[];
+}
+/**
+ * A `containsText` conditional formatting rule (exceljs `ContainsTextRuleType`, index.d.ts L1058).
+ *
+ * @example
+ * ```ts
+ * import type { ContainsTextRuleType } from '@xlvane/compat';
+ * const value: ContainsTextRuleType | undefined = { type: 'containsText' } as ContainsTextRuleType;
+ * console.log(value);
+ * ```
+ */
+interface ContainsTextRuleType {
+  type: "containsText";
+  priority?: number;
+  style?: Partial<Style>;
+  operator?: ContainsTextOperators;
+  text?: string;
+}
+/**
+ * A `timePeriod` conditional formatting rule (exceljs `TimePeriodRuleType`, index.d.ts L1064).
+ *
+ * @example
+ * ```ts
+ * import type { TimePeriodRuleType } from '@xlvane/compat';
+ * const value: TimePeriodRuleType | undefined = { type: 'timePeriod' } as TimePeriodRuleType;
+ * console.log(value);
+ * ```
+ */
+interface TimePeriodRuleType {
+  type: "timePeriod";
+  priority?: number;
+  style?: Partial<Style>;
+  timePeriod?: TimePeriodTypes;
+}
+/**
+ * A `dataBar` conditional formatting rule (exceljs `DataBarRuleType`, index.d.ts L1069).
+ *
+ * @example
+ * ```ts
+ * import type { DataBarRuleType } from '@xlvane/compat';
+ * const value: DataBarRuleType | undefined = { type: 'dataBar' } as DataBarRuleType;
+ * console.log(value);
+ * ```
+ */
+interface DataBarRuleType {
+  type: "dataBar";
+  priority?: number;
+  style?: Partial<Style>;
+  gradient?: boolean;
+  minLength?: number;
+  maxLength?: number;
+  showValue?: boolean;
+  border?: boolean;
+  negativeBarColorSameAsPositive?: boolean;
+  negativeBarBorderColorSameAsPositive?: boolean;
+  axisPosition?: "auto" | "middle" | "none";
+  direction?: "context" | "leftToRight" | "rightToLeft";
+  cfvo?: Cvfo[];
+}
+/**
+ * The values of a row given to `addRow()` (exceljs `RowValues`, index.d.ts L1087).
+ *
+ * @example
+ * ```ts
+ * import type { RowValues } from '@xlvane/compat';
+ * const value: RowValues | undefined = [1, 'two', new Date(0)];
+ * console.log(value);
+ * ```
+ */
+type RowValues = CellValue[] | {
+  [key: string]: CellValue;
+} | undefined | null;
+/**
+ * `workbook.calcProperties` (exceljs `CalculationProperties`, index.d.ts L1385).
+ *
+ * @example
+ * ```ts
+ * import type { CalculationProperties } from '@xlvane/compat';
+ * const value: CalculationProperties | undefined = { fullCalcOnLoad: true };
+ * console.log(value);
+ * ```
+ */
+interface CalculationProperties {
+  fullCalcOnLoad: boolean;
+}
+/**
+ * `workbook.properties` (exceljs `WorkbookProperties`, index.d.ts L1440).
+ *
+ * @example
+ * ```ts
+ * import type { WorkbookProperties } from '@xlvane/compat';
+ * const value: WorkbookProperties | undefined = { date1904: false };
+ * console.log(value);
+ * ```
+ */
+interface WorkbookProperties {
+  date1904: boolean;
+}
+/**
+ * The `zip` option of `writeBuffer()` (exceljs `JSZipGeneratorOptions`, index.d.ts L1447); xlvane uses `compressionOptions.level`.
+ *
+ * @example
+ * ```ts
+ * import type { JSZipGeneratorOptions } from '@xlvane/compat';
+ * const value: JSZipGeneratorOptions | undefined = { compression: 'DEFLATE', compressionOptions: { level: 9 } };
+ * console.log(value);
+ * ```
+ */
+interface JSZipGeneratorOptions {
+  compression: "STORE" | "DEFLATE";
+  compressionOptions: null | {
+    level: number;
+  };
+}
+/**
+ * `workbook.xlsx` (exceljs `Xlsx`, index.d.ts L1474).
+ *
+ * @example
+ * ```ts
+ * import type { Xlsx } from '@xlvane/compat';
+ * const value: Xlsx | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+type Xlsx = XlsxIO;
+/**
+ * `workbook.csv` (exceljs `Csv`, index.d.ts L1583).
+ *
+ * @example
+ * ```ts
+ * import type { Csv } from '@xlvane/compat';
+ * const value: Csv | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+type Csv = CsvIO;
+/**
+ * fast-csv parser options accepted by `csv.read()` (exceljs index.d.ts L1512).
+ *
+ * @example
+ * ```ts
+ * import type { FastCsvParserOptionsArgs } from '@xlvane/compat';
+ * const value: FastCsvParserOptionsArgs | undefined = { delimiter: ';' } as FastCsvParserOptionsArgs;
+ * console.log(value);
+ * ```
+ */
+interface FastCsvParserOptionsArgs {
+  objectMode: boolean;
+  delimiter: string;
+  quote: string | null;
+  escape: string;
+  headers: boolean | ((headers: (string | undefined | null)[]) => (string | undefined | null)[]) | (string | undefined | null)[];
+  renameHeaders: boolean;
+  ignoreEmpty: boolean;
+  comment: string;
+  strictColumnHandling: boolean;
+  discardUnmappedColumns: boolean;
+  trim: boolean;
+  ltrim: boolean;
+  rtrim: boolean;
+  encoding: string;
+  maxRows: number;
+  skipLines: number;
+  skipRows: number;
+}
+/**
+ * fast-csv formatter options accepted by `csv.write()` (exceljs index.d.ts L1550).
+ *
+ * @example
+ * ```ts
+ * import type { FastCsvFormatterOptionsArgs } from '@xlvane/compat';
+ * const value: FastCsvFormatterOptionsArgs | undefined = { delimiter: ';' } as FastCsvFormatterOptionsArgs;
+ * console.log(value);
+ * ```
+ */
+interface FastCsvFormatterOptionsArgs {
+  objectMode: boolean;
+  delimiter: string;
+  rowDelimiter: string;
+  quote: string | boolean;
+  escape: string;
+  quoteColumns: boolean | boolean[] | {
+    [column: string]: boolean;
+  };
+  quoteHeaders: boolean | boolean[] | {
+    [column: string]: boolean;
+  };
+  headers: null | boolean | string[];
+  includeEndRowDelimiter: boolean;
+  writeBOM: boolean;
+  transform: (row: unknown) => unknown;
+  alwaysWriteHeaders: boolean;
+}
+/**
+ * The data of a worksheet as exceljs `WorksheetModel` (index.d.ts L984). `worksheet.model` returns xlvane's own snapshot.
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetModel } from '@xlvane/compat';
+ * const value: WorksheetModel | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface WorksheetModel {
+  id: number;
+  name: string;
+  properties: Partial<WorksheetProperties>;
+  pageSetup: Partial<PageSetup>;
+  headerFooter: Partial<HeaderFooter>;
+  rowBreaks: RowBreak[];
+  views: Partial<WorksheetView>[];
+  autoFilter: AutoFilter;
+  media: Media[];
+  merges: string[];
+}
+/**
+ * The data of a workbook as exceljs `WorkbookModel` (index.d.ts L1682). `workbook.model` returns xlvane's own snapshot.
+ *
+ * @example
+ * ```ts
+ * import type { WorkbookModel } from '@xlvane/compat';
+ * const value: WorkbookModel | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface WorkbookModel {
+  creator: string;
+  lastModifiedBy: string;
+  lastPrinted: Date;
+  created: Date;
+  modified: Date;
+  properties: WorkbookProperties;
+  worksheets: Worksheet[];
+  sheets: WorksheetModel[];
+  definedNames: {
+    name: string;
+    ranges: string[];
+  }[];
+  views: Record<string, unknown>[];
+  company: string;
+  manager: string;
+  title: string;
+  subject: string;
+  keywords: string;
+  category: string;
+  description: string;
+  language: string;
+  revision: Date;
+  contentStatus: string;
+  themes: string[];
+  media: Media[];
+}
+/**
+ * Settings shared by every worksheet view (exceljs `WorksheetViewCommon`, index.d.ts L33).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetViewCommon } from '@xlvane/compat';
+ *
+ * const value: WorksheetViewCommon | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface WorksheetViewCommon {
+  rightToLeft: boolean;
+  activeCell: string;
+  showRuler: boolean;
+  showRowColHeaders: boolean;
+  showGridLines: boolean;
+  zoomScale: number;
+  zoomScaleNormal: number;
+}
+/**
+ * A normal worksheet view (exceljs `WorksheetViewNormal`, index.d.ts L72).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetViewNormal } from '@xlvane/compat';
+ *
+ * const value: WorksheetViewNormal | undefined = { state: 'normal', style: 'pageLayout' };
+ * console.log(value);
+ * ```
+ */
+interface WorksheetViewNormal {
+  state: "normal";
+  style: "pageBreakPreview" | "pageLayout";
+}
+/**
+ * A view with frozen rows and columns (exceljs `WorksheetViewFrozen`, index.d.ts L84).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetViewFrozen } from '@xlvane/compat';
+ *
+ * const value: WorksheetViewFrozen | undefined = { state: 'frozen', ySplit: 1 };
+ * console.log(value);
+ * ```
+ */
+interface WorksheetViewFrozen {
+  state: "frozen";
+  style?: "pageBreakPreview";
+  xSplit?: number;
+  ySplit?: number;
+  topLeftCell?: string;
+}
+/**
+ * A view split into panes (exceljs `WorksheetViewSplit`, index.d.ts L113).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetViewSplit } from '@xlvane/compat';
+ *
+ * const value: WorksheetViewSplit | undefined = { state: 'split', xSplit: 2000, ySplit: 3000 };
+ * console.log(value);
+ * ```
+ */
+interface WorksheetViewSplit {
+  state: "split";
+  style?: "pageBreakPreview" | "pageLayout";
+  xSplit?: number;
+  ySplit?: number;
+  topLeftCell?: string;
+  activePane?: "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+}
+/**
+ * A window of the workbook (exceljs `WorkbookView`, index.d.ts L151).
+ *
+ * @example
+ * ```ts
+ * import type { WorkbookView } from '@xlvane/compat';
+ *
+ * const value: WorkbookView | undefined = { x: 0, y: 0, width: 10000, height: 20000, firstSheet: 0, activeTab: 0, visibility: 'visible' };
+ * console.log(value);
+ * ```
+ */
+interface WorkbookView {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  firstSheet: number;
+  activeTab: number;
+  visibility: string;
+}
+/**
+ * A pattern fill (exceljs `FillPattern`, index.d.ts L167).
+ *
+ * @example
+ * ```ts
+ * import type { FillPattern } from '@xlvane/compat';
+ *
+ * const value: FillPattern | undefined = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFFF00' } };
+ * console.log(value);
+ * ```
+ */
+interface FillPattern {
+  type: "pattern";
+  pattern: FillPatterns;
+  fgColor?: Partial<Color>;
+  bgColor?: Partial<Color>;
+}
+/**
+ * A cell that shares the formula of a master cell (exceljs `CellSharedFormulaValue`, index.d.ts L357).
+ *
+ * @example
+ * ```ts
+ * import type { CellSharedFormulaValue } from '@xlvane/compat';
+ *
+ * const value: CellSharedFormulaValue | undefined = { sharedFormula: 'A1', result: 2 };
+ * console.log(value);
+ * ```
+ */
+interface CellSharedFormulaValue {
+  sharedFormula: string;
+  readonly formula?: string;
+  result?: number | string | boolean | Date | CellErrorValue;
+  date1904?: boolean;
+}
+/**
+ * A picture anchor (exceljs `IAnchor`, index.d.ts L893).
+ *
+ * @example
+ * ```ts
+ * import type { IAnchor } from '@xlvane/compat';
+ *
+ * const value: IAnchor | undefined = undefined;
+ * console.log(value);
+ * ```
+ */
+interface IAnchor {
+  col: number;
+  row: number;
+  nativeCol: number;
+  nativeRow: number;
+  nativeColOff: number;
+  nativeRowOff: number;
+}
+/**
+ * Fields shared by conditional formatting rules (exceljs `ConditionalFormattingBaseRule`, index.d.ts L1015).
+ *
+ * @example
+ * ```ts
+ * import type { ConditionalFormattingBaseRule } from '@xlvane/compat';
+ *
+ * const value: ConditionalFormattingBaseRule | undefined = { priority: 1 };
+ * console.log(value);
+ * ```
+ */
+interface ConditionalFormattingBaseRule {
+  priority: number;
+  style?: Partial<Style>;
+}
+/**
+ * A `top10` conditional formatting rule (exceljs `Top10RuleType`, index.d.ts L1031).
+ *
+ * @example
+ * ```ts
+ * import type { Top10RuleType } from '@xlvane/compat';
+ *
+ * const value: Top10RuleType | undefined = { type: 'top10', rank: 5, percent: false, bottom: false };
+ * console.log(value);
+ * ```
+ */
+interface Top10RuleType {
+  type: "top10";
+  priority?: number;
+  style?: Partial<Style>;
+  rank: number;
+  percent: boolean;
+  bottom: boolean;
+}
+/**
+ * `worksheet.properties` (exceljs `WorksheetProperties`, index.d.ts L1392).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetProperties } from '@xlvane/compat';
+ *
+ * const value: WorksheetProperties | undefined = { tabColor: { argb: 'FFFF0000' } } as WorksheetProperties;
+ * console.log(value);
+ * ```
+ */
+interface WorksheetProperties {
+  tabColor: Partial<Color>;
+  outlineLevelCol: number;
+  outlineLevelRow: number;
+  outlineProperties: {
+    summaryBelow: boolean;
+    summaryRight: boolean;
+  };
+  defaultRowHeight: number;
+  defaultColWidth?: number;
+  dyDescent: number;
+  showGridLines: boolean;
+}
+/**
+ * Options of `addWorksheet()` (exceljs `AddWorksheetOptions`, index.d.ts L1431).
+ *
+ * @example
+ * ```ts
+ * import type { AddWorksheetOptions } from '@xlvane/compat';
+ *
+ * const value: AddWorksheetOptions | undefined = { state: 'hidden' } as Partial<AddWorksheetOptions> as AddWorksheetOptions;
+ * console.log(value);
+ * ```
+ */
+interface AddWorksheetOptions {
+  properties: Partial<WorksheetProperties>;
+  pageSetup: Partial<PageSetup>;
+  headerFooter: Partial<HeaderFooter>;
+  views: Array<Partial<WorksheetView>>;
+  state: WorksheetState;
+}
+/**
+ * One defined name and its ranges (exceljs `DefinedNamesRanges`, index.d.ts L1654).
+ *
+ * @example
+ * ```ts
+ * import type { DefinedNamesRanges } from '@xlvane/compat';
+ *
+ * const value: DefinedNamesRanges | undefined = { name: 'Totals', ranges: ['Sheet1!$A$1'] };
+ * console.log(value);
+ * ```
+ */
+interface DefinedNamesRanges {
+  name: string;
+  ranges: string[];
+}
+/**
+ * `workbook.definedNames.model` (exceljs `DefinedNamesModel`, index.d.ts L1659).
+ *
+ * @example
+ * ```ts
+ * import type { DefinedNamesModel } from '@xlvane/compat';
+ *
+ * const value: DefinedNamesModel | undefined = [];
+ * console.log(value);
+ * ```
+ */
+type DefinedNamesModel = DefinedNamesRanges[];
+/**
+ * The style of a table (exceljs `TableStyleProperties`, index.d.ts L1783). `theme` is any table style name, such as `TableStyleMedium2`.
+ *
+ * @example
+ * ```ts
+ * import type { TableStyleProperties } from '@xlvane/compat';
+ *
+ * const value: TableStyleProperties | undefined = { theme: 'TableStyleMedium2', showRowStripes: true };
+ * console.log(value);
+ * ```
+ */
+interface TableStyleProperties {
+  theme?: string;
+  showFirstColumn?: boolean;
+  showLastColumn?: boolean;
+  showRowStripes?: boolean;
+  showColumnStripes?: boolean;
+}
+/**
+ * exceljs `config` (index.d.ts L1906): declared by exceljs for a custom Promise library; exceljs does
+ * not export it at run time either.
+ *
+ * @example
+ * ```ts
+ * import type { config } from '@xlvane/compat';
+ *
+ * type SetValue = typeof config.setValue;
+ * const kind: SetValue | undefined = undefined;
+ * console.log(kind);
+ * ```
+ */
+declare namespace config {
+  function setValue(key: "promise", promise: unknown): void;
+}
+/**
+ * A colour: `argb` such as `"FFFF0000"`, or a theme index (with optional tint), or an indexed colour.
+ *
+ * @example
+ * ```ts
+ * import type { Color } from '@xlvane/compat';
+ *
+ * const red: Partial<Color> = { argb: 'FFFF0000' };
+ * ```
+ */
+interface Color {
+  argb: string;
+  theme: number;
+  tint: number;
+  indexed: number;
+}
+/**
+ * Font of a cell (exceljs `Font`); every property is written and read back.
+ *
+ * @example
+ * ```ts
+ * import type { Font } from '@xlvane/compat';
+ *
+ * const font: Partial<Font> = { name: 'Arial', size: 12, bold: true, color: { argb: 'FF1F4E79' } };
+ * ```
+ */
+interface Font {
+  name: string;
+  size: number;
+  family: number;
+  scheme: "minor" | "major" | "none";
+  charset: number;
+  color: Partial<Color>;
+  bold: boolean;
+  italic: boolean;
+  underline: boolean | "none" | "single" | "double" | "singleAccounting" | "doubleAccounting";
+  vertAlign: "superscript" | "subscript";
+  strike: boolean;
+  outline: boolean;
+}
+/**
+ * Fill patterns.
+ *
+ * @example
+ * ```ts
+ * import type { FillPatterns } from '@xlvane/compat';
+ *
+ * const pattern: FillPatterns = 'solid';
+ * ```
+ */
+type FillPatterns = "none" | "solid" | "darkVertical" | "darkHorizontal" | "darkGrid" | "darkTrellis" | "darkDown" | "darkUp" | "lightVertical" | "lightHorizontal" | "lightGrid" | "lightTrellis" | "lightDown" | "lightUp" | "darkGray" | "mediumGray" | "lightGray" | "gray125" | "gray0625";
+/**
+ * A pattern fill (`pattern`, `fgColor`, `bgColor`) or a gradient fill, as in exceljs: `gradient:
+ * 'angle'` with `degree`, or `gradient: 'path'` with `center: { left, top }`, and `stops: [{
+ * position, color }]` (X4-27).
+ *
+ * @example
+ * ```ts
+ * import type { Fill } from '@xlvane/compat';
+ *
+ * const fill: Fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFFF00' } };
+ * const gradient: Fill = { type: 'gradient', gradient: 'angle', degree: 90, stops: [{ position: 0, color: { argb: 'FFFFFFFF' } }, { position: 1, color: { argb: 'FF4472C4' } }] };
+ * ```
+ */
+interface Fill {
+  type: "pattern" | "gradient";
+  pattern?: FillPatterns;
+  fgColor?: Partial<Color>;
+  bgColor?: Partial<Color>;
+  gradient?: "angle" | "path";
+  degree?: number;
+  center?: {
+    left: number;
+    top: number;
+  };
+  stops?: GradientStop[];
+}
+/**
+ * Border line styles.
+ *
+ * @example
+ * ```ts
+ * import type { BorderStyle } from '@xlvane/compat';
+ *
+ * const style: BorderStyle = 'thin';
+ * ```
+ */
+type BorderStyle = "thin" | "dotted" | "hair" | "medium" | "double" | "thick" | "dashed" | "dashDot" | "dashDotDot" | "slantDashDot" | "mediumDashed" | "mediumDashDotDot" | "mediumDashDot";
+/**
+ * One edge of a border.
+ *
+ * @example
+ * ```ts
+ * import type { Border } from '@xlvane/compat';
+ *
+ * const edge: Partial<Border> = { style: 'thin', color: { argb: 'FF000000' } };
+ * ```
+ */
+interface Border {
+  style: BorderStyle;
+  color: Partial<Color>;
+}
+/**
+ * Borders of a cell; `diagonal` has `up` and `down` flags, written only with a style (X4-27).
+ *
+ * @example
+ * ```ts
+ * import type { Borders } from '@xlvane/compat';
+ *
+ * const border: Partial<Borders> = { top: { style: 'thin' }, bottom: { style: 'double' } };
+ * ```
+ */
+interface Borders {
+  top: Partial<Border>;
+  left: Partial<Border>;
+  bottom: Partial<Border>;
+  right: Partial<Border>;
+  diagonal: Partial<Border> & {
+    up?: boolean;
+    down?: boolean;
+  };
+}
+/**
+ * Alignment of a cell. `textRotation` is −90…90 or `'vertical'`; `readingOrder` is `'ltr'` or `'rtl'` (X4-27).
+ *
+ * @example
+ * ```ts
+ * import type { Alignment } from '@xlvane/compat';
+ *
+ * const alignment: Partial<Alignment> = { horizontal: 'center', vertical: 'middle', wrapText: true };
+ * ```
+ */
+interface Alignment {
+  horizontal: "left" | "center" | "right" | "fill" | "justify" | "centerContinuous" | "distributed";
+  vertical: "top" | "middle" | "bottom" | "distributed" | "justify";
+  wrapText: boolean;
+  shrinkToFit: boolean;
+  indent: number;
+  readingOrder: "rtl" | "ltr";
+  textRotation: number | "vertical";
+}
+/**
+ * The style of a cell, row or column.
+ *
+ * @example
+ * ```ts
+ * import type { Style } from '@xlvane/compat';
+ *
+ * const style: Partial<Style> = { numFmt: '#,##0.00', font: { bold: true } };
+ * ```
+ */
+interface Style {
+  numFmt?: string | undefined;
+  font?: Partial<Font> | undefined;
+  fill?: Fill | undefined;
+  border?: Partial<Borders> | undefined;
+  alignment?: Partial<Alignment> | undefined;
+  protection?: Partial<Protection> | undefined;
+}
+/**
+ * Cell protection; it takes effect when the sheet is protected (X4-27).
+ *
+ * @example
+ * ```ts
+ * import type { Protection } from '@xlvane/compat';
+ *
+ * const unlocked: Partial<Protection> = { locked: false };
+ * ```
+ */
+interface Protection {
+  locked: boolean;
+  hidden: boolean;
+}
+/**
+ * An error value of a cell.
+ *
+ * @example
+ * ```ts
+ * import type { CellErrorValue } from '@xlvane/compat';
+ *
+ * const na: CellErrorValue = { error: '#N/A' };
+ * ```
+ */
+interface CellErrorValue {
+  error: "#N/A" | "#REF!" | "#NAME?" | "#DIV/0!" | "#NULL!" | "#VALUE!" | "#NUM!";
+}
+/**
+ * A formula with an optional cached result. xlvane does not calculate formulas.
+ *
+ * @example
+ * ```ts
+ * import type { CellFormulaValue } from '@xlvane/compat';
+ *
+ * const total: CellFormulaValue = { formula: 'SUM(B2:B10)', result: 120 };
+ * ```
+ */
+interface CellFormulaValue {
+  formula: string;
+  result?: number | string | boolean | Date | CellErrorValue;
+  date1904?: boolean;
+}
+/**
+ * A cell value, including rich text (`{ richText: [{ text, font? }] }`) and hyperlinks
+ * (`{ text, hyperlink, tooltip? }`; a `hyperlink` starting with `#` is a place in the workbook).
+ * Shared-string values are not supported (`XLV_E_NOT_SUPPORTED` when set); shared formulas are
+ * written as ordinary formulas.
+ *
+ * @example
+ * ```ts
+ * import type { CellValue } from '@xlvane/compat';
+ *
+ * const values: CellValue[] = [
+ *   1, 'text', true, new Date(), null, { formula: 'A1*2' }, { error: '#N/A' },
+ *   { richText: [{ font: { bold: true }, text: 'Bold' }, { text: ' plain' }] },
+ *   { text: 'Docs', hyperlink: 'https://example.com', tooltip: 'Open the docs' },
+ *   { text: 'Totals', hyperlink: "#'Sheet 2'!A1" },
+ * ];
+ * ```
+ */
+type CellValue = null | undefined | number | string | boolean | Date | CellErrorValue | CellFormulaValue | CellRichTextValue | CellHyperlinkValue | CellSharedFormulaValue | Record<string, unknown>;
+/**
+ * A column definition for `worksheet.columns`.
+ *
+ * @example
+ * ```ts
+ * import type { ColumnDefn } from '@xlvane/compat';
+ *
+ * const column: Partial<ColumnDefn> = { header: 'Total', key: 'total', width: 12, style: { numFmt: '#,##0.00' } };
+ * ```
+ */
+interface ColumnDefn {
+  header?: string | string[] | undefined;
+  key?: string | undefined;
+  width?: number | undefined;
+  style?: Style | undefined;
+  hidden?: boolean | undefined;
+  outlineLevel?: number | undefined;
+}
+/**
+ * A worksheet view. The first view of a worksheet is written: frozen panes (`xSplit`/`ySplit`
+ * in columns and rows) or a split window (`state: "split"`, `xSplit`/`ySplit` in 1/20 point),
+ * `zoomScale`, `zoomScaleNormal`, `showGridLines`, `showRowColHeaders`, `showRuler`,
+ * `rightToLeft`, `style`, `topLeftCell` (not for frozen panes, whose top-left cell follows the
+ * split) and `activeCell`. `activePane` follows from the panes; further views are not written.
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetView } from '@xlvane/compat';
+ *
+ * const view: WorksheetView = { state: 'frozen', xSplit: 1, ySplit: 1 };
+ * ```
+ */
+interface WorksheetView {
+  state?: "normal" | "frozen" | "split";
+  xSplit?: number;
+  ySplit?: number;
+  topLeftCell?: string | undefined;
+  activeCell?: string;
+  showGridLines?: boolean;
+  zoomScale?: number;
+  [key: string]: unknown;
+}
+/**
+ * Options for `workbook.addWorksheet()`, as in exceljs (index.d.ts `AddWorksheetOptions`).
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetOptions } from '@xlvane/compat';
+ *
+ * const options: WorksheetOptions = { state: 'hidden', views: [{ state: 'frozen', ySplit: 1 }] };
+ * ```
+ */
+interface WorksheetOptions {
+  state?: "visible" | "hidden" | "veryHidden";
+  views?: WorksheetView[];
+  properties?: Record<string, unknown>;
+  pageSetup?: Partial<PageSetup>;
+  headerFooter?: Partial<HeaderFooter>;
+}
+/**
+ * A cell note (`cell.note = string | Comment`), as in exceljs (index.d.ts `Comment`, lib/doc/note.js).
+ * `texts` are rich text runs. `margins` (`inset` in centimetres: left, top, right, bottom),
+ * `protection` and `editAs` set the box that shows the note, as in exceljs (D-E07).
+ *
+ * @example
+ * ```ts
+ * import type { Comment } from '@xlvane/compat';
+ *
+ * const note: Comment = { texts: [{ font: { bold: true }, text: 'Check: ' }, { text: 'estimate only' }] };
+ * ```
+ */
+interface Comment {
+  texts?: {
+    text: string;
+    font?: Partial<Font>;
+  }[];
+  margins?: {
+    insetmode?: "auto" | "custom";
+    inset?: number[];
+  };
+  protection?: {
+    locked?: "True" | "False";
+    lockText?: "True" | "False";
+  };
+  editAs?: "twoCells" | "oneCells" | "absolute";
+}
+/**
+ * A data validation (`cell.dataValidation`, `worksheet.dataValidations`), as in exceljs
+ * (index.d.ts `DataValidation`). `'any'` is a validation that only shows its input message.
+ * `formulae` are formulas (`'"Yes,No"'` for a literal list, `'$D$1:$D$9'` for a range), numbers or
+ * dates; reading gives numbers for whole, decimal and textLength validations and dates for date
+ * validations, as exceljs does.
+ *
+ * @example
+ * ```ts
+ * import type { DataValidation } from '@xlvane/compat';
+ *
+ * const rule: DataValidation = { type: 'whole', operator: 'between', allowBlank: true, formulae: [1, 10], showErrorMessage: true, error: '1 to 10' };
+ * ```
+ */
+interface DataValidation {
+  type: "list" | "whole" | "decimal" | "date" | "time" | "textLength" | "custom" | "any";
+  formulae?: unknown[];
+  allowBlank?: boolean;
+  operator?: "between" | "notBetween" | "equal" | "notEqual" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual";
+  error?: string;
+  errorTitle?: string;
+  errorStyle?: "stop" | "warning" | "information" | "error";
+  prompt?: string;
+  promptTitle?: string;
+  showErrorMessage?: boolean;
+  showInputMessage?: boolean;
+}
+/**
+ * A conditional formatting rule, as in exceljs (index.d.ts `ConditionalFormattingRule`): the
+ * rule type with its own properties (`formulae`, `operator`, `rank`, `cfvo`, `color`, `iconSet`,
+ * `text`, `timePeriod`, …) and the `style` applied where the rule is true.
+ *
+ * @example
+ * ```ts
+ * import type { ConditionalFormattingRule } from '@xlvane/compat';
+ *
+ * const rule: ConditionalFormattingRule = { type: 'cellIs', operator: 'greaterThan', formulae: [100], style: { font: { bold: true } } };
+ * ```
+ */
+type ConditionalFormattingRule = ExpressionRuleType | CellIsRuleType | Top10RuleType | AboveAverageRuleType | ColorScaleRuleType | IconSetRuleType | ContainsTextRuleType | TimePeriodRuleType | DataBarRuleType;
+/**
+ * The argument of `worksheet.addConditionalFormatting()`: the range and its rules.
+ *
+ * @example
+ * ```ts
+ * import type { ConditionalFormattingOptions } from '@xlvane/compat';
+ *
+ * const cf: ConditionalFormattingOptions = { ref: 'B2:B20', rules: [{ type: 'top10', rank: 3, percent: false, bottom: false, style: { fill: { type: 'pattern', pattern: 'solid', bgColor: { argb: 'FFFFC7CE' } } } }] };
+ * ```
+ */
+interface ConditionalFormattingOptions {
+  ref: string;
+  rules: ConditionalFormattingRule[];
+}
+/**
+ * Page setup of a worksheet (`worksheet.pageSetup`), as in exceljs (index.d.ts `PageSetup`).
+ * `printArea` (several areas joined by `&&`), `printTitlesRow` (`'1:2'`) and `printTitlesColumn`
+ * (`'A:B'`) are stored as the built-in names Excel uses.
+ *
+ * @example
+ * ```ts
+ * import type { PageSetup } from '@xlvane/compat';
+ *
+ * const setup: Partial<PageSetup> = { orientation: 'landscape', paperSize: 9, fitToPage: true, fitToWidth: 1, fitToHeight: 0, printArea: 'A1:G40' };
+ * ```
+ */
+interface PageSetup {
+  margins?: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    header: number;
+    footer: number;
+  } | undefined;
+  orientation?: "portrait" | "landscape" | undefined;
+  horizontalDpi?: number | undefined;
+  verticalDpi?: number | undefined;
+  fitToPage?: boolean | undefined;
+  pageOrder?: "downThenOver" | "overThenDown" | undefined;
+  blackAndWhite?: boolean | undefined;
+  draft?: boolean | undefined;
+  cellComments?: "atEnd" | "asDisplayed" | "asDisplyed" | "None" | undefined;
+  errors?: "dash" | "blank" | "NA" | "displayed" | undefined;
+  scale?: number | undefined;
+  fitToWidth?: number | undefined;
+  fitToHeight?: number | undefined;
+  paperSize?: number | undefined;
+  showRowColHeaders?: boolean | undefined;
+  showGridLines?: boolean | undefined;
+  firstPageNumber?: number | undefined;
+  useFirstPageNumber?: boolean | undefined;
+  usePrinterDefaults?: boolean | undefined;
+  copies?: number | undefined;
+  horizontalCentered?: boolean | undefined;
+  verticalCentered?: boolean | undefined;
+  rowBreaks?: unknown | undefined;
+  colBreaks?: unknown | undefined;
+  printArea?: string | undefined;
+  printTitlesRow?: string | undefined;
+  printTitlesColumn?: string | undefined;
+}
+/**
+ * Headers and footers of a worksheet (`worksheet.headerFooter`), as in exceljs (index.d.ts
+ * `HeaderFooter`). The texts use Excel's codes (`&C` centre section, `&P` page number, …).
+ *
+ * @example
+ * ```ts
+ * import type { HeaderFooter } from '@xlvane/compat';
+ *
+ * const hf: HeaderFooter = { oddHeader: '&CQuarterly report', oddFooter: '&RPage &P of &N' };
+ * ```
+ */
+interface HeaderFooter {
+  differentFirst?: boolean;
+  differentOddEven?: boolean;
+  oddHeader?: string | null;
+  oddFooter?: string | null;
+  evenHeader?: string | null;
+  evenFooter?: string | null;
+  firstHeader?: string | null;
+  firstFooter?: string | null;
+}
+/**
+ * A manual row break (`worksheet.rowBreaks`), as `row.addPageBreak()` stores it in exceljs:
+ * the page ends after row `id`.
+ *
+ * @example
+ * ```ts
+ * import type { RowBreak } from '@xlvane/compat';
+ *
+ * const pageEndsAfterRow20: RowBreak = { id: 20, max: 16383, man: 1 };
+ * ```
+ */
+interface RowBreak {
+  id: number;
+  max?: number;
+  min?: number;
+  man?: number;
+}
+/**
+ * Options of `worksheet.protect()`, as in exceljs (index.d.ts `WorksheetProtection`): `true`
+ * allows users to do the action on the protected sheet.
+ *
+ * @example
+ * ```ts
+ * import type { WorksheetProtection } from '@xlvane/compat';
+ *
+ * const options: Partial<WorksheetProtection> = { formatCells: true, sort: true, autoFilter: true };
+ * ```
+ */
+interface WorksheetProtection {
+  objects: boolean;
+  scenarios: boolean;
+  selectLockedCells: boolean;
+  selectUnlockedCells: boolean;
+  formatCells: boolean;
+  formatColumns: boolean;
+  formatRows: boolean;
+  insertColumns: boolean;
+  insertRows: boolean;
+  insertHyperlinks: boolean;
+  deleteColumns: boolean;
+  deleteRows: boolean;
+  sort: boolean;
+  autoFilter: boolean;
+  pivotTables: boolean;
+  spinCount: number;
+}
+/** The totals functions of a table column (exceljs `TableColumnProperties.totalsRowFunction`). */
+type TotalsFunction = "none" | "average" | "countNums" | "count" | "max" | "min" | "stdDev" | "var" | "sum" | "custom";
+/**
+ * A column of a table, as in exceljs `TableColumnProperties`. `style` is applied to the column's
+ * cells (header, data and totals), as exceljs does.
+ *
+ * @example
+ * ```ts
+ * import type { TableColumnProperties } from '@xlvane/compat';
+ *
+ * const column: TableColumnProperties = { name: 'Revenue', totalsRowFunction: 'sum', filterButton: true };
+ * ```
+ */
+interface TableColumnProperties {
+  name: string;
+  filterButton?: boolean | undefined;
+  totalsRowLabel?: string | undefined;
+  totalsRowFunction?: TotalsFunction | undefined;
+  totalsRowFormula?: string | undefined;
+  totalsRowResult?: unknown;
+  style?: Partial<Style> | undefined;
+}
+/**
+ * The definition of a table, as in exceljs `TableProperties` (`worksheet.addTable`). `ref` is the
+ * top-left cell; the table covers the header row, the rows and the totals row.
+ *
+ * @example
+ * ```ts
+ * import type { TableProperties } from '@xlvane/compat';
+ *
+ * const table: TableProperties = {
+ *   name: 'Sales',
+ *   ref: 'A1',
+ *   totalsRow: true,
+ *   columns: [{ name: 'Region', totalsRowLabel: 'Total' }, { name: 'Revenue', totalsRowFunction: 'sum' }],
+ *   rows: [['North', 1200], ['South', 980]],
+ * };
+ * ```
+ */
+interface TableProperties {
+  name: string;
+  displayName?: string | undefined;
+  ref: string;
+  headerRow?: boolean | undefined;
+  totalsRow?: boolean | undefined;
+  style?: {
+    theme?: string | null | undefined;
+    showFirstColumn?: boolean | undefined;
+    showLastColumn?: boolean | undefined;
+    showRowStripes?: boolean | undefined;
+    showColumnStripes?: boolean | undefined;
+  } | undefined;
+  columns: TableColumnProperties[];
+  rows: unknown[][];
+}
+/** The model of a table: exceljs's fields plus the computed ranges (lib/doc/table.js L129–178). */
+interface TableModel extends TableProperties {
+  tl: {
+    row: number;
+    col: number;
+  };
+  autoFilterRef: string;
+  tableRef: string;
+}
+/**
+ * A column of a table, as exceljs `Table.getColumn()` returns it. Changing `name` or the totals
+ * settings takes effect at `table.commit()`.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Data');
+ * const table = sheet.addTable({ name: 'Sales', ref: 'A1', columns: [{ name: 'Region' }, { name: 'Revenue' }], rows: [['North', 1200]] });
+ * table.getColumn(1).totalsRowFunction = 'sum';
+ * table.totalsRow = true;
+ * table.commit();
+ * ```
+ */
+export declare class TableColumn {
+  readonly table: Table;
+  readonly column: TableColumnProperties;
+  readonly index: number;
+  /** @internal */
+  constructor(table: Table, column: TableColumnProperties, index: number);
+  private set_;
+  get name(): string;
+  set name(v: string);
+  get filterButton(): boolean | undefined;
+  set filterButton(v: boolean | undefined);
+  get style(): Partial<Style> | undefined;
+  set style(v: Partial<Style> | undefined);
+  get totalsRowLabel(): string | undefined;
+  set totalsRowLabel(v: string | undefined);
+  get totalsRowFunction(): TotalsFunction | undefined;
+  set totalsRowFunction(v: TotalsFunction | undefined);
+  get totalsRowResult(): unknown;
+  set totalsRowResult(v: unknown);
+  get totalsRowFormula(): string | undefined;
+  set totalsRowFormula(v: string | undefined);
+}
+/**
+ * A table on a worksheet, as exceljs `Table` (lib/doc/table.js). `worksheet.addTable()` writes
+ * the header, rows and totals into the cells; methods that change the table take effect at
+ * `commit()`, which clears the old area and writes the new one. Names and ranges follow Excel's
+ * rules (`XLV_E_INVALID_TABLE`), which exceljs does not check.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Data');
+ * const table = sheet.addTable({
+ *   name: 'Sales',
+ *   ref: 'B2',
+ *   columns: [{ name: 'Region' }, { name: 'Revenue' }],
+ *   rows: [['North', 1200]],
+ * });
+ * table.addRow(['South', 980]);
+ * table.commit();
+ * console.log(table.ref, sheet.getCell('C4').value); // "B2" 980
+ * ```
+ */
+export declare class Table {
+  readonly worksheet: Worksheet;
+  /** @internal */
+  table: TableModel;
+  /** @internal Read from a file: a custom style name is then written without the name (D-R01). */
+  readonly fromFile: boolean;
+  private _cache;
+  /** @internal Use `worksheet.addTable()`. */
+  constructor(worksheet: Worksheet, table: TableProperties, store?: boolean);
+  get width(): number;
+  get height(): number;
+  get filterHeight(): number;
+  get tableHeight(): number;
+  /** The formula of a column's totals cell, or `null` (exceljs `getFormula`, with the codes of [MS-OI29500]). */
+  getFormula(column: TableColumnProperties): string | null;
+  /**
+   * Sets the defaults of exceljs and computes the ranges (table.js L129–178), then checks the
+   * table against Excel's rules through xlvane, so that a table Excel would reject is refused
+   * here rather than when the file is written.
+   */
+  validate(): void;
+  /** Writes the header, rows and totals into the worksheet's cells (exceljs `store`, table.js L180–234). */
+  store(): void;
+  /** @internal Remembers the table's area before the first change, for `commit()`. */
+  cacheState(): void;
+  /**
+   * Applies the changes made since the last commit: clears the area the table left and writes
+   * it again (table.js L295–335). The cache is cleared, so later changes are committed too
+   * (exceljs keeps the first cache and clears the wrong cells after a second change).
+   */
+  commit(): void;
+  /** Adds a row of data at the end, or before the row with index `rowNumber` (0-based). */
+  addRow(values: unknown[], rowNumber?: number): void;
+  /** Removes `count` rows of data from index `rowIndex` (0-based). */
+  removeRows(rowIndex: number, count?: number): void;
+  /** The column with index `colIndex` (0-based). */
+  getColumn(colIndex: number): TableColumn;
+  /** Adds a column with its values, at the end or before index `colIndex` (0-based). */
+  addColumn(column: TableColumnProperties, values: unknown[], colIndex?: number): void;
+  /** Removes `count` columns from index `colIndex` (0-based), with their values. */
+  removeColumns(colIndex: number, count?: number): void;
+  /** The table's model, as exceljs `table.model`, with `ref` and `rows`. */
+  get model(): TableProperties & {
+    tableRef: string;
+    autoFilterRef: string;
+  };
+  set model(v: TableProperties & {
+    tableRef: string;
+    autoFilterRef: string;
+  });
+  get ref(): string;
+  set ref(v: string);
+  get name(): string;
+  set name(v: string);
+  /** The display name; `name` when not set. exceljs reads a misspelled field here (`displyName`). */
+  get displayName(): string;
+  set displayName(v: string);
+  get headerRow(): boolean;
+  set headerRow(v: boolean);
+  get totalsRow(): boolean;
+  set totalsRow(v: boolean);
+  /** The table style name. exceljs reads and writes `style.name` here, which is never written to the file. */
+  get theme(): string | null | undefined;
+  set theme(v: string | null | undefined);
+  get showFirstColumn(): boolean;
+  set showFirstColumn(v: boolean);
+  get showLastColumn(): boolean;
+  set showLastColumn(v: boolean);
+  get showRowStripes(): boolean;
+  set showRowStripes(v: boolean);
+  get showColumnStripes(): boolean;
+  set showColumnStripes(v: boolean);
+}
+/**
+ * An image of the workbook, as exceljs `Image` (`workbook.addImage`). Give the file contents as
+ * `buffer` (bytes) or `base64` (a data URL or plain base64). xlvane recognises PNG, JPEG and GIF
+ * from the bytes; `extension` is kept but not used. `filename` names a file that is read when the
+ * workbook is written (Node.js, Bun, Deno), as exceljs reads it (xlsx.js addMedia L421–442).
+ *
+ * @example
+ * ```ts
+ * import type { ImageData } from '@xlvane/compat';
+ *
+ * declare const png: Uint8Array;
+ * const image: ImageData = { buffer: png, extension: 'png' };
+ * ```
+ */
+interface ImageData {
+  extension?: string;
+  buffer?: Uint8Array;
+  base64?: string;
+  filename?: string;
+  /** Set when read from a file: the media part's name without extension, as exceljs reads it. */
+  name?: string;
+  /** `"image"`, as in exceljs's media list. */
+  type?: "image";
+}
+/** A corner of a picture as exceljs models it (lib/doc/anchor.js): a 0-based cell and an offset in EMU. */
+interface AnchorModel {
+  nativeCol: number;
+  nativeColOff: number;
+  nativeRow: number;
+  nativeRowOff: number;
+}
+/**
+ * A corner of a picture, as exceljs `Anchor` (lib/doc/anchor.js): `nativeCol` and `nativeRow`
+ * are 0-based, the offsets are in EMU, and `col`/`row` give the position as a fraction of the
+ * cell, using exceljs's cell sizes (640000 per default column, 180000 per default row,
+ * `width * 10000` and `height * 10000` for custom ones).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * const sheet = workbook.addWorksheet('Report');
+ * declare const png: Uint8Array;
+ * sheet.addImage(workbook.addImage({ buffer: png, extension: 'png' }), 'B2:D6');
+ * const corner = sheet.getImages()[0]?.range?.tl;
+ * console.log(corner?.nativeCol, corner?.col); // 1 1
+ * ```
+ */
+export declare class Anchor implements AnchorModel {
+  readonly worksheet: Worksheet | undefined;
+  nativeCol: number;
+  nativeColOff: number;
+  nativeRow: number;
+  nativeRowOff: number;
+  /** @internal */
+  constructor(worksheet: Worksheet | undefined, address?: string | Partial<AnchorModel> | {
+    col: number;
+    row: number;
+  }, offset?: number);
+  get colWidth(): number;
+  get rowHeight(): number;
+  get col(): number;
+  set col(v: number);
+  get row(): number;
+  set row(v: number);
+  get model(): AnchorModel;
+}
+/**
+ * Where a picture goes, as in exceljs `worksheet.addImage` (index.d.ts L915–928): a range such as
+ * `"B2:D6"`, two corners `{ tl, br }`, or a corner and a size in pixels `{ tl, ext }`. Corners
+ * are 0-based `{ col, row }` (fractions are parts of a cell) or exceljs `nativeCol` objects.
+ *
+ * @example
+ * ```ts
+ * import type { ImageRangeInput } from '@xlvane/compat';
+ *
+ * const cells: ImageRangeInput = 'B2:D6';
+ * const sized: ImageRangeInput = { tl: { col: 1, row: 1 }, ext: { width: 160, height: 90 } };
+ * ```
+ */
+type ImageRangeInput = string | {
+  tl: string | Partial<AnchorModel> | {
+    col: number;
+    row: number;
+  };
+  br?: string | Partial<AnchorModel> | {
+    col: number;
+    row: number;
+  };
+  ext?: {
+    width: number;
+    height: number;
+  };
+  editAs?: "oneCell" | "twoCell" | "absolute";
+  hyperlinks?: {
+    hyperlink?: string;
+    tooltip?: string;
+  };
+};
+/** A picture or background of a worksheet (exceljs lib/doc/image.js). */
+interface SheetMedia {
+  type: "image" | "background";
+  imageId: number;
+  range?: {
+    tl: Anchor;
+    br?: Anchor;
+    ext?: {
+      width: number;
+      height: number;
+    };
+    editAs?: string;
+    hyperlinks?: {
+      hyperlink?: string;
+      tooltip?: string;
+    };
+  };
+}
+/** A picture placed on a sheet: `range` is always set (exceljs `getImages()`, index.d.ts L1342-1346). */
+type SheetImageMedia = SheetMedia & {
+  type: "image";
+  range: NonNullable<SheetMedia["range"]>;
+};
+/**
+ * The data validations of a worksheet (`worksheet.dataValidations`), keyed by cell address or
+ * range as in exceljs (lib/doc/data-validations.js). `remove()` deletes the entry; exceljs
+ * leaves an empty entry behind, which it writes as a validation without a type.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Form');
+ * sheet.dataValidations.add('B2:B20', { type: 'list', allowBlank: true, formulae: ['"Yes,No"'] });
+ * console.log(sheet.getCell('B5').dataValidation?.type); // list
+ * ```
+ */
+export declare class DataValidations {
+  private _model;
+  constructor(model?: Record<string, DataValidation | undefined>);
+  /** The validations by address or range, as exceljs `dataValidations.model`. Setting it copies the entries. */
+  get model(): Record<string, DataValidation | undefined>;
+  set model(value: Record<string, DataValidation | undefined>);
+  add(address: string, validation: DataValidation): DataValidation;
+  /** The validation of a cell: its own entry, or the entry of a range that contains it. */
+  find(address: string): DataValidation | undefined;
+  remove(address: string): void;
+}
+/** A splice on one axis: `count` positions from `at` are removed, then `inserts` positions are inserted at `at`. */
+interface SpliceChange {
+  readonly sheet: string;
+  readonly axis: "row" | "col";
+  readonly at: number;
+  readonly count: number;
+  readonly inserts: number;
+}
+/** `results` of `fillFormula`, typed as exceljs (index.d.ts L1327). */
+type FillFormulaResults = ((r: number, c: number) => string | number) | number[] | number[][];
+/**
+ * Value types, as in exceljs `lib/doc/enums.js` (ValueType).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const cell = new ExcelJS.Workbook().addWorksheet('S').getCell('A1');
+ * cell.value = 42;
+ * console.log(cell.type === ExcelJS.ValueType.Number); // true
+ * ```
+ */
+export declare const ValueType: {
+  readonly Null: 0;
+  readonly Merge: 1;
+  readonly Number: 2;
+  readonly String: 3;
+  readonly Date: 4;
+  readonly Hyperlink: 5;
+  readonly Formula: 6;
+  readonly SharedString: 7;
+  readonly RichText: 8;
+  readonly Boolean: 9;
+  readonly Error: 10;
+};
+/** A value of {@link ValueType}, so that `ExcelJS.ValueType` also works as a type, as with the exceljs enum. */
+export type ValueType = (typeof ValueType)[keyof typeof ValueType];
+/**
+ * Formula types, as in exceljs `lib/doc/enums.js` (FormulaType).
+ *
+ * @example
+ * ```ts
+ * import { FormulaType } from '@xlvane/compat';
+ *
+ * console.log(FormulaType.Master); // 1
+ * ```
+ */
+export declare const FormulaType: {
+  readonly None: 0;
+  readonly Master: 1;
+  readonly Shared: 2;
+};
+/** A value of {@link FormulaType} (usable as a type, as the exceljs enum). */
+export type FormulaType = (typeof FormulaType)[keyof typeof FormulaType];
+/**
+ * Error values, as in exceljs `lib/doc/enums.js` (ErrorValue).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const cell = new ExcelJS.Workbook().addWorksheet('S').getCell('A1');
+ * cell.value = { error: ExcelJS.ErrorValue.NotApplicable };
+ * ```
+ */
+export declare const ErrorValue: {
+  readonly NotApplicable: "#N/A";
+  readonly Ref: "#REF!";
+  readonly Name: "#NAME?";
+  readonly DivZero: "#DIV/0!";
+  readonly Null: "#NULL!";
+  readonly Value: "#VALUE!";
+  readonly Num: "#NUM!";
+};
+/** A value of {@link ErrorValue} (usable as a type, as the exceljs enum). */
+export type ErrorValue = (typeof ErrorValue)[keyof typeof ErrorValue];
+/**
+ * A cell, as exceljs `Cell` (lib/doc/cell.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Data');
+ * const cell = sheet.getCell('B2');
+ * cell.value = 42;
+ * cell.font = { bold: true };
+ * console.log(cell.address, cell.type === ExcelJS.ValueType.Number, cell.text); // B2 true 42
+ * ```
+ */
+export declare class Cell {
+  private readonly _row;
+  /** @internal The column number; changed when cells are spliced. */
+  _col: number;
+  /** The cell's style; `font`, `fill`, … are shortcuts to its properties. */
+  style: Style;
+  private _value;
+  private _note;
+  /** @internal Master cell when this cell is part of a merged range but not its top-left cell. */
+  _master: Cell | null;
+  /** @internal Number of merged ranges this cell is the master of. */
+  _mergeCount: number;
+  /** @internal Use `worksheet.getCell()`. */
+  constructor(_row: Row, _col: number);
+  get worksheet(): Worksheet;
+  get row(): number;
+  get col(): number;
+  get address(): string;
+  get $col$row(): string;
+  get value(): CellValue;
+  set value(v: CellValue);
+  /** The ValueType (Merge for the non-master cells of a merged range). */
+  get type(): ValueType;
+  /** The type of the value shown: for a formula, the type of its result. */
+  get effectiveType(): ValueType;
+  /** The value as text, as exceljs `cell.text`. */
+  get text(): string;
+  toString(): string;
+  get isMerged(): boolean;
+  /** The top-left cell of the merged range this cell belongs to (the cell itself otherwise). */
+  get master(): Cell;
+  /**
+   * The formula text. For a `{ sharedFormula: master }` value it is the master's formula moved to
+   * this cell, as exceljs translates it (lib/doc/cell.js `_getTranslatedFormula`; X4-29).
+   */
+  get formula(): string | undefined;
+  /** `FormulaType.Shared` for a `{ sharedFormula }` value, `Master` for other formulas, otherwise `None` (lib/doc/cell.js L807). */
+  get formulaType(): FormulaType;
+  get result(): unknown;
+  get numFmt(): string | undefined;
+  set numFmt(v: string | undefined);
+  get font(): Partial<Font> | undefined;
+  set font(v: Partial<Font> | undefined);
+  get fill(): Fill | undefined;
+  set fill(v: Fill | undefined);
+  get border(): Partial<Borders> | undefined;
+  set border(v: Partial<Borders> | undefined);
+  get alignment(): Partial<Alignment> | undefined;
+  set alignment(v: Partial<Alignment> | undefined);
+  /** `{ locked, hidden }`, as exceljs `cell.protection` (lib/doc/cell.js); it takes effect on a protected sheet. */
+  get protection(): Partial<Protection> | undefined;
+  set protection(v: Partial<Protection> | undefined);
+  /**
+   * The cell's note: a string or `{ texts: [{ text, font? }] }`, as in exceljs (lib/doc/cell.js
+   * L224–230). The note belongs to this cell, also inside a merged range. `undefined` removes it.
+   */
+  get note(): string | Comment | undefined;
+  set note(v: string | Comment | undefined);
+  /** The data validation of this cell: its own, or that of a range containing it (`worksheet.dataValidations`). */
+  get dataValidation(): DataValidation | undefined;
+  set dataValidation(v: DataValidation | undefined);
+  /** The link target of a `{ text, hyperlink }` value, as exceljs `cell.hyperlink` (lib/doc/cell.js L201). */
+  get hyperlink(): string | undefined;
+  /** Whether the value is a `{ text, hyperlink }` value (lib/doc/cell.js L197). */
+  get isHyperlink(): boolean;
+  get workbook(): Worksheet["workbook"];
+  /** Whether this cell is merged into `master` (lib/doc/cell.js L185). */
+  isMergedTo(master: Cell): boolean;
+  /**
+   * The value as a CSV field, as exceljs `cell.toCsvString` (lib/doc/cell.js L395–1049): text and
+   * rich text in double quotes with `"` doubled, dates in ISO form, booleans 1/0, a link's
+   * target, a formula's result (empty for none), an error's text (X4-30).
+   */
+  toCsvString(): string;
+  /** A plain-data snapshot `{ address, value, style, note? }` (X4-30); the setter takes the same shape. */
+  get model(): {
+    address: string;
+    value: CellValue;
+    style: Style;
+    note?: string | Comment;
+  };
+  set model(m: {
+    value?: CellValue;
+    style?: Style;
+    note?: string | Comment;
+  });
+  /** The cell's location for defined names: `{ sheetName, address, row, col }` (lib/doc/cell.js L270). */
+  get fullAddress(): {
+    sheetName: string;
+    address: string;
+    row: number;
+    col: number;
+  };
+  private get definedNames();
+  /** The first defined name that includes this cell. */
+  get name(): string | undefined;
+  set name(value: string);
+  /** The defined names that include this cell. */
+  get names(): string[];
+  set names(value: string[]);
+  addName(name: string): void;
+  removeName(name: string): void;
+  removeAllNames(): void;
+  /**
+   * Kept for exceljs code that calls it: exceljs deletes the cell's internal references here
+   * (lib/doc/cell.js L41–47), after which the cell must not be used. In @xlvane/compat the cell
+   * stays usable and nothing changes; memory is freed when the cell is no longer referenced.
+   */
+  destroy(): void;
+  /** @internal */
+  _merge(master: Cell): void;
+  /** @internal */
+  _unmerge(): void;
+}
+/**
+ * A row, as exceljs `Row` (lib/doc/row.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Data');
+ * const row = sheet.addRow(['Tea', 3.5]);
+ * row.font = { italic: true };
+ * console.log(row.number, row.values); // 1 [ <1 empty item>, 'Tea', 3.5 ]
+ * ```
+ */
+export declare class Row {
+  readonly worksheet: Worksheet;
+  /** Style applied to cells created in this row, and set on existing cells by the setters. */
+  style: Style;
+  height: number | undefined;
+  private _hidden;
+  /** @internal */
+  _cells: (Cell | undefined)[];
+  /** @internal The row number; changed when rows are spliced. */
+  _number: number;
+  /** @internal Use `worksheet.getRow()`. */
+  constructor(worksheet: Worksheet, number: number);
+  /** The row number. It follows the row when rows are inserted or removed above it. */
+  get number(): number;
+  get hidden(): boolean;
+  set hidden(v: boolean);
+  private _outlineLevel;
+  /** Outline (grouping) level 0–7 (lib/doc/row.js L318). */
+  get outlineLevel(): number;
+  set outlineLevel(v: number);
+  /** As exceljs: the level is at least the sheet's `properties.outlineLevelRow` (lib/doc/row.js L326). */
+  get collapsed(): boolean;
+  /**
+   * Kept for exceljs code that calls it: exceljs deletes the row's internal references here
+   * (lib/doc/row.js L34–38), after which the row must not be used. In @xlvane/compat the row
+   * stays usable and nothing changes; memory is freed when the row is no longer referenced.
+   */
+  destroy(): void;
+  findCell(col: number): Cell | undefined;
+  /** The cell at `address.col`, created if missing (lib/doc/row.js L45). */
+  getCellEx(address: {
+    col: number;
+  }): Cell;
+  /** The cell at a column number, letters or column key; created if missing. */
+  getCell(col: number | string): Cell;
+  /** Visits cells with a value (all cells up to the last one with `includeEmpty`). */
+  eachCell(options: {
+    includeEmpty?: boolean;
+  } | ((cell: Cell, col: number) => void), iteratee?: (cell: Cell, col: number) => void): void;
+  /** Sparse array of values, index 0 unused (lib/doc/row.js `values`). */
+  get values(): CellValue[];
+  /**
+   * Replaces the row's values: a contiguous array starts at column A, a sparse array (index 0
+   * unset) uses its indexes as column numbers, an object is matched to column keys.
+   */
+  set values(value: CellValue[] | Record<string, CellValue> | null | undefined);
+  get hasValues(): boolean;
+  get cellCount(): number;
+  get actualCellCount(): number;
+  get dimensions(): {
+    min: number;
+    max: number;
+  } | null;
+  private applyStyle;
+  get numFmt(): string | undefined;
+  set numFmt(v: string | undefined);
+  get font(): Partial<Font> | undefined;
+  set font(v: Partial<Font> | undefined);
+  get fill(): Fill | undefined;
+  set fill(v: Fill | undefined);
+  get border(): Partial<Borders> | undefined;
+  set border(v: Partial<Borders> | undefined);
+  get alignment(): Partial<Alignment> | undefined;
+  set alignment(v: Partial<Alignment> | undefined);
+  get protection(): Partial<Protection> | undefined;
+  set protection(v: Partial<Protection> | undefined);
+  /** Streaming writers write committed rows; in a normal workbook this does nothing (as in exceljs). */
+  commit(): void;
+  /**
+   * Removes `count` cells from column `start` and inserts `inserts` there; the cells to the right
+   * move with their values, styles and notes (as exceljs `row.splice`, lib/doc/row.js L77). A row
+   * crossing a merged range at or right of `start` is refused, because the range cannot follow
+   * cells of one row; use `worksheet.spliceColumns` or unmerge first. Formulas are not rewritten,
+   * as in exceljs.
+   */
+  splice(start: number, count: number, ...inserts: CellValue[]): void;
+  /** @internal Moves the cell objects of this row for a column splice. */
+  _spliceCells(change: SpliceChange, method: string): void;
+  /**
+   * Adds a manual page break after this row, as exceljs (lib/doc/row.js L150–162). The column
+   * limits `lft`/`rght` are kept on the break; Office ignores them ([MS-OI29500] §2.1.589 b).
+   */
+  addPageBreak(lft?: number, rght?: number): void;
+}
+/**
+ * A column, as exceljs `Column` (lib/doc/column.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Data');
+ * sheet.columns = [{ header: 'Name', key: 'name', width: 20 }, { header: 'Total', key: 'total' }];
+ * sheet.getColumn('total').numFmt = '#,##0.00';
+ * console.log(sheet.getColumn('name').letter); // A
+ * ```
+ */
+export declare class Column {
+  readonly worksheet: Worksheet;
+  width: number | undefined;
+  style: Style;
+  private _hidden;
+  private _key;
+  private _header;
+  /** @internal The column number; changed when columns are spliced. */
+  _number: number;
+  /** @internal Use `worksheet.getColumn()`. */
+  constructor(worksheet: Worksheet, number: number);
+  /** The column number. It follows the column when columns are inserted or removed before it. */
+  get number(): number;
+  get letter(): string;
+  get key(): string | undefined;
+  set key(value: string | undefined);
+  get header(): string | string[] | undefined;
+  set header(value: string | string[] | undefined);
+  get headers(): (string | undefined)[];
+  get hidden(): boolean;
+  set hidden(v: boolean);
+  get isCustomWidth(): boolean;
+  private _outlineLevel;
+  /** Outline (grouping) level 0–7 (lib/doc/column.js L116). */
+  get outlineLevel(): number;
+  set outlineLevel(v: number);
+  /** As exceljs: the level is at least the sheet's `properties.outlineLevelCol` (lib/doc/column.js L124). */
+  get collapsed(): boolean;
+  /** A column that is written to the file only when it differs from the default (lib/doc/column.js L147). */
+  get isDefault(): boolean;
+  /** Number of header rows (lib/doc/column.js L164). */
+  get headerCount(): number;
+  /** `{ key, width, headers }` as JSON (lib/doc/column.js L130). */
+  toString(): string;
+  /** Same width, visibility, outline level and style (lib/doc/column.js L138). */
+  equivalentTo(other: Column): boolean;
+  get defn(): ColumnDefn;
+  set defn(value: ColumnDefn | undefined);
+  /** Cell values of this column by row number (index 0 unused). */
+  get values(): CellValue[];
+  set values(values: CellValue[]);
+  eachCell(options: {
+    includeEmpty?: boolean;
+  } | ((cell: Cell, row: number) => void), iteratee?: (cell: Cell, row: number) => void): void;
+  private applyStyle;
+  get numFmt(): string | undefined;
+  set numFmt(v: string | undefined);
+  get font(): Partial<Font> | undefined;
+  set font(v: Partial<Font> | undefined);
+  get fill(): Fill | undefined;
+  set fill(v: Fill | undefined);
+  get border(): Partial<Borders> | undefined;
+  set border(v: Partial<Borders> | undefined);
+  get alignment(): Partial<Alignment> | undefined;
+  set alignment(v: Partial<Alignment> | undefined);
+  get protection(): Partial<Protection> | undefined;
+  set protection(v: Partial<Protection> | undefined);
+}
+/**
+ * A worksheet, as exceljs `Worksheet` (lib/doc/worksheet.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const sheet = new ExcelJS.Workbook().addWorksheet('Sales', { views: [{ state: 'frozen', ySplit: 1 }] });
+ * sheet.columns = [{ header: 'Region', key: 'region', width: 15 }, { header: 'Revenue', key: 'revenue' }];
+ * sheet.addRow({ region: 'North', revenue: 1250 });
+ * sheet.mergeCells('D1:E1');
+ * sheet.eachRow((row, n) => console.log(n, row.values));
+ * ```
+ */
+export declare class Worksheet {
+  readonly workbook: {
+    readonly _names: (exclude: Worksheet) => string[];
+    readonly definedNames?: DefinedNames;
+    readonly worksheets?: readonly Worksheet[];
+  };
+  readonly id: number;
+  /**
+   * The position of the sheet in `workbook.worksheets`, as exceljs `orderNo`: one more than the
+   * largest of the other sheets for a new sheet (lib/doc/workbook.js L81-85), the 0-based position
+   * in the file for a loaded one (L203). Worksheets are listed in this order.
+   */
+  orderNo: number | undefined;
+  state: "visible" | "hidden" | "veryHidden";
+  views: WorksheetView[];
+  autoFilter: string | {
+    from: string | {
+      row: number;
+      column: number;
+    };
+    to: string | {
+      row: number;
+      column: number;
+    };
+  } | null;
+  /** Sheet properties (exceljs `WorksheetProperties`); unknown keys are kept as given. */
+  properties: WorksheetProperties & Record<string, unknown>;
+  /** Printing settings, with the defaults of exceljs (lib/doc/worksheet.js L64–90). */
+  pageSetup: PageSetup;
+  /** Headers and footers, with the defaults of exceljs. */
+  headerFooter: HeaderFooter;
+  /** Manual row breaks (`row.addPageBreak()`). */
+  rowBreaks: RowBreak[];
+  /** Data validations by cell address or range. */
+  dataValidations: DataValidations;
+  /** Conditional formats, in the order they were added. */
+  conditionalFormattings: ConditionalFormattingOptions[];
+  /** The protection set by `protect()`, or `null`. */
+  sheetProtection: (Partial<WorksheetProtection> & {
+    sheet?: boolean;
+    [key: string]: unknown;
+  }) | null;
+  /** @internal */
+  _rows: (Row | undefined)[];
+  /** @internal */
+  _columns: Column[];
+  /** @internal */
+  _merges: Map<string, {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+  }>;
+  private readonly _keys;
+  private _name;
+  /** @internal Use `workbook.addWorksheet()`. */
+  constructor(workbook: {
+    readonly _names: (exclude: Worksheet) => string[];
+    readonly definedNames?: DefinedNames;
+    readonly worksheets?: readonly Worksheet[];
+  }, id: number, name: string | undefined, options: WorksheetOptions | undefined);
+  get name(): string;
+  /** Sheet name rules of exceljs (lib/doc/worksheet.js L134–173), including truncation to 31 characters. */
+  set name(value: string);
+  /** Deprecated in exceljs in favour of `properties.tabColor`, which it reads and sets (lib/doc/worksheet.js L827). */
+  get tabColor(): unknown;
+  set tabColor(value: unknown);
+  get columns(): Column[];
+  set columns(defs: ColumnDefn[]);
+  /** @internal */
+  findColumn(n: number): Column | undefined;
+  getColumn(c: number | string): Column;
+  getColumnKey(key: string): Column | undefined;
+  setColumnKey(key: string, column: Column): void;
+  deleteColumnKey(key: string): void;
+  eachColumnKey(f: (column: Column, key: string) => void): void;
+  get columnCount(): number;
+  get actualColumnCount(): number;
+  /**
+   * Removes `count` columns from `start` and inserts one column per item of `inserts` there; each
+   * insert is an array of values by row (index 0 is row 1). Columns to the right move with their
+   * cells, widths, styles, keys and notes, and merged ranges, the autofilter, defined names and
+   * formulas follow, as in a spreadsheet application (exceljs 4.4.0 moves values and styles only,
+   * docs/exceljs-compat.md). Falsy insert values such as `0` are kept.
+   */
+  spliceColumns(start: number, count: number, ...inserts: CellValue[][]): void;
+  /** @internal Rows already written and dropped by a streaming writer still count. */
+  _committedRows: number;
+  private get lastRowNumber();
+  get rowCount(): number;
+  get actualRowCount(): number;
+  get lastRow(): Row | undefined;
+  findRow(r: number): Row | undefined;
+  getRow(r: number): Row;
+  getRows(start: number, length: number): Row[] | undefined;
+  /** Adds a row after the last one; style `'i'` / `'i+'` copies the style of the row above (exceljs `addRow`). */
+  addRow(values: CellValue[] | Record<string, CellValue>, style?: string): Row;
+  addRows(rows: (CellValue[] | Record<string, CellValue>)[], style?: string): Row[];
+  /**
+   * Inserts a row at `pos`; the rows from `pos` down move one row down. `style` copies a style as
+   * exceljs does: `'i'` from the row above, `'o'` from the row below (the one that moved down),
+   * with `+` also for empty cells, `'n'` none.
+   */
+  insertRow(pos: number, value?: CellValue[] | Record<string, CellValue> | null, style?: string): Row;
+  /** Inserts one row per item of `values` at `pos`, with the style options of `insertRow`. */
+  insertRows(pos: number, values: (CellValue[] | Record<string, CellValue> | null)[], style?: string): Row[] | undefined;
+  /**
+   * Makes `count` copies of row `rowNum` below it, inserting new rows with `insert = true` or
+   * overwriting the rows below with `insert = false` (the default of exceljs's code; its README
+   * says `true`). Copies get the values, styles and height and the merged ranges inside the row;
+   * a formula is copied as a spreadsheet application copies a cell: its relative references move by
+   * the distance of the copy. With `insert = true` the rows below move first and every formula
+   * follows (spliceRows); with `insert = false` the rows below are overwritten in place, merged
+   * ranges that touch them are removed, and no other formula changes.
+   */
+  duplicateRow(rowNum: number, count: number, insert?: boolean): void;
+  /**
+   * Removes `count` rows from `start` and inserts one row per item of `inserts` (an array or object
+   * of values) there. Rows below move with their cells, styles, heights, hidden flag and notes, and
+   * merged ranges, the autofilter, defined names and formulas follow, as in a spreadsheet
+   * application. exceljs 4.4.0 moves values, styles and heights only (docs/exceljs-compat.md).
+   */
+  spliceRows(start: number, count: number, ...inserts: (CellValue[] | Record<string, CellValue> | null | undefined)[]): void;
+  /** exceljs `_setStyleOption` (worksheet.js L444–450). */
+  private _setStyleOption;
+  /** exceljs `_copyStyle` (worksheet.js L452–461), with copies instead of shared style objects. */
+  private _copyStyle;
+  /** @internal Removes every merged range and returns them, for a splice. */
+  _takeMerges(): {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+  }[];
+  /**
+   * @internal Merges the ranges again at their new place: a range loses the removed rows or
+   * columns, grows when rows or columns are inserted inside it, and disappears when one cell or
+   * nothing is left. When the top-left cell was removed, the new top-left cell becomes the master
+   * with its own (empty) value.
+   */
+  _restoreMerges(merges: readonly {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+  }[], change: SpliceChange): void;
+  /**
+   * @internal Merges a range without the overlap check of `mergeCells`. Cells keep their own
+   * style, except those for which `takeMasterStyle` returns true (cells inserted inside the range),
+   * which get a copy of the master's style; style objects are never shared.
+   */
+  _mergeRange(range: {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+  }, takeMasterStyle?: (r: number, c: number) => boolean): void;
+  /**
+   * @internal The autofilter range and every formula of the workbook follow a splice of this
+   * sheet. `formulas` are the new texts computed by `_checkFormulas` before the splice.
+   */
+  _afterSplice(change: SpliceChange, formulas: ReadonlyMap<Cell, Record<string, unknown>>): void;
+  /**
+   * @internal Refuses a splice that tables or pictures cannot follow, before anything changes:
+   * tables do not move in @xlvane/compat (as in exceljs), so rows or columns may not be inserted
+   * or removed at or before a table's last row or column; a picture corner in a removed row or
+   * column has no place to go.
+   */
+  _checkMedia(change: SpliceChange, method: string): void;
+  /**
+   * @internal Computes the new text of every formula of the workbook that `change` alters, and
+   * throws before anything changes when one cannot follow it. Each formula is parsed once.
+   */
+  _checkFormulas(change: SpliceChange, method: string): Map<Cell, Record<string, unknown>>;
+  private _sheetNames;
+  private _eachFormula;
+  eachRow(options: {
+    includeEmpty?: boolean;
+  } | ((row: Row, n: number) => void), iteratee?: (row: Row, n: number) => void): void;
+  getSheetValues(): CellValue[][];
+  /** @internal Overridden by the streaming writer. */
+  _commitRow(_row: Row): void;
+  findCell(r: number | string, c?: number): Cell | undefined;
+  getCell(r: number | string, c?: number | string): Cell;
+  /**
+   * The range of the cells with values, as an exceljs `Range` (worksheet.js L186): `top`, `left`,
+   * `bottom`, `right`, `tl`, `br`, `range`, `model` and `toString()`. An empty sheet gives the
+   * model `{ top: 0, left: 0, bottom: 0, right: 0 }` and the range "A1:A1", as in exceljs.
+   */
+  get dimensions(): Range;
+  /** Rows from `start`, `length` of them, without creating missing rows (lib/doc/worksheet.js `findRows`). */
+  findRows(start: number, length: number): (Row | undefined)[];
+  /** The last column with a definition (lib/doc/worksheet.js `lastColumn`). */
+  get lastColumn(): Column;
+  /** Releases the worksheet's data (exceljs frees memory here); the sheet is empty afterwards. */
+  destroy(): void;
+  /**
+   * Sets a shared formula (or an array formula with `shareType: 'array'`) over `range`, as exceljs
+   * `fillFormula` (lib/doc/worksheet.js L678–721; X4-29): the top-left cell gets `{ shareType,
+   * formula, ref, result }`, the others `{ sharedFormula: topLeft, result }` (shared) or their
+   * result (array). `results` is a function `(row, col) => result`, a flat array or a 2-D array.
+   */
+  fillFormula(range: string, formula: string, results?: FillFormulaResults, shareType?: "shared" | "array"): void;
+  /**
+   * A plain-data snapshot of the worksheet, as exceljs `worksheet.model` (X4-30): id, name, state,
+   * properties, views, autoFilter, page setup, header and footer, breaks, protection, validations,
+   * conditional formats, merges, column definitions and rows with their cells. The setter takes
+   * the same shape. Tables and pictures are not part of it.
+   */
+  get model(): Record<string, unknown>;
+  set model(m: Record<string, unknown>);
+  /** As `mergeCells`, but the other cells keep their own style (lib/doc/worksheet.js L606). */
+  mergeCellsWithoutStyle(...args: unknown[]): void;
+  private _mergeKeepStyle;
+  mergeCells(...args: unknown[]): void;
+  unMergeCells(...args: unknown[]): void;
+  get hasMerges(): boolean;
+  /** Adds conditional formatting for a range (exceljs `addConditionalFormatting`). */
+  addConditionalFormatting(cf: ConditionalFormattingOptions): void;
+  /**
+   * Removes conditional formatting: the entry at an index, the entries a filter function rejects,
+   * or all of them for any other argument (lib/doc/worksheet.js L815–822).
+   */
+  removeConditionalFormatting(filter?: number | ((cf: ConditionalFormattingOptions, index: number) => boolean) | string | boolean | null | Record<string, unknown>): void;
+  /**
+   * Protects the sheet (exceljs `protect`). Options say what users may still do
+   * (`formatCells: true` allows formatting). A non-empty password is stored as exceljs stores it:
+   * a SHA-512 verifier with a random 16-byte salt and `spinCount` iterations (default 100000;
+   * xlvane `hashPassword`, docs/decisions.md D-C08). The options object is not modified
+   * (exceljs rounds its `spinCount` in place).
+   */
+  protect(password?: string, options?: Partial<WorksheetProtection>): Promise<void>;
+  /** Removes the protection. */
+  unprotect(): void;
+  /**
+   * Tables by name, as exceljs `worksheet.tables`. The object has no prototype, so names such as
+   * "constructor" or "__proto__" are plain entries (D-R01).
+   */
+  tables: Record<string, Table>;
+  /** @internal Pictures and the background, as exceljs `worksheet._media`. */
+  _media: SheetMedia[];
+  /**
+   * Adds a table and writes its header, rows and totals into the cells (exceljs `addTable`).
+   * Names are unique in the workbook, ignoring case (`XLV_E_INVALID_TABLE`); exceljs replaces a
+   * table of the same name on this sheet.
+   */
+  addTable(model: TableProperties): Table;
+  /**
+   * The table with this name. Typed `Table` as in exceljs (index.d.ts L1365), so exceljs code
+   * type-checks unchanged; at run time a missing name gives `undefined`, as exceljs does
+   * (lib/doc/worksheet.js L797-799).
+   */
+  getTable(name: string): Table;
+  /** Removes the table; its cells are kept, as in exceljs. */
+  removeTable(name: string): void;
+  /** The tables of the sheet (an array; exceljs's typings say tuples). */
+  getTables(): Table[];
+  /** Places an image of the workbook (`workbook.addImage`) on the sheet. */
+  addImage(imageId: number, range: ImageRangeInput): void;
+  /**
+   * The pictures of the sheet, as exceljs `getImages()`: `{ type, imageId, range }`; `range` is
+   * always set for a picture (index.d.ts L1342-1346 types it as required).
+   */
+  getImages(): SheetImageMedia[];
+  /** Uses an image of the workbook as the sheet background. */
+  addBackgroundImage(imageId: number): void;
+  /** The id of the background image, or `undefined`. */
+  getBackgroundImageId(): number | undefined;
+}
+/** Implements exceljs `Range` for sheet dimensions; created by the worksheet, not by users. */
+declare class Dimensions implements Range {
+  readonly model: Location & {
+    sheetName?: string;
+  };
+  get top(): number;
+  get left(): number;
+  get bottom(): number;
+  get right(): number;
+  /** Grows the range to include the given rectangle (exceljs `expand`, range.js L163). */
+  expand(top: number, left: number, bottom: number, right: number): void;
+  /** Grows the range to include the cells of a row (exceljs `expandRow`, range.js L170). */
+  expandRow(row: {
+    readonly number: number;
+    readonly dimensions: {
+      min: number;
+      max: number;
+    } | null;
+  }): void;
+  get tl(): string;
+  get $t$l(): string;
+  get br(): string;
+  get $b$r(): string;
+  get range(): string;
+  get $range(): string;
+  get shortRange(): string;
+  get $shortRange(): string;
+  get count(): number;
+  toString(): string;
+}
+/** A writable Node.js stream. */
+interface WritableLike {
+  write(chunk: Uint8Array, callback?: (error?: unknown) => void): unknown;
+  end(callback?: () => void): unknown;
+}
+/**
+ * Options of {@link WorkbookWriter}, as exceljs `WorkbookWriter` options.
+ *
+ * @example
+ * ```ts
+ * import type { WorkbookWriterOptions } from '@xlvane/compat';
+ *
+ * const options: WorkbookWriterOptions = { filename: 'big.xlsx', useSharedStrings: false, useStyles: true };
+ * ```
+ */
+interface WorkbookWriterOptions {
+  /** Output file (Node.js). */
+  filename?: string;
+  /** Output stream. */
+  stream?: WritableLike;
+  /** Use a shared string table (default false: strings are stored in their cells). */
+  useSharedStrings?: boolean;
+  /** Write cell styles (default false, as in exceljs). */
+  useStyles?: boolean;
+  /** Document properties written to `docProps/core.xml` (defaults as in exceljs). */
+  created?: Date;
+  modified?: Date;
+  creator?: string;
+  lastModifiedBy?: string;
+  lastPrinted?: Date;
+  /** archiver options; `zlib.level` (0–9) sets the Deflate level of the parts. */
+  zip?: unknown;
+}
+/**
+ * A worksheet of a {@link WorkbookWriter}: rows are written when committed and then dropped.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const writer = new ExcelJS.stream.xlsx.WorkbookWriter({ filename: 'big.xlsx' });
+ * const sheet = writer.addWorksheet('Data');
+ * sheet.addRow([1, 'one']).commit();
+ * sheet.commit();
+ * await writer.commit();
+ * ```
+ */
+export declare class WorksheetWriter extends Worksheet {
+  private readonly writer;
+  private readonly rowsOut;
+  private started;
+  private committedUpTo;
+  /** The layout written when the sheet started, to detect later changes that would be lost. */
+  private layout;
+  /** @internal */
+  constructor(writer: WorkbookWriter, id: number, name: string | undefined, options: WorksheetOptions | undefined);
+  /** @internal The sheet spec, made when the first row is committed (layout must be set by then). */
+  _spec(): StreamSheetSpec;
+  private currentLayout;
+  /** The background (exceljs `addBackgroundImage`, worksheet-writer.js L474) and pictures, by image id. */
+  private mediaSpec;
+  override addTable(): never;
+  override mergeCells(...args: unknown[]): void;
+  override spliceRows(): void;
+  override insertRow(): Row;
+  override insertRows(): Row[] | undefined;
+  override duplicateRow(): void;
+  override spliceColumns(): void;
+  /** Formulas of written rows, by address, for later `{ sharedFormula }` dependents. */
+  private readonly formulaMasters;
+  /** @internal Writes every row up to `row` and drops it from memory. */
+  override _commitRow(row: Row): void;
+  private flush;
+  /** Commits the remaining rows and closes the worksheet. */
+  commit(): void;
+}
+/**
+ * The streaming writer of exceljs (`ExcelJS.stream.xlsx.WorkbookWriter`). Committed rows are
+ * written at once and dropped, so memory stays constant. Strings are stored in their cells
+ * unless `useSharedStrings` is set; styles are written only with `useStyles: true`, as in exceljs.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({ filename: 'big.xlsx', useStyles: true });
+ * const sheet = workbook.addWorksheet('Data');
+ * sheet.columns = [{ header: 'Id', key: 'id', width: 10 }];
+ * for (let id = 1; id <= 100_000; id++) sheet.addRow({ id }).commit();
+ * sheet.commit();
+ * await workbook.commit();
+ * ```
+ */
+export declare class WorkbookWriter {
+  /** @internal */
+  readonly _book: Workbook;
+  /** @internal */
+  readonly _useStyles: boolean;
+  private readonly sheets;
+  private readonly open;
+  private done;
+  private readonly options;
+  private written;
+  private nextId;
+  created: Date;
+  modified: Date;
+  creator: string;
+  lastModifiedBy: string;
+  lastPrinted: Date | undefined;
+  /** Workbook windows, written as exceljs's workbook writer writes them (workbook-writer.js L43, L321; D-E06). */
+  views: Record<string, unknown>[];
+  constructor(options?: WorkbookWriterOptions);
+  /**
+   * Adds an image (PNG, JPEG or GIF; `buffer` or `base64`) and returns its id, as exceljs
+   * `workbookWriter.addImage`. Images are written when the first sheet starts, so they must be
+   * added before the first row is committed.
+   */
+  addImage(image: ImageData): number;
+  /** The image with this id (typed `Image` as in exceljs, index.d.ts L1780; `undefined` for an unknown id). */
+  getImage(id: number): Image;
+  /** Defined names, as exceljs `workbookWriter.definedNames`; set them before the first row is committed. */
+  get definedNames(): DefinedNames;
+  /** The document properties and names written; they are fixed when writing starts. */
+  private meta;
+  /** Starts the xlvane stream (once): when the first sheet starts or at commit. */
+  private begin;
+  /** Adds a worksheet. Sheets are written in the order their first rows are committed. */
+  addWorksheet(name?: string, options?: WorksheetOptions): WorksheetWriter;
+  getWorksheet(id?: number | string): WorksheetWriter | undefined;
+  /** @internal Starts writing a sheet (once). */
+  _start(sheet: WorksheetWriter): void;
+  /** Commits all worksheets and finishes the file. */
+  commit(): Promise<void>;
+}
+type Listener = (...args: unknown[]) => void;
+/** The part of Node.js `EventEmitter` that exceljs's streaming reader uses; no node:events import. */
+declare class Emitter {
+  private readonly listeners;
+  on(event: string, fn: Listener): this;
+  addListener(event: string, fn: Listener): this;
+  once(event: string, fn: Listener): this;
+  off(event: string, fn: Listener): this;
+  removeListener(event: string, fn: Listener): this;
+  removeAllListeners(event?: string): this;
+  listenerCount(event: string): number;
+  emit(event: string, ...args: unknown[]): boolean;
+}
+/**
+ * Options of {@link WorkbookReader}, as exceljs `WorkbookStreamReaderOptions` (index.d.ts L1988).
+ *
+ * @example
+ * ```ts
+ * import type { WorkbookReaderOptions } from '@xlvane/compat';
+ *
+ * const options: WorkbookReaderOptions = { styles: 'cache', entries: 'emit' };
+ * ```
+ */
+interface WorkbookReaderOptions {
+  worksheets?: "emit" | "ignore";
+  /** Only `cache` (the default): `emit` and `ignore` throw `XLV_E_NOT_SUPPORTED`. */
+  sharedStrings?: "cache" | "emit" | "ignore";
+  /** `ignore` (default) or `cache`, which changes nothing for files in schema order (links follow the rows); `emit` throws `XLV_E_NOT_SUPPORTED`. */
+  hyperlinks?: "cache" | "emit" | "ignore";
+  /** `cache` gives the cells their styles; `ignore` (default) does not. */
+  styles?: "cache" | "ignore";
+  /** `emit` sends `entry` events for the workbook and each worksheet. */
+  entries?: "emit" | "ignore";
+}
+/**
+ * A worksheet read by {@link WorkbookReader}, as exceljs `WorksheetReader`: iterate its rows with
+ * `for await`, or call `read()` and listen to `row` and `finished` events.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const reader = new ExcelJS.stream.xlsx.WorkbookReader('big.xlsx', {});
+ * for await (const worksheet of reader) {
+ *   console.log(worksheet.name, worksheet.state);
+ *   for await (const row of worksheet) console.log(row.number);
+ *   console.log(worksheet.dimensions.range);
+ * }
+ * ```
+ */
+export declare class WorksheetReader extends Emitter implements AsyncIterable<Row> {
+  readonly workbook: WorkbookReader;
+  readonly id: number;
+  readonly name: string;
+  readonly state: "visible" | "hidden" | "veryHidden";
+  private readonly sheet;
+  private readonly rows;
+  /** The range of the rows read so far, as exceljs's `Range` (lib/doc/range.js). */
+  readonly dimensions: Dimensions;
+  /** @internal */
+  constructor(workbook: WorkbookReader, id: number, name: string, state: "visible" | "hidden" | "veryHidden", sheet: Worksheet, rows: () => AsyncIterable<Row>);
+  /** Column definitions read so far, or `null` (as exceljs before any `getColumn`). */
+  get columns(): ReturnType<Worksheet["getColumn"]>[] | null;
+  getColumn(c: number | string): ReturnType<Worksheet["getColumn"]>;
+  getColumnKey(key: string): ReturnType<Worksheet["getColumnKey"]>;
+  setColumnKey(key: string, value: ReturnType<Worksheet["getColumn"]>): void;
+  deleteColumnKey(key: string): void;
+  eachColumnKey(f: Parameters<Worksheet["eachColumnKey"]>[0]): void;
+  /** Not valid on a streamed worksheet (it throws in exceljs too). */
+  destroy(): never;
+  [Symbol.asyncIterator](): AsyncIterator<Row>;
+  /** Events of the rows: `row` (a Row), then `finished`; `error` on failure. */
+  parse(): AsyncGenerator<{
+    eventType: string;
+    value: unknown;
+  }[]>;
+  /** Reads the rows and emits `row` events, then `finished` (or `error`). */
+  read(): Promise<void>;
+}
+/**
+ * The streaming reader of exceljs (`ExcelJS.stream.xlsx.WorkbookReader`): iterate worksheets
+ * and their rows with `for await`, or call `read()` and listen to `worksheet`, `end`,
+ * `finished` and `error` events (and `entry` with `entries: 'emit'`). Rows are not kept.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const reader = new ExcelJS.stream.xlsx.WorkbookReader('big.xlsx', { styles: 'cache' });
+ * for await (const worksheet of reader) {
+ *   for await (const row of worksheet) console.log(row.number, row.values);
+ * }
+ * ```
+ */
+export declare class WorkbookReader extends Emitter implements AsyncIterable<WorksheetReader> {
+  private readonly input;
+  private options;
+  constructor(input: string | Uint8Array | ArrayBuffer | AsyncIterable<Uint8Array>, options?: WorkbookReaderOptions | Record<string, unknown>);
+  private open;
+  /** Worksheet events in workbook order, as exceljs `parse()` yields them (`{ eventType: 'worksheet', value }`). */
+  parse(input?: string | Uint8Array | ArrayBuffer | AsyncIterable<Uint8Array>, options?: WorkbookReaderOptions): AsyncGenerator<{
+    eventType: string;
+    value: unknown;
+  }>;
+  [Symbol.asyncIterator](): AsyncIterator<WorksheetReader>;
+  /**
+   * Reads the workbook and emits events, as exceljs `read()`: `worksheet` for each worksheet
+   * (its rows are read after the listeners run; listen to the worksheet's `row` events), then
+   * `end` and `finished`; `error` on failure.
+   */
+  read(input?: string | Uint8Array | ArrayBuffer | AsyncIterable<Uint8Array>, options?: WorkbookReaderOptions): Promise<void>;
+}
+/**
+ * exceljs `RelationshipType` (lib/doc/enums.js), kept for code that reads it.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * console.log(ExcelJS.RelationshipType.Worksheet); // 2
+ * ```
+ */
+export declare const RelationshipType: {
+  readonly None: 0;
+  readonly OfficeDocument: 1;
+  readonly Worksheet: 2;
+  readonly CalcChain: 3;
+  readonly SharedStrings: 4;
+  readonly Styles: 5;
+  readonly Theme: 6;
+  readonly Hyperlink: 7;
+};
+/** A value of {@link RelationshipType} (usable as a type, as the exceljs enum). */
+export type RelationshipType = (typeof RelationshipType)[keyof typeof RelationshipType];
+/**
+ * exceljs `DocumentType` (lib/doc/enums.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * console.log(ExcelJS.DocumentType.Xlsx); // 1
+ * ```
+ */
+export declare const DocumentType: {
+  readonly Xlsx: 1;
+};
+/** A value of {@link DocumentType} (usable as a type, as the exceljs enum). */
+export type DocumentType = (typeof DocumentType)[keyof typeof DocumentType];
+/**
+ * exceljs `ReadingOrder` (lib/doc/enums.js).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * console.log(ExcelJS.ReadingOrder.RightToLeft); // 2
+ * ```
+ */
+export declare const ReadingOrder: {
+  readonly LeftToRight: 1;
+  readonly RightToLeft: 2;
+};
+/** A value of {@link ReadingOrder} (usable as a type, as the exceljs enum). */
+export type ReadingOrder = (typeof ReadingOrder)[keyof typeof ReadingOrder];
+/**
+ * The streaming API, as `ExcelJS.stream`.
+ *
+ * @example
+ * ```ts
+ * import { stream } from '@xlvane/compat';
+ *
+ * const writer = new stream.xlsx.WorkbookWriter({ filename: 'out.xlsx' });
+ * writer.addWorksheet('Data').addRow([1]).commit();
+ * await writer.commit();
+ * ```
+ */
+export declare const stream: {
+  readonly xlsx: {
+    readonly WorkbookWriter: typeof WorkbookWriter;
+    readonly WorkbookReader: typeof WorkbookReader;
+  };
+};
+/** Types of the streaming API as exceljs declares them (`ExcelJS.stream.xlsx.WorkbookWriterOptions`). */
+export declare namespace stream {
+  namespace xlsx {
+    type WorkbookWriter = XlvTypeOfWorkbookWriter;
+    type WorkbookReader = XlvTypeOfWorkbookReader;
+    type WorksheetWriter = XlvTypeOfWorksheetWriter;
+    type WorksheetReader = XlvTypeOfWorksheetReader;
+    type WorkbookWriterOptions = XlvTypeOfWorkbookWriterOptions;
+    type WorkbookReaderOptions = XlvTypeOfWorkbookReaderOptions;
+    /** The name exceljs's index.d.ts uses for the reader options. */
+    type WorkbookStreamReaderOptions = XlvTypeOfWorkbookReaderOptions;
+  }
+}
+/**
+ * Kept for exceljs compatibility (`ExcelJS.ModelContainer`); not supported.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * console.log(typeof ExcelJS.ModelContainer); // function
+ * ```
+ */
+export declare class ModelContainer {
+  constructor();
+}
+/**
+ * The shape of the default export (and of `require('exceljs')`).
+ *
+ * @example
+ * ```ts
+ * import ExcelJS, { type ExcelJSModule } from '@xlvane/compat';
+ *
+ * const lib: ExcelJSModule = ExcelJS;
+ * const workbook = new lib.Workbook();
+ * ```
+ */
+export interface ExcelJSModule {
+  readonly Workbook: typeof Workbook;
+  readonly ModelContainer: typeof ModelContainer;
+  readonly stream: typeof stream;
+  readonly ValueType: typeof ValueType;
+  readonly FormulaType: typeof FormulaType;
+  readonly ErrorValue: typeof ErrorValue;
+  readonly RelationshipType: typeof RelationshipType;
+  readonly DocumentType: typeof DocumentType;
+  readonly ReadingOrder: typeof ReadingOrder;
+  readonly PaperSize: typeof PaperSize;
+}
+/**
+ * The exceljs-compatible API as one object: `import ExcelJS from 'exceljs'` and
+ * `const ExcelJS = require('exceljs')` both give it.
+ *
+ * @example
+ * ```ts
+ * import ExcelJS from '@xlvane/compat';
+ *
+ * const workbook = new ExcelJS.Workbook();
+ * const sheet = workbook.addWorksheet('Sheet1');
+ * sheet.addRow(['Hello', 'world']);
+ * const buffer = await workbook.xlsx.writeBuffer();
+ * console.log(buffer.length > 0);
+ * ```
+ */
+declare const ExcelJS: ExcelJSModule;
+type ModelContainerInstance = ModelContainer;
+type XlvTypeOfWorkbookWriter = WorkbookWriter;
+type XlvTypeOfWorkbookReader = WorkbookReader;
+type XlvTypeOfWorksheetWriter = WorksheetWriter;
+type XlvTypeOfWorksheetReader = WorksheetReader;
+type XlvTypeOfWorkbookWriterOptions = WorkbookWriterOptions;
+type XlvTypeOfWorkbookReaderOptions = WorkbookReaderOptions;
+type XlvTypeOfColor = Color;
+type XlvTypeOfFont = Font;
+type XlvTypeOfFillPatterns = FillPatterns;
+type XlvTypeOfFill = Fill;
+type XlvTypeOfBorderStyle = BorderStyle;
+type XlvTypeOfBorder = Border;
+type XlvTypeOfBorders = Borders;
+type XlvTypeOfAlignment = Alignment;
+type XlvTypeOfStyle = Style;
+type XlvTypeOfProtection = Protection;
+type XlvTypeOfCellErrorValue = CellErrorValue;
+type XlvTypeOfCellFormulaValue = CellFormulaValue;
+type XlvTypeOfCellValue = CellValue;
+type XlvTypeOfColumnDefn = ColumnDefn;
+type XlvTypeOfWorksheetView = WorksheetView;
+type XlvTypeOfWorksheetOptions = WorksheetOptions;
+type XlvTypeOfComment = Comment;
+type XlvTypeOfDataValidation = DataValidation;
+type XlvTypeOfConditionalFormattingRule = ConditionalFormattingRule;
+type XlvTypeOfConditionalFormattingOptions = ConditionalFormattingOptions;
+type XlvTypeOfPageSetup = PageSetup;
+type XlvTypeOfHeaderFooter = HeaderFooter;
+type XlvTypeOfRowBreak = RowBreak;
+type XlvTypeOfWorksheetProtection = WorksheetProtection;
+type XlvTypeOfBuffer = Buffer;
+type XlvTypeOfGradientStop = GradientStop;
+type XlvTypeOfFillGradientAngle = FillGradientAngle;
+type XlvTypeOfFillGradientPath = FillGradientPath;
+type XlvTypeOfBorderDiagonal = BorderDiagonal;
+type XlvTypeOfMargins = Margins;
+type XlvTypeOfDataValidationOperator = DataValidationOperator;
+type XlvTypeOfRichText = RichText;
+type XlvTypeOfCellRichTextValue = CellRichTextValue;
+type XlvTypeOfCellHyperlinkValue = CellHyperlinkValue;
+type XlvTypeOfAddress = Address;
+type XlvTypeOfCellModel = CellModel;
+type XlvTypeOfRowModel = RowModel;
+type XlvTypeOfAutoFilter = AutoFilter;
+type XlvTypeOfImage = Image;
+type XlvTypeOfImageRange = ImageRange;
+type XlvTypeOfIAnchorPosition = IAnchorPosition;
+type XlvTypeOfImagePosition = ImagePosition;
+type XlvTypeOfImageHyperlinkValue = ImageHyperlinkValue;
+type XlvTypeOfLocation = Location;
+type XlvTypeOfRange = Range;
+type XlvTypeOfMedia = Media;
+type XlvTypeOfWorksheetState = WorksheetState;
+type XlvTypeOfCellIsOperators = CellIsOperators;
+type XlvTypeOfContainsTextOperators = ContainsTextOperators;
+type XlvTypeOfTimePeriodTypes = TimePeriodTypes;
+type XlvTypeOfIconSetTypes = IconSetTypes;
+type XlvTypeOfCfvoTypes = CfvoTypes;
+type XlvTypeOfCvfo = Cvfo;
+type XlvTypeOfExpressionRuleType = ExpressionRuleType;
+type XlvTypeOfCellIsRuleType = CellIsRuleType;
+type XlvTypeOfAboveAverageRuleType = AboveAverageRuleType;
+type XlvTypeOfColorScaleRuleType = ColorScaleRuleType;
+type XlvTypeOfIconSetRuleType = IconSetRuleType;
+type XlvTypeOfContainsTextRuleType = ContainsTextRuleType;
+type XlvTypeOfTimePeriodRuleType = TimePeriodRuleType;
+type XlvTypeOfDataBarRuleType = DataBarRuleType;
+type XlvTypeOfRowValues = RowValues;
+type XlvTypeOfCalculationProperties = CalculationProperties;
+type XlvTypeOfWorkbookProperties = WorkbookProperties;
+type XlvTypeOfJSZipGeneratorOptions = JSZipGeneratorOptions;
+type XlvTypeOfXlsx = Xlsx;
+type XlvTypeOfCsv = Csv;
+type XlvTypeOfFastCsvParserOptionsArgs = FastCsvParserOptionsArgs;
+type XlvTypeOfFastCsvFormatterOptionsArgs = FastCsvFormatterOptionsArgs;
+type XlvTypeOfWorksheetModel = WorksheetModel;
+type XlvTypeOfWorkbookModel = WorkbookModel;
+type XlvTypeOfWorksheetViewCommon = WorksheetViewCommon;
+type XlvTypeOfWorksheetViewNormal = WorksheetViewNormal;
+type XlvTypeOfWorksheetViewFrozen = WorksheetViewFrozen;
+type XlvTypeOfWorksheetViewSplit = WorksheetViewSplit;
+type XlvTypeOfWorkbookView = WorkbookView;
+type XlvTypeOfFillPattern = FillPattern;
+type XlvTypeOfCellSharedFormulaValue = CellSharedFormulaValue;
+type XlvTypeOfIAnchor = IAnchor;
+type XlvTypeOfConditionalFormattingBaseRule = ConditionalFormattingBaseRule;
+type XlvTypeOfTop10RuleType = Top10RuleType;
+type XlvTypeOfWorksheetProperties = WorksheetProperties;
+type XlvTypeOfAddWorksheetOptions = AddWorksheetOptions;
+type XlvTypeOfDefinedNamesRanges = DefinedNamesRanges;
+type XlvTypeOfDefinedNamesModel = DefinedNamesModel;
+type XlvTypeOfTableStyleProperties = TableStyleProperties;
+type XlvTypeOfPaperSize = PaperSize;
+type XlvTypeOfCell = Cell;
+type XlvTypeOfColumn = Column;
+type XlvTypeOfRow = Row;
+type XlvTypeOfWorksheet = Worksheet;
+type XlvTypeOfValueType = ValueType;
+type XlvTypeOfFormulaType = FormulaType;
+type XlvTypeOfErrorValue = ErrorValue;
+type XlvTypeOfCsvIO = CsvIO;
+type XlvTypeOfCsvReadOptions = CsvReadOptions;
+type XlvTypeOfCsvWriteOptions = CsvWriteOptions;
+type XlvTypeOfCellMatrix = CellMatrix;
+type XlvTypeOfDefinedNames = DefinedNames;
+type XlvTypeOfDecodedLocation = DecodedLocation;
+type XlvTypeOfNameCell = NameCell;
+type XlvTypeOfWorkbook = Workbook;
+type XlvTypeOfXlsxIO = XlsxIO;
+type XlvTypeOfXlsxReadOptions = XlsxReadOptions;
+type XlvTypeOfXlsxWriteOptions = XlsxWriteOptions;
+type XlvTypeOfDataValidations = DataValidations;
+type XlvTypeOfAnchor = Anchor;
+type XlvTypeOfTable = Table;
+type XlvTypeOfTableColumn = TableColumn;
+type XlvTypeOfImageData = ImageData;
+type XlvTypeOfImageRangeInput = ImageRangeInput;
+type XlvTypeOfTableColumnProperties = TableColumnProperties;
+type XlvTypeOfTableProperties = TableProperties;
+type XlvTypeOfRelationshipType = (typeof RelationshipType)[keyof typeof RelationshipType];
+type XlvTypeOfDocumentType = (typeof DocumentType)[keyof typeof DocumentType];
+type XlvTypeOfReadingOrder = (typeof ReadingOrder)[keyof typeof ReadingOrder];
+type XlvTypeOfModelContainer = ModelContainerInstance;
+/**
+ * The types of the exceljs-compatible API under the default export, so that exceljs code such as
+ * `let sheet: ExcelJS.Worksheet` type-checks with `import ExcelJS from 'exceljs'` and with
+ * `import ExcelJS = require('exceljs')` (D-R01).
+ */
+declare namespace ExcelJS {
+  type Color = XlvTypeOfColor;
+  type Font = XlvTypeOfFont;
+  type FillPatterns = XlvTypeOfFillPatterns;
+  type Fill = XlvTypeOfFill;
+  type BorderStyle = XlvTypeOfBorderStyle;
+  type Border = XlvTypeOfBorder;
+  type Borders = XlvTypeOfBorders;
+  type Alignment = XlvTypeOfAlignment;
+  type Style = XlvTypeOfStyle;
+  type Protection = XlvTypeOfProtection;
+  type CellErrorValue = XlvTypeOfCellErrorValue;
+  type CellFormulaValue = XlvTypeOfCellFormulaValue;
+  type CellValue = XlvTypeOfCellValue;
+  type ColumnDefn = XlvTypeOfColumnDefn;
+  type WorksheetView = XlvTypeOfWorksheetView;
+  type WorksheetOptions = XlvTypeOfWorksheetOptions;
+  type Comment = XlvTypeOfComment;
+  type DataValidation = XlvTypeOfDataValidation;
+  type ConditionalFormattingRule = XlvTypeOfConditionalFormattingRule;
+  type ConditionalFormattingOptions = XlvTypeOfConditionalFormattingOptions;
+  type PageSetup = XlvTypeOfPageSetup;
+  type HeaderFooter = XlvTypeOfHeaderFooter;
+  type RowBreak = XlvTypeOfRowBreak;
+  type WorksheetProtection = XlvTypeOfWorksheetProtection;
+  type Buffer = XlvTypeOfBuffer;
+  type GradientStop = XlvTypeOfGradientStop;
+  type FillGradientAngle = XlvTypeOfFillGradientAngle;
+  type FillGradientPath = XlvTypeOfFillGradientPath;
+  type BorderDiagonal = XlvTypeOfBorderDiagonal;
+  type Margins = XlvTypeOfMargins;
+  type DataValidationOperator = XlvTypeOfDataValidationOperator;
+  type RichText = XlvTypeOfRichText;
+  type CellRichTextValue = XlvTypeOfCellRichTextValue;
+  type CellHyperlinkValue = XlvTypeOfCellHyperlinkValue;
+  type Address = XlvTypeOfAddress;
+  type CellModel = XlvTypeOfCellModel;
+  type RowModel = XlvTypeOfRowModel;
+  type AutoFilter = XlvTypeOfAutoFilter;
+  type Image = XlvTypeOfImage;
+  type ImageRange = XlvTypeOfImageRange;
+  type IAnchorPosition = XlvTypeOfIAnchorPosition;
+  type ImagePosition = XlvTypeOfImagePosition;
+  type ImageHyperlinkValue = XlvTypeOfImageHyperlinkValue;
+  type Location = XlvTypeOfLocation;
+  type Range = XlvTypeOfRange;
+  type Media = XlvTypeOfMedia;
+  type WorksheetState = XlvTypeOfWorksheetState;
+  type CellIsOperators = XlvTypeOfCellIsOperators;
+  type ContainsTextOperators = XlvTypeOfContainsTextOperators;
+  type TimePeriodTypes = XlvTypeOfTimePeriodTypes;
+  type IconSetTypes = XlvTypeOfIconSetTypes;
+  type CfvoTypes = XlvTypeOfCfvoTypes;
+  type Cvfo = XlvTypeOfCvfo;
+  type ExpressionRuleType = XlvTypeOfExpressionRuleType;
+  type CellIsRuleType = XlvTypeOfCellIsRuleType;
+  type AboveAverageRuleType = XlvTypeOfAboveAverageRuleType;
+  type ColorScaleRuleType = XlvTypeOfColorScaleRuleType;
+  type IconSetRuleType = XlvTypeOfIconSetRuleType;
+  type ContainsTextRuleType = XlvTypeOfContainsTextRuleType;
+  type TimePeriodRuleType = XlvTypeOfTimePeriodRuleType;
+  type DataBarRuleType = XlvTypeOfDataBarRuleType;
+  type RowValues = XlvTypeOfRowValues;
+  type CalculationProperties = XlvTypeOfCalculationProperties;
+  type WorkbookProperties = XlvTypeOfWorkbookProperties;
+  type JSZipGeneratorOptions = XlvTypeOfJSZipGeneratorOptions;
+  type Xlsx = XlvTypeOfXlsx;
+  type Csv = XlvTypeOfCsv;
+  type FastCsvParserOptionsArgs = XlvTypeOfFastCsvParserOptionsArgs;
+  type FastCsvFormatterOptionsArgs = XlvTypeOfFastCsvFormatterOptionsArgs;
+  type WorksheetModel = XlvTypeOfWorksheetModel;
+  type WorkbookModel = XlvTypeOfWorkbookModel;
+  type WorksheetViewCommon = XlvTypeOfWorksheetViewCommon;
+  type WorksheetViewNormal = XlvTypeOfWorksheetViewNormal;
+  type WorksheetViewFrozen = XlvTypeOfWorksheetViewFrozen;
+  type WorksheetViewSplit = XlvTypeOfWorksheetViewSplit;
+  type WorkbookView = XlvTypeOfWorkbookView;
+  type FillPattern = XlvTypeOfFillPattern;
+  type CellSharedFormulaValue = XlvTypeOfCellSharedFormulaValue;
+  type IAnchor = XlvTypeOfIAnchor;
+  type ConditionalFormattingBaseRule = XlvTypeOfConditionalFormattingBaseRule;
+  type Top10RuleType = XlvTypeOfTop10RuleType;
+  type WorksheetProperties = XlvTypeOfWorksheetProperties;
+  type AddWorksheetOptions = XlvTypeOfAddWorksheetOptions;
+  type DefinedNamesRanges = XlvTypeOfDefinedNamesRanges;
+  type DefinedNamesModel = XlvTypeOfDefinedNamesModel;
+  type TableStyleProperties = XlvTypeOfTableStyleProperties;
+  type PaperSize = XlvTypeOfPaperSize;
+  type Cell = XlvTypeOfCell;
+  type Column = XlvTypeOfColumn;
+  type Row = XlvTypeOfRow;
+  type Worksheet = XlvTypeOfWorksheet;
+  type ValueType = XlvTypeOfValueType;
+  type FormulaType = XlvTypeOfFormulaType;
+  type ErrorValue = XlvTypeOfErrorValue;
+  type WorkbookReader = XlvTypeOfWorkbookReader;
+  type WorkbookWriter = XlvTypeOfWorkbookWriter;
+  type WorksheetReader = XlvTypeOfWorksheetReader;
+  type WorksheetWriter = XlvTypeOfWorksheetWriter;
+  type WorkbookReaderOptions = XlvTypeOfWorkbookReaderOptions;
+  type WorkbookWriterOptions = XlvTypeOfWorkbookWriterOptions;
+  type CsvIO = XlvTypeOfCsvIO;
+  type CsvReadOptions = XlvTypeOfCsvReadOptions;
+  type CsvWriteOptions = XlvTypeOfCsvWriteOptions;
+  type CellMatrix = XlvTypeOfCellMatrix;
+  type DefinedNames = XlvTypeOfDefinedNames;
+  type DecodedLocation = XlvTypeOfDecodedLocation;
+  type NameCell = XlvTypeOfNameCell;
+  type Workbook = XlvTypeOfWorkbook;
+  type XlsxIO = XlvTypeOfXlsxIO;
+  type XlsxReadOptions = XlvTypeOfXlsxReadOptions;
+  type XlsxWriteOptions = XlvTypeOfXlsxWriteOptions;
+  type DataValidations = XlvTypeOfDataValidations;
+  type Anchor = XlvTypeOfAnchor;
+  type Table = XlvTypeOfTable;
+  type TableColumn = XlvTypeOfTableColumn;
+  type ImageData = XlvTypeOfImageData;
+  type ImageRangeInput = XlvTypeOfImageRangeInput;
+  type TableColumnProperties = XlvTypeOfTableColumnProperties;
+  type TableProperties = XlvTypeOfTableProperties;
+  type RelationshipType = XlvTypeOfRelationshipType;
+  type DocumentType = XlvTypeOfDocumentType;
+  type ReadingOrder = XlvTypeOfReadingOrder;
+  type ModelContainer = XlvTypeOfModelContainer;
+  namespace stream {
+    namespace xlsx {
+      type WorkbookWriter = XlvTypeOfWorkbookWriter;
+      type WorkbookReader = XlvTypeOfWorkbookReader;
+      type WorksheetWriter = XlvTypeOfWorksheetWriter;
+      type WorksheetReader = XlvTypeOfWorksheetReader;
+      type WorkbookWriterOptions = XlvTypeOfWorkbookWriterOptions;
+      type WorkbookReaderOptions = XlvTypeOfWorkbookReaderOptions;
+      type WorkbookStreamReaderOptions = XlvTypeOfWorkbookReaderOptions;
+    }
+  }
+}
+export { type AboveAverageRuleType, type AddWorksheetOptions, type Address, type Alignment, type AutoFilter, type Border, type BorderDiagonal, type BorderStyle, type Borders, type Buffer, type CalculationProperties, type CellErrorValue, type CellFormulaValue, type CellHyperlinkValue, type CellIsOperators, type CellIsRuleType, type CellModel, type CellRichTextValue, type CellSharedFormulaValue, type CellValue, type CfvoTypes, type Color, type ColorScaleRuleType, type ColumnDefn, type Comment, type ConditionalFormattingBaseRule, type ConditionalFormattingOptions, type ConditionalFormattingRule, type ContainsTextOperators, type ContainsTextRuleType, type Csv, type CsvReadOptions, type CsvWriteOptions, type Cvfo, type DataBarRuleType, type DataValidation, type DataValidationOperator, type DecodedLocation, type DefinedNamesModel, type DefinedNamesRanges, type ExpressionRuleType, type FastCsvFormatterOptionsArgs, type FastCsvParserOptionsArgs, type Fill, type FillGradientAngle, type FillGradientPath, type FillPattern, type FillPatterns, type Font, type GradientStop, type HeaderFooter, type IAnchor, type IAnchorPosition, type IconSetRuleType, type IconSetTypes, type Image, type ImageData, type ImageHyperlinkValue, type ImagePosition, type ImageRange, type ImageRangeInput, type JSZipGeneratorOptions, type Location, type Margins, type Media, type NameCell, type PageSetup, type Protection, type Range, type RichText, type RowBreak, type RowModel, type RowValues, type Style, type TableColumnProperties, type TableProperties, type TableStyleProperties, type TimePeriodRuleType, type TimePeriodTypes, type Top10RuleType, type WorkbookModel, type WorkbookProperties, type WorkbookReaderOptions, type WorkbookView, type WorkbookWriterOptions, type WorksheetModel, type WorksheetOptions, type WorksheetProperties, type WorksheetProtection, type WorksheetState, type WorksheetView, type WorksheetViewCommon, type WorksheetViewFrozen, type WorksheetViewNormal, type WorksheetViewSplit, type Xlsx, type XlsxReadOptions, type XlsxWriteOptions, type config, ExcelJS as default, ExcelJS as "module.exports" };