@cj-tech-master/excelts 3.1.0 → 4.0.0

package/dist/types/modules/excel/utils/col-cache.d.ts

@@ -0,0 +1,36 @@
+import type { Address, Location } from "../types.d.ts";
+type CachedAddress = Address & {
+    $col$row: string;
+};
+export type DecodedRange = Location & {
+    tl: string | CachedAddress;
+    br: string | CachedAddress;
+    dimensions: string;
+    sheetName?: string;
+};
+interface ErrorReference {
+    error: string;
+    sheetName?: string;
+}
+type DecodeExResult = CachedAddress | DecodedRange | ErrorReference;
+interface ColCache {
+    _dictionary: string[];
+    _l2nFill: number;
+    _l2n: Record<string, number>;
+    _n2l: string[];
+    _hash: Record<string, CachedAddress>;
+    _level(n: number): number;
+    _fill(level: number): void;
+    l2n(l: string): number;
+    n2l(n: number): string;
+    validateAddress(value: string): boolean;
+    decodeAddress(value: string): CachedAddress;
+    getAddress(r: number | string, c?: number): CachedAddress;
+    decode(value: string): CachedAddress | DecodedRange;
+    decodeEx(value: string): DecodeExResult;
+    encodeAddress(row: number, col: number): string;
+    encode(...args: number[]): string;
+    inRange(range: number[], address: number[]): boolean;
+}
+declare const colCache: ColCache;
+export { colCache };

package/dist/types/modules/excel/utils/encryptor.browser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Browser-only Encryptor
+ * Uses Web Crypto API (hardware accelerated)
+ */
+declare const Encryptor: {
+    /**
+     * Calculate hash using Web Crypto API
+     */
+    hash(algorithm: string, ...buffers: Uint8Array[]): Promise<Uint8Array>;
+    /**
+     * Convert password to hash
+     */
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): Promise<string>;
+    /**
+     * Generate cryptographically strong random bytes
+     */
+    randomBytes(size: number): Uint8Array;
+};
+export { Encryptor };

package/dist/types/modules/excel/utils/encryptor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Node.js Encryptor - uses native crypto module
+ */
+declare const Encryptor: {
+    hash(algorithm: string, ...buffers: Uint8Array[]): Uint8Array;
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): Promise<string>;
+    randomBytes(size: number): Uint8Array;
+};
+export { Encryptor };

package/dist/types/modules/excel/utils/iterate-stream.d.ts

