@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

package/dist/types/modules/excel/stream/hyperlink-reader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HyperlinkReader - Streaming Hyperlink Reader
+ *
+ * Cross-platform implementation.
+ */
+import { EventEmitter } from "../../stream/index";
+import type { InternalWorksheetOptions } from "./workbook-reader.browser";
+export interface HyperlinkReaderOptions<TWorkbook = unknown> {
+    workbook: TWorkbook;
+    id: number;
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
+}
+/** Hyperlink relationship parsed from worksheet rels */
+export interface Hyperlink {
+    type: number;
+    rId: string;
+    target: string;
+    targetMode: string;
+}
+declare class HyperlinkReader extends EventEmitter {
+    workbook: unknown;
+    id: number;
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
+    hyperlinks?: Record<string, Hyperlink>;
+    private _hyperlinkCount;
+    constructor({ workbook, id, iterator, options }: HyperlinkReaderOptions);
+    get count(): number;
+    each(fn: (hyperlink: Hyperlink, rId: string) => void): void;
+    read(): Promise<void>;
+}
+export { HyperlinkReader };

package/dist/types/modules/excel/stream/sheet-comments-writer.d.ts

@@ -0,0 +1,26 @@
+interface SheetCommentsWriterOptions {
+    id: number;
+    workbook: any;
+}
+declare class SheetCommentsWriter {
+    id: number;
+    count: number;
+    _worksheet: any;
+    _workbook: any;
+    _sheetRelsWriter: any;
+    _commentsStream?: any;
+    _vmlStream?: any;
+    vmlRelId?: string;
+    startedData?: boolean;
+    constructor(worksheet: any, sheetRelsWriter: any, options: SheetCommentsWriterOptions);
+    get commentsStream(): any;
+    get vmlStream(): any;
+    _addRelationships(): void;
+    _addCommentRefs(): void;
+    _writeOpen(): void;
+    _writeComment(comment: any, index: number): void;
+    _writeClose(): void;
+    addComments(comments: any[]): void;
+    commit(): void;
+}
+export { SheetCommentsWriter };

package/dist/types/modules/excel/stream/sheet-rels-writer.d.ts

@@ -0,0 +1,45 @@
+interface Hyperlink {
+    address: string;
+    target: string;
+}
+interface Relationship {
+    Type: string;
+    Target: string;
+    TargetMode?: string;
+}
+declare class HyperlinksProxy {
+    writer: SheetRelsWriter;
+    constructor(sheetRelsWriter: SheetRelsWriter);
+    push(hyperlink: Hyperlink): void;
+}
+interface SheetRelsWriterOptions {
+    id: number;
+    workbook: any;
+}
+declare class SheetRelsWriter {
+    id: number;
+    count: number;
+    _hyperlinks: Array<{
+        rId: string;
+        address: string;
+    }>;
+    _workbook: any;
+    _stream?: any;
+    _hyperlinksProxy?: HyperlinksProxy;
+    constructor(options: SheetRelsWriterOptions);
+    get stream(): any;
+    get length(): number;
+    each(fn: (hyperlink: {
+        rId: string;
+        address: string;
+    }) => void): void;
+    get hyperlinksProxy(): HyperlinksProxy;
+    addHyperlink(hyperlink: Hyperlink): void;
+    addMedia(media: Relationship): string;
+    addRelationship(rel: Relationship): string;
+    commit(): void;
+    _writeOpen(): void;
+    _writeRelationship(relationship: Relationship): string;
+    _writeClose(): void;
+}
+export { SheetRelsWriter };

package/dist/types/modules/excel/stream/workbook-reader.browser.d.ts

