@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/types/stream/xlsx/workbook-writer.d.ts

@@ -0,0 +1,139 @@
+import fs from "fs";
+import { Zip } from "../../utils/zip/streaming-zip";
+import { StreamBuf } from "../../utils/stream-buf";
+import { StylesXform } from "../../xlsx/xform/style/styles-xform";
+import { SharedStrings } from "../../utils/shared-strings";
+import { DefinedNames } from "../../doc/defined-names";
+import { WorksheetWriter } from "./worksheet-writer";
+import type Stream from "stream";
+import type { Image, WorkbookView, AddWorksheetOptions } from "../../types";
+/** Internal medium type for storing images in workbook */
+interface Medium extends Image {
+    type: "image";
+    name: string;
+}
+/** Internal comment reference type for tracking comment files */
+interface CommentRef {
+    commentName: string;
+    vmlDrawing: string;
+}
+export interface ZlibOptions {
+    /** @default constants.Z_NO_FLUSH */
+    flush?: number;
+    /** @default constants.Z_FINISH */
+    finishFlush?: number;
+    /** @default 16*1024 */
+    chunkSize?: number;
+    windowBits?: number;
+    /** compression level (0-9) */
+    level?: number;
+    memLevel?: number;
+    strategy?: number;
+    dictionary?: Buffer | NodeJS.TypedArray | DataView | ArrayBuffer;
+}
+export interface ZipOptions {
+    comment?: string;
+    forceLocalTime?: boolean;
+    forceZip64?: boolean;
+    store?: boolean;
+    zlib?: Partial<ZlibOptions>;
+    /** Alternative way to set compression level */
+    compressionOptions?: {
+        level?: number;
+    };
+}
+export interface WorkbookWriterOptions {
+    /** The date the workbook was created */
+    created?: Date;
+    /** The date the workbook was last modified */
+    modified?: Date;
+    /** The author of the workbook */
+    creator?: string;
+    /** Who last modified the workbook */
+    lastModifiedBy?: string;
+    /** The date the workbook was last printed */
+    lastPrinted?: Date;
+    /** Specifies whether to use shared strings in the workbook. Default is false */
+    useSharedStrings?: boolean;
+    /** Specifies whether to add style information to the workbook. Default is false */
+    useStyles?: boolean;
+    /** Zip compression options */
+    zip?: Partial<ZipOptions>;
+    /** Specifies a writable stream to write the XLSX workbook to */
+    stream?: Stream;
+    /** If stream not specified, this field specifies the path to a file to write the XLSX workbook to */
+    filename?: string;
+}
+declare class WorkbookWriter {
+    /** The date the workbook was created */
+    created: Date;
+    /** The date the workbook was last modified */
+    modified: Date;
+    /** The author of the workbook */
+    creator: string;
+    /** Who last modified the workbook */
+    lastModifiedBy: string;
+    /** The date the workbook was last printed */
+    lastPrinted?: Date;
+    /** Whether to use shared strings */
+    useSharedStrings: boolean;
+    /** Shared strings collection - internal use */
+    sharedStrings: SharedStrings;
+    /** Style manager - internal use */
+    styles: StylesXform;
+    /** Defined names - internal use */
+    _definedNames: DefinedNames;
+    /** Worksheets collection */
+    _worksheets: WorksheetWriter[];
+    /** Workbook views controls how many separate windows Excel will open */
+    views: WorkbookView[];
+    /** Zip options - internal use */
+    zipOptions?: Partial<ZipOptions>;
+    /** Compression level (0-9) */
+    compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    /** Media collection (images) - internal use */
+    media: Medium[];
+    /** Comment references - internal use */
+    commentRefs: CommentRef[];
+    /** Zip instance - internal use */
+    zip: Zip;
+    /** Output stream - internal use */
+    stream: Stream | fs.WriteStream | InstanceType<typeof StreamBuf>;
+    /** Internal promise for async operations */
+    promise: Promise<void[]>;
+    constructor(options?: WorkbookWriterOptions);
+    get definedNames(): DefinedNames;
+    _openStream(path: string): InstanceType<typeof StreamBuf>;
+    _addFile(data: string | Uint8Array, name: string, base64?: boolean): void;
+    _commitWorksheets(): Promise<void>;
+    commit(): Promise<void>;
+    get nextId(): number;
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image: Image): number;
+    /**
+     * Get image by id
+     */
+    getImage(id: number): Image | undefined;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name?: string, options?: Partial<AddWorksheetOptions>): WorksheetWriter;
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id?: string | number): WorksheetWriter | undefined;
+    addStyles(): Promise<void>;
+    addThemes(): Promise<void>;
+    addOfficeRels(): Promise<void>;
+    addContentTypes(): Promise<void>;
+    addMedia(): Promise<void[]>;
+    addApp(): Promise<void>;
+    addCore(): Promise<void>;
+    addSharedStrings(): Promise<void>;
+    addWorkbookRels(): Promise<void>;
+    addWorkbook(): Promise<void>;
+    _finalize(): Promise<any>;
+}
+export { WorkbookWriter };