@@ -0,0 +1,14 @@
+type Listener = (...args: any[]) => void;
+interface EventEmitterLike {
+    on(event: string, listener: Listener): this;
+    removeListener(event: string, listener: Listener): this;
+}
+interface Readable extends EventEmitterLike {
+    resume(): void;
+    pause(): void;
+    on(event: "data", listener: (chunk: any) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+}
+declare function iterateStream(stream: Readable): AsyncGenerator<any>;
+export { iterateStream };

package/dist/types/modules/excel/utils/ooxml-paths.d.ts

@@ -0,0 +1,64 @@
+export declare const OOXML_PATHS: {
+    readonly contentTypes: "[Content_Types].xml";
+    readonly rootRels: "_rels/.rels";
+    readonly docPropsApp: "docProps/app.xml";
+    readonly docPropsCore: "docProps/core.xml";
+    readonly xlWorkbook: "xl/workbook.xml";
+    readonly xlWorkbookRels: "xl/_rels/workbook.xml.rels";
+    readonly xlSharedStrings: "xl/sharedStrings.xml";
+    readonly xlStyles: "xl/styles.xml";
+    readonly xlTheme1: "xl/theme/theme1.xml";
+};
+export declare function normalizeZipPath(path: string): string;
+export declare function getWorksheetNoFromWorksheetPath(path: string): number | undefined;
+export declare function getWorksheetNoFromWorksheetRelsPath(path: string): number | undefined;
+export declare function isMediaPath(path: string): boolean;
+export declare function getMediaFilenameFromPath(path: string): string | undefined;
+export declare function isThemePath(path: string): boolean;
+export declare function getThemeNameFromPath(path: string): string | undefined;
+export declare function isBinaryEntryPath(path: string): boolean;
+export declare function getDrawingNameFromPath(path: string): string | undefined;
+export declare function getDrawingNameFromRelsPath(path: string): string | undefined;
+export declare function getVmlDrawingNameFromPath(path: string): string | undefined;
+export declare function getCommentsIndexFromPath(path: string): string | undefined;
+export declare function getTableNameFromPath(path: string): string | undefined;
+export declare function getPivotTableNameFromPath(path: string): string | undefined;
+export declare function getPivotTableNameFromRelsPath(path: string): string | undefined;
+export declare function getPivotCacheDefinitionNameFromPath(path: string): string | undefined;
+export declare function getPivotCacheDefinitionNameFromRelsPath(path: string): string | undefined;
+export declare function getPivotCacheRecordsNameFromPath(path: string): string | undefined;
+export declare function toContentTypesPartName(zipPath: string): string;
+export declare function themePath(themeName: string): string;
+export declare function mediaPath(filename: string): string;
+export declare function worksheetPath(sheetId: number | string): string;
+export declare function worksheetRelsPath(sheetId: number | string): string;
+export declare function worksheetRelTarget(sheetId: number | string): string;
+export declare function commentsPath(sheetId: number | string): string;
+export declare function commentsPathFromName(commentName: string): string;
+export declare function vmlDrawingPath(sheetId: number | string): string;
+export declare function tablePath(target: string): string;
+export declare function drawingPath(drawingName: string): string;
+export declare function drawingRelsPath(drawingName: string): string;
+export declare function pivotCacheDefinitionPath(n: number | string): string;
+export declare function pivotCacheDefinitionRelsPath(n: number | string): string;
+export declare function pivotCacheRecordsPath(n: number | string): string;
+export declare function pivotCacheRecordsRelTarget(n: number | string): string;
+export declare function pivotTablePath(n: number | string): string;
+export declare function pivotTableRelsPath(n: number | string): string;
+export declare function pivotCacheDefinitionRelTargetFromPivotTable(n: number | string): string;
+export declare const OOXML_REL_TARGETS: {
+    readonly workbookStyles: "styles.xml";
+    readonly workbookSharedStrings: "sharedStrings.xml";
+    readonly workbookTheme1: "theme/theme1.xml";
+};
+export declare function pivotCacheDefinitionRelTargetFromWorkbook(n: number | string): string;
+export declare function commentsRelTargetFromWorksheet(sheetId: number | string): string;
+export declare function vmlDrawingRelTargetFromWorksheet(sheetId: number | string): string;
+export declare function drawingRelTargetFromWorksheet(drawingName: string): string;
+export declare function vmlDrawingRelTargetFromWorksheetName(vmlName: string): string;
+export declare function commentsRelTargetFromWorksheetName(commentName: string): string;
+export declare function pivotTableRelTargetFromWorksheet(n: number | string): string;
+export declare function pivotTableRelTargetFromWorksheetName(pivotName: string): string;
+export declare function tableRelTargetFromWorksheet(target: string): string;
+export declare function tableRelTargetFromWorksheetName(name: string): string;
+export declare function mediaRelTargetFromRels(filename: string): string;

package/dist/types/modules/excel/utils/sheet-utils.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Utility functions for ExcelTS
+ * Provides convenient helper functions for common spreadsheet operations
+ */
+import { Workbook } from "../workbook.d.ts";
+import type { Worksheet } from "../worksheet.d.ts";
+import type { CellValue } from "../types.d.ts";
+/**
+ * Cell address object (0-indexed)
+ */
+export interface CellAddress {
+    /** 0-indexed column number */
+    c: number;
+    /** 0-indexed row number */
+    r: number;
+}
+/**
+ * Range object with start and end addresses
+ */
+export interface Range {
+    /** Start cell (top-left) */
+    s: CellAddress;
+    /** End cell (bottom-right) */
+    e: CellAddress;
+}
+/**
+ * Row data for JSON conversion
+ */
+export type JSONRow = Record<string, CellValue>;
+/**
+ * Decode column string to 0-indexed number
+ * @example decodeCol("A") => 0, decodeCol("Z") => 25, decodeCol("AA") => 26
+ */
+export declare function decodeCol(colstr: string): number;
+/**
+ * Encode 0-indexed column number to string
+ * @example encodeCol(0) => "A", encodeCol(25) => "Z", encodeCol(26) => "AA"
+ */
+export declare function encodeCol(col: number): string;
+/**
+ * Decode row string to 0-indexed number
+ * @example decodeRow("1") => 0, decodeRow("10") => 9
+ */
+export declare function decodeRow(rowstr: string): number;
+/**
+ * Encode 0-indexed row number to string
+ * @example encodeRow(0) => "1", encodeRow(9) => "10"
+ */
+export declare function encodeRow(row: number): string;
+/**
+ * Decode cell address string to CellAddress object
+ * @example decodeCell("A1") => {c: 0, r: 0}, decodeCell("B2") => {c: 1, r: 1}
+ */
+export declare function decodeCell(cstr: string): CellAddress;
+/**
+ * Encode CellAddress object to cell address string
+ * @example encodeCell({c: 0, r: 0}) => "A1", encodeCell({c: 1, r: 1}) => "B2"
+ */
+export declare function encodeCell(cell: CellAddress): string;
+/**
+ * Decode range string to Range object
+ * @example decodeRange("A1:B2") => {s: {c: 0, r: 0}, e: {c: 1, r: 1}}
+ */
+export declare function decodeRange(range: string): Range;
+/**
+ * Encode Range object to range string
+ */
+export declare function encodeRange(range: Range): string;
+export declare function encodeRange(start: CellAddress, end: CellAddress): string;
+/** Origin can be cell address string, cell object, row number, or -1 to append */
+export type Origin = string | CellAddress | number;
+export interface JSON2SheetOpts {
+    /** Use specified field order (default Object.keys) */
+    header?: string[];
+    /** Use specified date format in string output */
+    dateFormat?: string;
+    /** Store dates as type d (default is n) */
+    cellDates?: boolean;
+    /** If true, do not include header row in output */
+    skipHeader?: boolean;
+    /** If true, emit #NULL! error cells for null values */
+    nullError?: boolean;
+}
+export interface SheetAddJSONOpts extends JSON2SheetOpts {
+    /** Use specified cell as starting point */
+    origin?: Origin;
+}
+/**
+ * Create a worksheet from an array of objects (xlsx compatible)
+ * @example
+ * const ws = jsonToSheet([{name: "Alice", age: 30}, {name: "Bob", age: 25}])
+ */
+export declare function jsonToSheet(data: JSONRow[], opts?: JSON2SheetOpts): Worksheet;
+/**
+ * Add data from an array of objects to an existing worksheet (xlsx compatible)
+ */
+export declare function sheetAddJson(worksheet: Worksheet, data: JSONRow[], opts?: SheetAddJSONOpts): Worksheet;
+export interface Sheet2JSONOpts {
+    /**
+     * Control output format:
+     * - 1: Generate an array of arrays
+     * - "A": Row object keys are literal column labels (A, B, C, ...)
+     * - string[]: Use specified strings as keys in row objects
+     * - undefined: Read and disambiguate first row as keys
+     */
+    header?: 1 | "A" | string[];
+    /**
+     * Override Range:
+     * - number: Use worksheet range but set starting row to the value
+     * - string: Use specified range (A1-Style bounded range string)
+     * - undefined: Use worksheet range
+     */
+    range?: number | string;
+    /** Use raw values (true, default) or formatted text strings with trim (false) */
+    raw?: boolean;
+    /** Default value for empty cells */
+    defval?: CellValue;
+    /** Include blank lines in the output */
+    blankrows?: boolean;
+    /**
+     * Override format for date values (not applied to time-only formats).
+     * When provided, Date values will be formatted using this format string.
+     * @example "dd/mm/yyyy" or "yyyy-mm-dd"
+     */
+    dateFormat?: string;
+}
+/**
+ * Convert worksheet to JSON array (xlsx compatible)
+ * @example
+ * // Default: array of objects with first row as headers
+ * const data = sheetToJson(worksheet)
+ * // => [{name: "Alice", age: 30}, {name: "Bob", age: 25}]
+ *
+ * // Array of arrays
+ * const aoa = sheetToJson(worksheet, { header: 1 })
+ * // => [["name", "age"], ["Alice", 30], ["Bob", 25]]
+ *
+ * // Column letters as keys
+ * const cols = sheetToJson(worksheet, { header: "A" })
+ * // => [{A: "name", B: "age"}, {A: "Alice", B: 30}]
+ */
+export declare function sheetToJson<T = JSONRow>(worksheet: Worksheet, opts?: Sheet2JSONOpts): T[];
+export interface Sheet2CSVOpts {
+    /** Field separator (default: ",") */
+    FS?: string;
+    /** Record separator (default: "\n") */
+    RS?: string;
+    /** Skip blank rows */
+    blankrows?: boolean;
+    /** Force quote all fields */
+    forceQuotes?: boolean;
+}
+/**
+ * Convert worksheet to CSV string
+ */
+export declare function sheetToCsv(worksheet: Worksheet, opts?: Sheet2CSVOpts): string;
+/**
+ * Create a new workbook
+ */
+export declare function bookNew(): Workbook;
+/**
+ * Append worksheet to workbook (xlsx compatible)
+ * @example
+ * const wb = bookNew();
+ * const ws = jsonToSheet([{a: 1, b: 2}]);
+ * bookAppendSheet(wb, ws, "Sheet1");
+ */
+export declare function bookAppendSheet(workbook: Workbook, worksheet: Worksheet, name?: string): void;
+export interface AOA2SheetOpts {
+    /** Use specified cell as starting point */
+    origin?: Origin;
+    /** Use specified date format in string output */
+    dateFormat?: string;
+    /** Store dates as type d (default is n) */
+    cellDates?: boolean;
+}
+/**
+ * Create a worksheet from an array of arrays (xlsx compatible)
+ * @example
+ * const ws = aoaToSheet([["Name", "Age"], ["Alice", 30], ["Bob", 25]])
+ */
+export declare function aoaToSheet(data: CellValue[][], opts?: AOA2SheetOpts): Worksheet;
+/**
+ * Add data from an array of arrays to an existing worksheet (xlsx compatible)
+ */
+export declare function sheetAddAoa(worksheet: Worksheet, data: CellValue[][], opts?: AOA2SheetOpts): Worksheet;
+/**
+ * Convert worksheet to array of arrays
+ */
+export declare function sheetToAoa(worksheet: Worksheet): CellValue[][];

package/dist/types/modules/excel/utils/stream-buf.d.ts

@@ -0,0 +1,126 @@
+/**
+ * StreamBuf - Cross-Platform Multi-purpose Read-Write Stream
+ *
+ * A unified implementation that works in both Node.js and Browser environments
+ * using the cross-platform EventEmitter from modules/stream.
+ *
+ * Features:
+ * - As MemBuf: write data, then call toBuffer() to consolidate
+ * - As StreamHub: pipe to multiple writable streams
+ * - As readable stream: feed data into writable part and read from it
+ */
+import { EventEmitter } from "../../stream/index.d.ts";
+import { StringBuf } from "./string-buf.d.ts";
+type TextEncoding = "utf-8" | "utf8" | BufferEncoding;
+interface StreamBufOptions {
+    bufSize?: number;
+    batch?: boolean;
+}
+/**
+ * StreamBuf is a multi-purpose read-write stream that works in both
+ * Node.js and Browser environments.
+ *
+ * It extends EventEmitter to provide stream-like events:
+ * - 'data': emitted when data is written (flowing mode)
+ * - 'readable': emitted when data is available to read
+ * - 'finish': emitted when end() is called
+ * - 'error': emitted on errors
+ * - 'drain': emitted when buffer drains (after pipe)
+ */
+declare class StreamBuf extends EventEmitter {
+    private bufSize;
+    private buffers;
+    private batch;
+    private corked;
+    private paused;
+    private encoding;
+    private pipes;
+    private _ended;
+    private _writableStream;
+    private _writableStreamWriter;
+    private _asyncWriteQueue;
+    constructor(options?: StreamBufOptions);
+    /**
+     * Returns true if the stream is writable (not ended)
+     * Required for compatibility with Node.js pipe()
+     */
+    get writable(): boolean;
+    /**
+     * Consolidate all buffers into a single Uint8Array
+     */
+    toBuffer(): Uint8Array | null;
+    private _getWritableBuffer;
+    private _pipeChunk;
+    private _writeToBuffers;
+    /**
+     * Write data to the stream
+     */
+    write(data: Uint8Array | string | StringBuf | ArrayBuffer | ArrayBufferView, encoding?: TextEncoding | Function, callback?: Function): Promise<boolean>;
+    /**
+     * Cork the stream - buffer writes until uncork
+     */
+    cork(): void;
+    private _flush;
+    /**
+     * Uncork the stream - flush buffered writes
+     */
+    uncork(): void;
+    /**
+     * End the stream
+     */
+    end(chunk?: any, encoding?: TextEncoding, callback?: Function): void;
+    /**
+     * Read from the stream
+     */
+    read(size?: number): Uint8Array;
+    /**
+     * Read from the stream and return as string.
+     * Cross-platform compatible - works identically in Node.js and Browser.
+     */
+    readString(encoding?: TextEncoding): string;
+    /**
+     * Set encoding for string reads
+     */
+    setEncoding(encoding: string): void;
+    /**
+     * Pause the stream
+     */
+    pause(): void;
+    /**
+     * Resume the stream
+     */
+    resume(): void;
+    /**
+     * Check if stream is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Pipe to a writable stream
+     */
+    pipe<T extends {
+        write: Function;
+        end?: Function;
+    }>(destination: T): T;
+    /**
+     * Pipe to a native WritableStream (browser Streams API).
+     * This properly handles async writes and waits for completion before finish.
+     */
+    pipeTo(writableStream: WritableStream<Uint8Array>): void;
+    /**
+     * Remove a piped destination
+     */
+    unpipe(destination: any): void;
+    /**
+     * Put data back at the front (not implemented)
+     */
+    unshift(): void;
+    /**
+     * Wrap a stream (not implemented)
+     */
+    wrap(): void;
+    /**
+     * Push data to the stream (alias for write)
+     */
+    push(chunk: any): boolean;
+}
+export { StreamBuf };

package/dist/types/modules/excel/utils/string-buf.d.ts

@@ -0,0 +1,29 @@
+/**
+ * StringBuf - Cross-Platform String Buffer
+ *
+ * A way to keep string memory operations to a minimum while building XML strings.
+ * Uses TextEncoder and Uint8Array for cross-platform compatibility (Node.js + Browser).
+ */
+interface StringBufOptions {
+    size?: number;
+    encoding?: string;
+}
+/**
+ * StringBuf - efficient string builder using Uint8Array
+ * Works identically in Node.js and Browser environments.
+ */
+declare class StringBuf {
+    private _buf;
+    private _inPos;
+    private _buffer;
+    constructor(options?: StringBufOptions);
+    get length(): number;
+    get capacity(): number;
+    get buffer(): Uint8Array;
+    toBuffer(): Uint8Array;
+    reset(position?: number): void;
+    private _grow;
+    addText(text: string): void;
+    addStringBuf(inBuf: StringBuf): void;
+}
+export { StringBuf };

package/dist/types/modules/excel/workbook.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Workbook - Cross-platform Excel Workbook
+ *
+ * Full functionality:
+ * - xlsx: File/stream/buffer support (file operations Node.js only)
+ * - csv: CSV read/write support (file operations Node.js only)
+ * - streaming: createStreamWriter/createStreamReader for large files
+ *
+ * Note: Browser build uses rolldown aliases to swap in browser-specific
+ * implementations for xlsx, csv, and stream modules.
+ */
+import { Worksheet, type WorksheetModel } from "./worksheet.d.ts";
+import { DefinedNames, type DefinedNameModel } from "./defined-names.d.ts";
+import { XLSX } from "./xlsx/xlsx.d.ts";
+import { CSV } from "../csv/csv.d.ts";
+import { WorkbookWriter, type WorkbookWriterOptions } from "./stream/workbook-writer.d.ts";
+import { WorkbookReader, type WorkbookReaderOptions } from "./stream/workbook-reader.d.ts";
+import type { Readable } from "../stream/index.d.ts";
+import type { PivotTable } from "./pivot-table.d.ts";
+import type { AddWorksheetOptions, CalculationProperties, Image, WorkbookProperties, WorkbookView, Buffer as ExcelBuffer } from "./types.d.ts";
+/** Internal media type - more flexible than public Media type */
+export interface WorkbookMedia {
+    type: string;
+    extension: string;
+    filename?: string;
+    buffer?: ExcelBuffer | Uint8Array;
+    base64?: string;
+    name?: string;
+}
+/** Internal model type for serialization */
+export interface WorkbookModel {
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    created: Date;
+    modified: Date;
+    properties: Partial<WorkbookProperties>;
+    worksheets: WorksheetModel[];
+    sheets?: WorksheetModel[];
+    definedNames: DefinedNameModel[];
+    views: WorkbookView[];
+    company: string;
+    manager: string;
+    title: string;
+    subject: string;
+    keywords: string;
+    category: string;
+    description: string;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    themes?: unknown;
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    /** Loaded pivot tables from file - used during reconciliation */
+    loadedPivotTables?: any[];
+    calcProperties: Partial<CalculationProperties>;
+}
+declare class Workbook {
+    /**
+     * Streaming workbook writer class for large files.
+     * @example
+     * // Node.js: new Workbook.Writer({ filename: "large.xlsx" })
+     * // Browser: new Workbook.Writer({ stream: writableStream })
+     */
+    static Writer: typeof WorkbookWriter;
+    /**
+     * Streaming workbook reader class for large files.
+     * @example
+     * // Node.js: new Workbook.Reader("large.xlsx")
+     * // Browser: new Workbook.Reader(readableStream)
+     */
+    static Reader: typeof WorkbookReader;
+    category: string;
+    company: string;
+    created: Date;
+    description: string;
+    keywords: string;
+    manager: string;
+    modified: Date;
+    subject: string;
+    title: string;
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    properties: Partial<WorkbookProperties>;
+    calcProperties: Partial<CalculationProperties>;
+    views: WorkbookView[];
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    private _worksheets;
+    private _definedNames;
+    private _themes?;
+    private _xlsx?;
+    private _csv?;
+    constructor();
+    /**
+     * xlsx file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream), load (buffer), writeBuffer
+     * Browser: load (buffer), writeBuffer
+     */
+    get xlsx(): XLSX;
+    /**
+     * csv file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream)
+     * Browser: load (string/buffer), writeString, writeBuffer
+     */
+    get csv(): CSV;
+    /**
+     * Create a streaming workbook writer for large files.
+     * This is more memory-efficient than using Workbook for large datasets.
+     *
+     * @param options - Options for the workbook writer
+     *   - Node.js: can use { filename } or { stream }
+     *   - Browser: must use { stream }
+     * @returns A new WorkbookWriter instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with filename
+     * const writer = Workbook.createStreamWriter({ filename: "large-file.xlsx" });
+     *
+     * // Browser or Node.js with stream
+     * const writer = Workbook.createStreamWriter({ stream: writableStream });
+     *
+     * const sheet = writer.addWorksheet("Sheet1");
+     * for (let i = 0; i < 1000000; i++) {
+     *   sheet.addRow([i, `Row ${i}`]).commit();
+     * }
+     * await writer.commit();
+     * ```
+     */
+    static createStreamWriter(options?: WorkbookWriterOptions): WorkbookWriter;
+    /**
+     * Create a streaming workbook reader for large files.
+     * This is more memory-efficient than using Workbook.xlsx.readFile for large datasets.
+     *
+     * @param input - File path (Node.js only) or readable stream
+     * @param options - Options for the workbook reader
+     * @returns A new WorkbookReader instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with file path
+     * const reader = Workbook.createStreamReader("large-file.xlsx");
+     *
+     * // Browser or Node.js with stream
+     * const reader = Workbook.createStreamReader(readableStream);
+     *
+     * for await (const event of reader) {
+     *   if (event.eventType === "worksheet") {
+     *     const worksheet = event.value;
+     *     for await (const row of worksheet) {
+     *       console.log(row.values);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    static createStreamReader(input: string | Readable, options?: WorkbookReaderOptions): WorkbookReader;
+    get nextId(): number;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name?: string, options?: AddWorksheetOptions): Worksheet;
+    removeWorksheetEx(worksheet: Worksheet): void;
+    removeWorksheet(id: number | string): void;
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id?: number | string): Worksheet | undefined;
+    /**
+     * Return a clone of worksheets in order
+     */
+    get worksheets(): Worksheet[];
+    /**
+     * Iterate over all sheets.
+     *
+     * Note: `workbook.worksheets.forEach` will still work but this is better.
+     */
+    eachSheet(callback: (sheet: Worksheet, id: number) => void): void;
+    get definedNames(): DefinedNames;
+    clearThemes(): void;
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image: Image): number;
+    getImage(id: number | string): WorkbookMedia | undefined;
+    get model(): WorkbookModel;
+    set model(value: WorkbookModel);
+}
+export { Workbook };