@@ -0,0 +1,169 @@
+/**
+ * WorkbookReader - Browser Streaming Workbook Reader
+ *
+ * This module contains the full shared implementation for the streaming
+ * workbook reader and a browser-compatible `WorkbookReader` that buffers
+ * waiting worksheets in memory.
+ *
+ * Node.js uses `workbook-reader.ts`, which extends the same base implementation
+ * with filesystem-specific features (filename input + temp-file buffering).
+ */
+import { EventEmitter, Readable } from "../../stream/index";
+import { iterateStream } from "../utils/iterate-stream";
+import { StylesXform } from "../xlsx/xform/style/styles-xform";
+import type { WorksheetState, Font, WorkbookProperties } from "../types";
+import { WorksheetReader } from "./worksheet-reader";
+import { HyperlinkReader, type Hyperlink } from "./hyperlink-reader";
+export interface InternalWorksheetOptions {
+    worksheets?: "emit" | "ignore" | "prep";
+    sharedStrings?: "cache" | "emit" | "ignore";
+    hyperlinks?: "cache" | "emit" | "ignore";
+    styles?: "cache" | "ignore";
+    entries?: "emit" | "ignore";
+}
+export interface SharedStringRichText {
+    richText: Array<{
+        font: Partial<Font> | null;
+        text: string | null;
+    }>;
+}
+export type SharedStringValue = string | SharedStringRichText;
+export interface WorkbookRelationship {
+    Id: string;
+    Target: string;
+    Type?: string;
+}
+export interface SheetMetadata {
+    id: number;
+    name: string;
+    state?: WorksheetState;
+    rId: string;
+}
+export interface WorkbookModel {
+    sheets?: SheetMetadata[];
+    properties?: Partial<WorkbookProperties>;
+    views?: unknown[];
+    definedNames?: unknown[];
+}
+export interface WorkbookPropertiesXform {
+    model?: Partial<WorkbookProperties>;
+}
+export interface EntryPayload {
+    type: "shared-strings" | "styles" | "workbook" | "worksheet" | "hyperlinks";
+    id?: string;
+}
+export type ParseEventType = "shared-strings" | "worksheet" | "hyperlinks";
+export interface SharedStringEvent {
+    eventType: "shared-strings";
+    value: {
+        index: number;
+        text: SharedStringValue;
+    };
+}
+export interface WorksheetReadyEvent<TWorksheetReader> {
+    eventType: "worksheet";
+    value: TWorksheetReader;
+}
+export interface HyperlinksEvent<THyperlinkReader> {
+    eventType: "hyperlinks";
+    value: THyperlinkReader;
+}
+export type ParseEvent<TWorksheetReader, THyperlinkReader> = SharedStringEvent | WorksheetReadyEvent<TWorksheetReader> | HyperlinksEvent<THyperlinkReader>;
+export interface WaitingWorksheetEntry {
+    eventType: "waiting-worksheet";
+    sheetNo: string;
+    entry: any;
+}
+export type CommonInput = Uint8Array | ArrayBuffer | Readable | ReadableStream<Uint8Array>;
+export interface WorkbookReaderOptions {
+    worksheets?: "emit" | "ignore";
+    sharedStrings?: "cache" | "emit" | "ignore";
+    hyperlinks?: "cache" | "emit" | "ignore";
+    styles?: "cache" | "ignore";
+    entries?: "emit" | "ignore";
+}
+/** Constructor type for WorksheetReader/HyperlinkReader */
+export interface ReaderConstructor<TReader, TWorkbook> {
+    new (params: {
+        workbook: TWorkbook;
+        id: number;
+        iterator: AsyncIterable<never>;
+        options: InternalWorksheetOptions;
+    }): TReader;
+}
+export declare abstract class WorkbookReaderBase<TInput, TWorksheetReader extends EventEmitter & {
+    id?: number | string;
+    name?: string;
+    state?: WorksheetState;
+}, THyperlinkReader extends EventEmitter & {
+    hyperlinks?: Record<string, Hyperlink>;
+}, TWaitingWorksheet = unknown> extends EventEmitter {
+    input: TInput;
+    options: {
+        worksheets: "emit" | "ignore";
+        sharedStrings: "cache" | "emit" | "ignore";
+        hyperlinks: "cache" | "emit" | "ignore";
+        styles: "cache" | "ignore";
+        entries: "emit" | "ignore";
+    };
+    styles: StylesXform;
+    stream?: Readable;
+    sharedStrings?: SharedStringValue[];
+    workbookRels?: WorkbookRelationship[];
+    properties?: WorkbookPropertiesXform;
+    model?: WorkbookModel;
+    protected _hyperlinkReadersBySheetNo?: Record<string, THyperlinkReader>;
+    protected _workbookRelIdByTarget?: Record<string, string>;
+    protected _sheetByRelId?: Record<string, SheetMetadata>;
+    getHyperlinkReader(sheetNo: number | string): THyperlinkReader | undefined;
+    getHyperlink(sheetNo: number | string, rId: string): Hyperlink | undefined;
+    getHyperlinkTarget(sheetNo: number | string, rId: string): string | undefined;
+    protected WorksheetReaderClass: ReaderConstructor<TWorksheetReader, this>;
+    protected HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, this>;
+    constructor(input: TInput, options: WorkbookReaderOptions, WorksheetReaderClass: ReaderConstructor<TWorksheetReader, any>, HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, any>);
+    _getStream(input: TInput): Readable;
+    abstract _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<TWaitingWorksheet>;
+    abstract _processWaitingWorksheets(waitingWorksheets: TWaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<TWorksheetReader>>;
+    _cleanupWaitingWorksheets(_waitingWorksheets: TWaitingWorksheet[]): void;
+    _createWorksheetReader(params: {
+        id: number;
+        iterator: AsyncIterable<unknown>;
+        options: InternalWorksheetOptions;
+    }): TWorksheetReader;
+    _createHyperlinkReader(params: {
+        id: number;
+        iterator: AsyncIterable<unknown>;
+        options: InternalWorksheetOptions;
+    }): THyperlinkReader;
+    read(input?: TInput, options?: WorkbookReaderOptions): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<TWorksheetReader>;
+    parse(input?: TInput, options?: WorkbookReaderOptions): AsyncIterableIterator<ParseEvent<TWorksheetReader, THyperlinkReader>>;
+    _emitEntry(payload: EntryPayload): void;
+    _parseRels(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseWorkbook(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseSharedStrings(entry: Parameters<typeof iterateStream>[0]): AsyncIterableIterator<{
+        index: number;
+        text: SharedStringValue;
+    }>;
+    _parseStyles(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseWorksheet(iterator: AsyncIterable<unknown>, sheetNo: string): IterableIterator<WorksheetReadyEvent<TWorksheetReader>>;
+    protected _parseHyperlinks(iterator: AsyncIterable<unknown>, sheetNo: string): AsyncIterableIterator<HyperlinksEvent<THyperlinkReader>>;
+    protected _parseEntries(stream: Readable): AsyncIterableIterator<ParseEvent<TWorksheetReader, THyperlinkReader> | WaitingWorksheetEntry>;
+}
+export declare const WorkbookReaderOptionsSchema: {
+    readonly worksheets: readonly ["emit", "ignore"];
+    readonly sharedStrings: readonly ["cache", "emit", "ignore"];
+    readonly hyperlinks: readonly ["cache", "emit", "ignore"];
+    readonly styles: readonly ["cache", "ignore"];
+    readonly entries: readonly ["emit", "ignore"];
+};
+interface WaitingWorksheet {
+    sheetNo: string;
+    data: Uint8Array[];
+}
+declare class WorkbookReader extends WorkbookReaderBase<CommonInput, WorksheetReader, HyperlinkReader, WaitingWorksheet> {
+    constructor(input: CommonInput, options?: WorkbookReaderOptions);
+    _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<WaitingWorksheet>;
+    _processWaitingWorksheets(waitingWorksheets: WaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<WorksheetReader>>;
+}
+export { WorkbookReader };

package/dist/types/modules/excel/stream/workbook-reader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * WorkbookReader - Node.js Streaming Workbook Reader
+ *
+ * Extends base with file path support and temp file storage for large files.
+ */
+import type { Readable } from "../../stream/index";
+import { WorksheetReader } from "./worksheet-reader";
+import { HyperlinkReader } from "./hyperlink-reader";
+import { WorkbookReaderBase, type CommonInput, type WorkbookReaderOptions, type WorksheetReadyEvent, WorkbookReaderOptionsSchema } from "./workbook-reader.browser";
+export type { WorkbookReaderOptions, InternalWorksheetOptions, SharedStringRichText, SharedStringValue, WorkbookRelationship, SheetMetadata, WorkbookModel, WorkbookPropertiesXform, ParseEventType, SharedStringEvent, WorksheetReadyEvent, HyperlinksEvent, ParseEvent } from "./workbook-reader.browser";
+export type NodeInput = string | CommonInput;
+interface WaitingWorksheet {
+    sheetNo: string;
+    path: string;
+    cleanup: () => void;
+    writePromise: Promise<void>;
+}
+declare class WorkbookReader extends WorkbookReaderBase<NodeInput, WorksheetReader, HyperlinkReader, WaitingWorksheet> {
+    constructor(input: NodeInput, options?: WorkbookReaderOptions);
+    _getStream(input: NodeInput): Readable;
+    _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<WaitingWorksheet>;
+    _processWaitingWorksheets(waitingWorksheets: WaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<WorksheetReader>>;
+}
+export { WorkbookReader, WorkbookReaderOptionsSchema };

package/dist/types/modules/excel/stream/workbook-writer.browser.d.ts

@@ -0,0 +1,147 @@
+/**
+ * WorkbookWriter - Browser Streaming Excel Writer
+ *
+ * This module contains the full cross-platform implementation for the streaming
+ * workbook writer and a browser-compatible `WorkbookWriter` class.
+ *
+ * Node.js uses `workbook-writer.ts`, which extends the same base implementation
+ * with filesystem-specific features (filename output + image loading).
+ */
+import { Zip } from "../../archive/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 "../defined-names";
+import type { Writable } from "../../stream/index";
+import type { Image, WorkbookView, AddWorksheetOptions } from "../types";
+import { WorksheetWriter } from "./worksheet-writer";
+interface Medium extends Image {
+    type: "image";
+    name: string;
+}
+interface CommentRef {
+    commentName: string;
+    vmlDrawing: string;
+}
+export interface ZlibOptions {
+    flush?: number;
+    finishFlush?: number;
+    chunkSize?: number;
+    windowBits?: number;
+    level?: number;
+    memLevel?: number;
+    strategy?: number;
+    dictionary?: Uint8Array | ArrayBuffer;
+}
+export interface ZipOptions {
+    comment?: string;
+    forceLocalTime?: boolean;
+    forceZip64?: boolean;
+    store?: boolean;
+    zlib?: Partial<ZlibOptions>;
+    compressionOptions?: {
+        level?: number;
+    };
+}
+export interface WorkbookWriterOptions {
+    created?: Date;
+    modified?: Date;
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    useSharedStrings?: boolean;
+    useStyles?: boolean;
+    zip?: Partial<ZipOptions>;
+    stream?: Writable | WritableStream<Uint8Array>;
+    filename?: string;
+    trueStreaming?: boolean;
+}
+interface OutputStreamLike {
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    write(chunk: any): boolean | Promise<boolean>;
+    end(): void;
+    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+}
+export interface WorksheetWriterLike {
+    id: number;
+    name: string;
+    rId?: string;
+    committed?: boolean;
+    stream: any;
+    commit(): void;
+}
+export interface WorksheetWriterConstructor<T extends WorksheetWriterLike> {
+    new (options: {
+        id: number;
+        name: string;
+        workbook: any;
+        useSharedStrings: boolean;
+        properties?: any;
+        state?: any;
+        pageSetup?: any;
+        views?: any;
+        autoFilter?: any;
+        headerFooter?: any;
+    }): T;
+}
+export declare abstract class WorkbookWriterBase<TWorksheetWriter extends WorksheetWriterLike> {
+    created: Date;
+    modified: Date;
+    creator: string;
+    lastModifiedBy: string;
+    lastPrinted?: Date;
+    useSharedStrings: boolean;
+    sharedStrings: SharedStrings;
+    styles: StylesXform;
+    _definedNames: DefinedNames;
+    _worksheets: TWorksheetWriter[];
+    views: WorkbookView[];
+    zipOptions?: Partial<ZipOptions>;
+    compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    media: Medium[];
+    commentRefs: CommentRef[];
+    zip: Zip;
+    stream: OutputStreamLike;
+    promise: Promise<void[]>;
+    protected _trueStreaming: boolean;
+    protected WorksheetWriterClass: WorksheetWriterConstructor<TWorksheetWriter>;
+    constructor(options: WorkbookWriterOptions, WorksheetWriterClass: WorksheetWriterConstructor<TWorksheetWriter>);
+    /**
+     * Create output stream - can be overridden by Node.js to support filename
+     */
+    protected _createOutputStream(options: WorkbookWriterOptions): OutputStreamLike;
+    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;
+    addImage(image: Image): number;
+    getImage(id: number): Image | undefined;
+    addWorksheet(name?: string, options?: Partial<AddWorksheetOptions>): TWorksheetWriter;
+    getWorksheet(id?: string | number): TWorksheetWriter | undefined;
+    addStyles(): Promise<void>;
+    addThemes(): Promise<void>;
+    addOfficeRels(): Promise<void>;
+    addContentTypes(): Promise<void>;
+    /**
+     * Add media files - can be overridden by Node.js for file system support
+     */
+    addMedia(): Promise<void[]>;
+    addApp(): Promise<void>;
+    addCore(): Promise<void>;
+    addSharedStrings(): Promise<void>;
+    addWorkbookRels(): Promise<void>;
+    addWorkbook(): Promise<void>;
+    _finalize(): Promise<this>;
+}
+export declare const WorkbookWriterOptionsSchema: {
+    readonly useSharedStrings: readonly ["boolean"];
+    readonly useStyles: readonly ["boolean"];
+    readonly trueStreaming: readonly ["boolean"];
+};
+declare class WorkbookWriter extends WorkbookWriterBase<WorksheetWriter> {
+    constructor(options?: WorkbookWriterOptions);
+}
+export { WorkbookWriter };

package/dist/types/modules/excel/stream/workbook-writer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * WorkbookWriter - Node.js Streaming Excel Writer
+ *
+ * Extends base with file path support and file system image loading.
+ */
+import { WorksheetWriter } from "./worksheet-writer";
+import { WorkbookWriterBase, type WorkbookWriterOptions as BaseOptions, type ZipOptions, type ZlibOptions } from "./workbook-writer.browser";
+export type { ZipOptions, ZlibOptions };
+export interface WorkbookWriterOptions extends BaseOptions {
+    /** If stream not specified, this field specifies the path to a file to write the XLSX workbook to */
+    filename?: string;
+}
+interface OutputStreamLike {
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    write(chunk: any): boolean | Promise<boolean>;
+    end(): void;
+    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+}
+declare class WorkbookWriter extends WorkbookWriterBase<WorksheetWriter> {
+    constructor(options?: WorkbookWriterOptions);
+    /**
+     * Create output stream - supports filename option in Node.js
+     */
+    protected _createOutputStream(options: WorkbookWriterOptions): OutputStreamLike;
+    /**
+     * Add media files - supports loading from file system
+     */
+    addMedia(): Promise<void[]>;
+}
+export { WorkbookWriter };

package/dist/types/modules/excel/stream/worksheet-reader.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WorksheetReader - Cross-Platform Streaming Worksheet Reader
+ *
+ * Works in both Node.js and Browser.
+ */
+import { EventEmitter } from "../../stream/index";
+import { Dimensions } from "../range";
+import { Row } from "../row";
+import { Column } from "../column";
+import type { InternalWorksheetOptions } from "./workbook-reader.browser";
+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: any;
+    id: number;
+    iterator: AsyncIterable<unknown>;
+    options?: InternalWorksheetOptions;
+}
+declare class WorksheetReader extends EventEmitter {
+    workbook: any;
+    id: number | string;
+    sheetNo: number;
+    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/modules/excel/stream/worksheet-writer.d.ts

@@ -0,0 +1,140 @@
+import { Dimensions } from "../range";
+import { StringBuf } from "../utils/string-buf";
+import { Row } from "../row";
+import { Column } from "../column";
+import { SheetRelsWriter } from "./sheet-rels-writer";
+import { SheetCommentsWriter } from "./sheet-comments-writer";
+import { DataValidations } from "../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;
+    _rowOffset: 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 };