package/dist/types/stream/xlsx/worksheet-reader.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from "events";
+import { Dimensions } from "../../doc/range";
+import { Row } from "../../doc/row";
+import { Column } from "../../doc/column";
+import type { WorkbookReader, InternalWorksheetOptions } from "./workbook-reader";
+import type { WorksheetState } from "../../types";
+/** Hyperlink reference from worksheet XML */
+export interface WorksheetHyperlink {
+    ref: string;
+    rId: string;
+}
+/** Events emitted during worksheet parsing */
+export type WorksheetEventType = RowEvent["eventType"] | HyperlinkEvent["eventType"];
+/** Row event emitted during parsing */
+export interface RowEvent {
+    eventType: "row";
+    value: Row;
+}
+/** Hyperlink event emitted during parsing */
+export interface HyperlinkEvent {
+    eventType: "hyperlink";
+    value: WorksheetHyperlink;
+}
+export type WorksheetEvent = RowEvent | HyperlinkEvent;
+export interface WorksheetReaderOptions {
+    workbook: WorkbookReader;
+    id: number;
+    iterator: AsyncIterable<unknown>;
+    options?: InternalWorksheetOptions;
+}
+declare class WorksheetReader extends EventEmitter {
+    workbook: WorkbookReader;
+    id: number | string;
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
+    name: string;
+    state?: WorksheetState;
+    private _columns;
+    private _keys;
+    private _dimensions;
+    hyperlinks?: Record<string, WorksheetHyperlink>;
+    constructor({ workbook, id, iterator, options }: WorksheetReaderOptions);
+    destroy(): void;
+    get dimensions(): Dimensions;
+    get columns(): Column[] | null;
+    getColumn(c: string | number): Column;
+    getColumnKey(key: string): Column | undefined;
+    setColumnKey(key: string, value: Column): void;
+    deleteColumnKey(key: string): void;
+    eachColumnKey(f: (column: Column, key: string) => void): void;
+    read(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Row>;
+    parse(): AsyncIterableIterator<WorksheetEvent[]>;
+}
+export { WorksheetReader };

package/dist/types/stream/xlsx/worksheet-writer.d.ts

@@ -0,0 +1,139 @@
+import { Dimensions } from "../../doc/range";
+import { StringBuf } from "../../utils/string-buf";
+import { Row } from "../../doc/row";
+import { Column } from "../../doc/column";
+import { SheetRelsWriter } from "./sheet-rels-writer";
+import { SheetCommentsWriter } from "./sheet-comments-writer";
+import { DataValidations } from "../../doc/data-validations";
+import type { StreamBuf } from "../../utils/stream-buf";
+import type { RowBreak, ColBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions } from "../../types";
+interface WorksheetWriterOptions {
+    id: number;
+    name?: string;
+    workbook: any;
+    useSharedStrings?: boolean;
+    properties?: Partial<WorksheetProperties>;
+    state?: WorksheetState;
+    pageSetup?: Partial<PageSetup>;
+    views?: Partial<WorksheetView>[];
+    autoFilter?: AutoFilter;
+    headerFooter?: Partial<HeaderFooter>;
+}
+declare class WorksheetWriter {
+    id: number;
+    name: string;
+    state: WorksheetState;
+    /** Rows stored while being worked on. Set to null after commit. */
+    _rows: Row[] | null;
+    /** Column definitions */
+    _columns: Column[] | null;
+    /** Column keys mapping: key => Column */
+    _keys: {
+        [key: string]: Column;
+    };
+    /** Merged cell ranges */
+    _merges: Dimensions[];
+    _sheetRelsWriter: SheetRelsWriter;
+    _sheetCommentsWriter: SheetCommentsWriter;
+    _dimensions: Dimensions;
+    _rowZero: number;
+    committed: boolean;
+    dataValidations: DataValidations;
+    /** Shared formulae by address */
+    _formulae: {
+        [key: string]: unknown;
+    };
+    _siFormulae: number;
+    conditionalFormatting: ConditionalFormattingOptions[];
+    rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
+    properties: Partial<WorksheetProperties> & {
+        defaultRowHeight: number;
+        dyDescent?: number;
+        outlineLevelCol: number;
+        outlineLevelRow: number;
+    };
+    headerFooter: Partial<HeaderFooter>;
+    pageSetup: Partial<PageSetup> & {
+        margins: PageSetup["margins"];
+    };
+    useSharedStrings: boolean;
+    _workbook: any;
+    hasComments: boolean;
+    _views: Partial<WorksheetView>[];
+    autoFilter: AutoFilter | null;
+    _media: unknown[];
+    sheetProtection: {
+        sheet?: boolean;
+        algorithmName?: string;
+        saltValue?: string;
+        spinCount?: number;
+        hashValue?: string;
+        [key: string]: unknown;
+    } | null;
+    _stream?: InstanceType<typeof StreamBuf>;
+    startedData: boolean;
+    _background?: {
+        imageId?: number;
+        rId?: string;
+    };
+    _headerRowCount?: number;
+    /** Relationship Id - assigned by WorkbookWriter */
+    rId?: string;
+    constructor(options: WorksheetWriterOptions);
+    get workbook(): any;
+    get stream(): any;
+    destroy(): void;
+    commit(): void;
+    get dimensions(): Dimensions;
+    get views(): Partial<WorksheetView>[];
+    get columns(): Column[] | null;
+    set columns(value: Partial<Column>[]);
+    getColumnKey(key: string): Column | undefined;
+    setColumnKey(key: string, value: Column): void;
+    deleteColumnKey(key: string): void;
+    eachColumnKey(f: (column: Column, key: string) => void): void;
+    getColumn(c: string | number): Column;
+    get _nextRow(): number;
+    eachRow(options: {
+        includeEmpty?: boolean;
+    } | ((row: Row, rowNumber: number) => void), iteratee?: (row: Row, rowNumber: number) => void): void;
+    _commitRow(cRow: Row): void;
+    get lastRow(): Row | undefined;
+    findRow(rowNumber: number): Row | undefined;
+    getRow(rowNumber: number): Row;
+    addRow(value: any[] | Record<string, any>): Row;
+    findCell(r: string | number, c?: number): any;
+    getCell(r: string | number, c?: number): any;
+    mergeCells(...cells: (string | number)[]): void;
+    addConditionalFormatting(cf: ConditionalFormattingOptions): void;
+    removeConditionalFormatting(filter?: number | ((cf: ConditionalFormattingOptions) => boolean)): void;
+    addBackgroundImage(imageId: number): void;
+    getBackgroundImageId(): number | undefined;
+    protect(password?: string, options?: Partial<WorksheetProtection>): Promise<void>;
+    unprotect(): void;
+    _write(text: string): void;
+    _writeSheetProperties(xmlBuf: StringBuf, properties: Partial<WorksheetProperties> | undefined, pageSetup: Partial<PageSetup> | undefined): void;
+    _writeSheetFormatProperties(xmlBuf: StringBuf, properties: Partial<WorksheetProperties> | undefined): void;
+    _writeOpenWorksheet(): void;
+    _writeColumns(): void;
+    _writeOpenSheetData(): void;
+    _writeRow(row: any): void;
+    _writeCloseSheetData(): void;
+    _writeMergeCells(): void;
+    _writeHyperlinks(): void;
+    _writeConditionalFormatting(): void;
+    _writeRowBreaks(): void;
+    _writeColBreaks(): void;
+    _writeDataValidations(): void;
+    _writeSheetProtection(): void;
+    _writePageMargins(): void;
+    _writePageSetup(): void;
+    _writeHeaderFooter(): void;
+    _writeAutoFilter(): void;
+    _writeBackground(): void;
+    _writeLegacyData(): void;
+    _writeDimensions(): void;
+    _writeCloseWorksheet(): void;
+}
+export { WorksheetWriter };

package/dist/types/utils/browser-buffer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Browser-compatible Buffer utilities
+ * Provides base64 encoding/decoding and a Buffer-like wrapper for Uint8Array
+ */
+/**
+ * Convert Uint8Array to base64 string
+ */
+export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+/**
+ * Convert base64 string to Uint8Array
+ */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Buffer-like wrapper for Uint8Array with toString("base64") support
+ * This provides Node.js Buffer-like API for browser environments
+ */
+export declare class BrowserBuffer extends Uint8Array {
+    toString(encoding?: string): string;
+    static from(data: Uint8Array): BrowserBuffer;
+}
+/**
+ * Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
+ */
+export declare function stringToUtf16Le(str: string): Uint8Array;
+/**
+ * Concatenate multiple Uint8Arrays into one
+ */
+export declare function concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array;

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

@@ -0,0 +1,36 @@
+import type { Address, Location } from "../types";
+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/utils/encryptor.browser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Browser-compatible Encryptor with pure JS SHA implementations
+ * This provides synchronous hash functions for browser compatibility
+ */
+import { BrowserBuffer } from "./browser-buffer";
+declare const Encryptor: {
+    /**
+     * Calculate a hash of the concatenated buffers with the given algorithm.
+     * @param algorithm - The hash algorithm.
+     * @returns The hash as Uint8Array
+     */
+    hash(algorithm: string, ...buffers: Uint8Array[]): Uint8Array;
+    /**
+     * Convert a password into an encryption key
+     * @param password - The password
+     * @param hashAlgorithm - The hash algorithm
+     * @param saltValue - The salt value (base64 encoded)
+     * @param spinCount - The spin count
+     * @returns The encryption key (base64 encoded)
+     */
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): string;
+    /**
+     * Generates cryptographically strong pseudo-random data.
+     * @param size The size argument is a number indicating the number of bytes to generate.
+     */
+    randomBytes(size: number): BrowserBuffer;
+};
+export { Encryptor };

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

@@ -0,0 +1,23 @@
+declare const Encryptor: {
+    /**
+     * Calculate a hash of the concatenated buffers with the given algorithm.
+     * @param algorithm - The hash algorithm.
+     * @returns The hash
+     */
+    hash(algorithm: string, ...buffers: Buffer[]): Buffer;
+    /**
+     * Convert a password into an encryption key
+     * @param password - The password
+     * @param hashAlgorithm - The hash algoritm
+     * @param saltValue - The salt value
+     * @param spinCount - The spin count
+     * @returns The encryption key
+     */
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): string;
+    /**
+     * Generates cryptographically strong pseudo-random data.
+     * @param size The size argument is a number indicating the number of bytes to generate.
+     */
+    randomBytes(size: number): Buffer;
+};
+export { Encryptor };

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

@@ -0,0 +1,10 @@
+import type { EventEmitter } from "events";
+interface Readable extends EventEmitter {
+    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/utils/sheet-utils.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Utility functions for ExcelTS
+ * Provides convenient helper functions for common spreadsheet operations
+ */
+import { Workbook } from "../doc/workbook";
+import type { Worksheet } from "../doc/worksheet";
+import type { CellValue } from "../types";
+/**
+ * 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[][];
+export declare const utils: {
+    decodeCol: typeof decodeCol;
+    encodeCol: typeof encodeCol;
+    decodeRow: typeof decodeRow;
+    encodeRow: typeof encodeRow;
+    decodeCell: typeof decodeCell;
+    encodeCell: typeof encodeCell;
+    decodeRange: typeof decodeRange;
+    encodeRange: typeof encodeRange;
+    jsonToSheet: typeof jsonToSheet;
+    sheetAddJson: typeof sheetAddJson;
+    sheetToJson: typeof sheetToJson;
+    sheetToCsv: typeof sheetToCsv;
+    aoaToSheet: typeof aoaToSheet;
+    sheetAddAoa: typeof sheetAddAoa;
+    sheetToAoa: typeof sheetToAoa;
+    bookNew: typeof bookNew;
+    bookAppendSheet: typeof bookAppendSheet;
+};