@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/types/index.browser.d.ts

@@ -31,7 +31,7 @@ export { DefinedNames, type DefinedNameModel } from "./modules/excel/defined-nam
 export type { CheckboxState } from "./modules/excel/form-control.js";
 export type { ColumnDefn, ColumnHeaderValue } from "./modules/excel/column.js";
 export type { RangeInput } from "./modules/excel/range.js";
-export type { WorkbookModel, WorkbookMedia } from "./modules/excel/workbook.js";
+export type { WorkbookModel, WorkbookMedia, WorkbookProtectionModel, ExternalLinkModel, ExternalLinkCachedSheet } from "./modules/excel/workbook.js";
 export { decodeCol, encodeCol, decodeRow, encodeRow, decodeCell, encodeCell, decodeRange, encodeRange } from "./modules/excel/utils/address.js";
 export type { CellAddress, SheetRange, Origin } from "./modules/excel/utils/address.js";
 export type { SheetToJSONOptions, AddJSONOptions, AddAOAOptions } from "./modules/excel/worksheet.js";

package/dist/types/index.d.ts

@@ -30,7 +30,7 @@ export { DefinedNames, type DefinedNameModel } from "./modules/excel/defined-nam
 export type { CheckboxState } from "./modules/excel/form-control.js";
 export type { ColumnDefn, ColumnHeaderValue } from "./modules/excel/column.js";
 export type { RangeInput } from "./modules/excel/range.js";
-export type { WorkbookModel, WorkbookMedia } from "./modules/excel/workbook.js";
+export type { WorkbookModel, WorkbookMedia, WorkbookProtectionModel, ExternalLinkModel, ExternalLinkCachedSheet } from "./modules/excel/workbook.js";
 export type { NodeInput } from "./modules/excel/stream/workbook-reader.js";
 export { decodeCol, encodeCol, decodeRow, encodeRow, decodeCell, encodeCell, decodeRange, encodeRange } from "./modules/excel/utils/address.js";
 export type { CellAddress, SheetRange, Origin } from "./modules/excel/utils/address.js";

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

@@ -2,7 +2,7 @@ import type { Column } from "./column.js";
 import type { ValueType, FormulaType } from "./enums.js";
 import { Note } from "./note.js";
 import type { Row } from "./row.js";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellHyperlinkValue } from "./types.js";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellValueInput, CellHyperlinkValue, RichText } from "./types.js";
 import type { Workbook } from "./workbook.js";
 import type { Worksheet } from "./worksheet.js";
 export type FormulaResult = string | number | boolean | Date | CellErrorValue;
@@ -13,6 +13,7 @@ export interface FormulaValueData {
     sharedFormula?: string;
     result?: FormulaResult;
     date1904?: boolean;
+    isDynamicArray?: boolean;
 }
 interface FullAddress {
     sheetName: string;
@@ -62,12 +63,24 @@ export interface CellModel {
     formula?: string;
     sharedFormula?: string;
     result?: FormulaResult;
-    richText?: CellRichTextValue;
+    /**
+     * Rich-text runs associated with this cell.
+     *
+     * - When `type === RichText`, this holds a CellRichTextValue (object wrapping
+     *   the runs array) — this is the historical, cell-level rich-text payload.
+     * - When `type === Hyperlink`, this holds a plain RichText[] — the runs used
+     *   for formatted display of the hyperlink text.
+     *
+     * Callers should branch on `type` before accessing the shape.
+     */
+    richText?: CellRichTextValue | RichText[];
     sharedString?: number;
     error?: CellErrorValue;
     rawValue?: unknown;
+    isDynamicArray?: boolean;
 }
 export type CellValueType = CellValue;
+export type CellValueInputType = CellValueInput;
 declare class Cell {
     static Types: typeof ValueType;
     private _row;
@@ -111,7 +124,7 @@ declare class Cell {
     get isHyperlink(): boolean;
     get hyperlink(): string | undefined;
     get value(): CellValueType;
-    set value(v: CellValueType);
+    set value(v: CellValueInputType);
     get note(): string | NoteConfig | undefined;
     set note(note: string | NoteConfig);
     get comment(): Note | undefined;
@@ -121,6 +134,7 @@ declare class Cell {
     toString(): string;
     get formula(): string | undefined;
     get result(): FormulaResult | undefined;
+    set result(value: FormulaResult | undefined);
     get formulaType(): FormulaType;
     get fullAddress(): FullAddress;
     get name(): string;

package/dist/types/modules/excel/defined-names.d.ts

@@ -2,6 +2,7 @@ import { Range } from "./range.js";
 import type { Address } from "./types.js";
 import { CellMatrix } from "./utils/cell-matrix.js";
 import { type DecodedRange } from "./utils/col-cache.js";
+import { type SyntaxProbe } from "../formula/default-syntax-probe.js";
 interface DefinedNameCell {
     sheetName?: string;
     address: string;
@@ -13,25 +14,119 @@ type CellLocation = Address | DecodedRange;
 interface DefinedNameModel {
     name: string;
     ranges: string[];
+    localSheetId?: number;
+    /** Formula expression for formula-based defined names (e.g. "LAMBDA(x,y,x+y)") */
+    formulaExpression?: string;
+    /** Original XML text — preserved for opaque names round-trip */
+    rawText?: string;
+    /**
+     * Classification determined by the semantic layer:
+     * - "reference": pure cell/range union — stored in matrixMap
+     * - "formula": parseable expression — stored in formulaMap
+     * - "opaque": unrecognised content preserved for round-trip — stored in opaqueMap
+     */
+    kind?: "reference" | "formula" | "opaque";
+}
+/** Stored entry for an opaque (unrecognised) defined name. */
+interface OpaqueEntry {
+    rawText: string;
+    localSheetId?: number;
 }
 declare class DefinedNames {
     matrixMap: Record<string, CellMatrix>;
-    constructor();
+    /**
+     * Formula-based defined names: storageKey → formula expression string.
+     */
+    formulaMap: Record<string, string>;
+    /**
+     * Tracks the localSheetId for each storage key.
+     * If a key is not in this map, the name is workbook-scoped (global).
+     */
+    localSheetIdMap: Record<string, number>;
+    /**
+     * Opaque defined names: storageKey → original text + optional localSheetId.
+     */
+    opaqueMap: Record<string, OpaqueEntry>;
+    /**
+     * Reverse mapping: storageKey → original name (bare, without scope suffix).
+     * Needed because storageKey encodes the scope, but consumers need the bare name.
+     */
+    nameForKey: Record<string, string>;
+    /**
+     * Optional explicit formula-syntax probe. When set, this is used to
+     * classify non-range, non-wrapper defined-name text during `set model`.
+     * When unset, the classifier falls back to the process-wide default
+     * probe (set by `installFormulaEngine()`). When neither is available,
+     * classification is conservative — non-range text becomes opaque.
+     */
+    private readonly _explicitProbe;
+    /**
+     * @param probe Optional formula-syntax probe used when classifying
+     *   defined-name text. Injecting a probe here makes classification
+     *   deterministic for this instance regardless of process-global
+     *   `installFormulaEngine()` state. When omitted, the instance defers
+     *   to the default probe at classification time (see `set model`).
+     */
+    constructor(probe?: SyntaxProbe);
     getMatrix(name: string): CellMatrix;
     add(locStr: string, name: string): void;
     addEx(location: CellLocation, name: string): void;
+    /**
+     * Register a formula-based defined name.
+     *
+     * Unlike `add()` which binds a name to a cell/range reference, this binds
+     * a name to an arbitrary formula expression that will be evaluated at
+     * calculation time.
+     *
+     * @param name - The defined name (e.g. "MyArray")
+     * @param expression - The formula expression (e.g. "{1,2;3,4}", "LAMBDA(x,y,x+y)")
+     */
+    addFormula(name: string, expression: string): void;
     remove(locStr: string, name: string): void;
     removeEx(location: CellLocation, name: string): void;
     removeAllNames(location: CellLocation): void;
     forEach(callback: (name: string, cell: DefinedNameCell) => void): void;
     getNames(addressStr: string): string[];
     getNamesEx(address: Address): string[];
+    /**
+     * Return all defined name entries in this collection, including scope info.
+     * Each entry has the bare name and optional localSheetId.
+     * Same bare name may appear multiple times with different scopes.
+     */
+    getAllNames(): {
+        name: string;
+        localSheetId?: number;
+    }[];
+    /**
+     * Return all defined name entries with full details (name, ranges, scope).
+     *
+     * This is the primary enumeration API. Each entry is self-contained —
+     * no second lookup is needed. Same bare name may appear multiple times
+     * with different scopes.
+     */
+    getAllEntries(): DefinedNameModel[];
     _explore(matrix: CellMatrix, cell: DefinedNameCell): Range;
+    /**
+     * Get ranges for a specific scoped entry.
+     *
+     * Unlike `getRanges(name)` which uses the bare name (and may hit the
+     * wrong scope when the same name exists both globally and locally),
+     * this method uses the internal `storageKey` to look up the exact entry.
+     */
+    getRangesScoped(name: string, localSheetId?: number): DefinedNameModel;
     getRanges(name: string, matrix?: CellMatrix): DefinedNameModel;
     normaliseMatrix(matrix: CellMatrix, sheetName: string): void;
     spliceRows(sheetName: string, start: number, numDelete: number, numInsert: number): void;
     spliceColumns(sheetName: string, start: number, numDelete: number, numInsert: number): void;
     get model(): DefinedNameModel[];
+    /**
+     * Deserialise an array of `DefinedNameModel` entries (typically from XLSX parsing).
+     *
+     * Stage 2 of the two-phase design: each entry's `rawText` is classified
+     * into reference / formula / opaque by `classifyDefinedName()`.  Entries
+     * that arrive without `rawText` (programmatic API) fall back to inspecting
+     * the existing `ranges` and `formulaExpression` fields for compatibility.
+     */
     set model(value: DefinedNameModel[]);
 }
 export { DefinedNames, type DefinedNameModel };

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

@@ -8,12 +8,19 @@ interface ImageExt {
     width?: number;
     height?: number;
 }
+/** Absolute position in pixels (for absoluteAnchor). */
+interface ImagePos {
+    x: number;
+    y: number;
+}
 interface ImageRange {
     tl: Anchor;
     br?: Anchor;
     ext?: ImageExt;
     editAs?: string;
     hyperlinks?: ImageHyperlinks;
+    /** Absolute position — mutually exclusive with tl/br cell anchors. */
+    pos?: ImagePos;
 }
 interface BackgroundModel {
     type: "background";
@@ -37,6 +44,8 @@ interface ImageRangeModel {
     br?: AnchorModel;
     ext?: ImageExt;
     editAs?: string;
+    /** Absolute position — when present, tl/br are ignored. */
+    pos?: ImagePos;
 }
 interface ImageModel {
     type: "image";
@@ -58,6 +67,8 @@ interface RangeInput {
     ext?: ImageExt;
     editAs?: string;
     hyperlinks?: ImageHyperlinks;
+    /** Absolute position — when present, tl/br are ignored. */
+    pos?: ImagePos;
 }
 interface ModelInput {
     type: string;

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

@@ -8,6 +8,7 @@
  * Node.js uses `workbook-reader.ts`, which extends the same base implementation
  * with filesystem-specific features (filename input + temp-file buffering).
  */
+import type { ZipEntry } from "../../archive/unzip/stream.js";
 import { HyperlinkReader, type Hyperlink } from "./hyperlink-reader.js";
 import { WorksheetReader } from "./worksheet-reader.js";
 import type { WorksheetState, Font, WorkbookProperties } from "../types.js";
@@ -72,7 +73,7 @@ export type ParseEvent<TWorksheetReader, THyperlinkReader> = SharedStringEvent |
 export interface WaitingWorksheetEntry {
     eventType: "waiting-worksheet";
     sheetNo: string;
-    entry: any;
+    entry: ZipEntry;
 }
 export type CommonInput = Uint8Array | ArrayBuffer | Readable | ReadableStream<Uint8Array>;
 export interface WorkbookReaderOptions {
@@ -120,6 +121,10 @@ export declare abstract class WorkbookReaderBase<TInput, TWorksheetReader extend
     workbookRels?: WorkbookRelationship[];
     properties?: WorkbookPropertiesXform;
     model?: WorkbookModel;
+    /** Whether xl/metadata.xml contains XLDAPR dynamic array metadata */
+    hasDynamicArrayMetadata: boolean;
+    /** Precise set of cm values (1-indexed) that map to XLDAPR metadataType */
+    dynamicArrayCmIndices?: Set<number>;
     /** Maximum bytes to buffer for worksheets waiting on prerequisites. Default: 256 MB. */
     protected _maxBufferedBytes: number;
     /** Running total of bytes buffered for waiting worksheets. */
@@ -134,7 +139,7 @@ export declare abstract class WorkbookReaderBase<TInput, TWorksheetReader extend
     protected HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, this>;
     constructor(input: TInput, options: WorkbookReaderOptions, WorksheetReaderClass: ReaderConstructor<TWorksheetReader, any>, HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, any>);
     protected _getStream(input: TInput): Readable;
-    abstract _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<TWaitingWorksheet>;
+    abstract _storeWaitingWorksheet(sheetNo: string, entry: ZipEntry): Promise<TWaitingWorksheet>;
     abstract _processWaitingWorksheets(waitingWorksheets: TWaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<TWorksheetReader>>;
     protected _cleanupWaitingWorksheets(_waitingWorksheets: TWaitingWorksheet[]): void;
     private _createWorksheetReader;
@@ -147,6 +152,7 @@ export declare abstract class WorkbookReaderBase<TInput, TWorksheetReader extend
     private _parseWorkbook;
     private _parseSharedStrings;
     private _parseStyles;
+    private _parseMetadata;
     protected _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>;
@@ -164,7 +170,7 @@ interface WaitingWorksheet {
 }
 declare class WorkbookReader extends WorkbookReaderBase<CommonInput, WorksheetReader, HyperlinkReader, WaitingWorksheet> {
     constructor(input: CommonInput, options?: WorkbookReaderOptions);
-    _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<WaitingWorksheet>;
+    _storeWaitingWorksheet(sheetNo: string, entry: ZipEntry): Promise<WaitingWorksheet>;
     _processWaitingWorksheets(waitingWorksheets: WaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<WorksheetReader>>;
 }
 export { WorkbookReader };

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

@@ -3,6 +3,7 @@
  *
  * Extends base with file path support and temp file storage for large files.
  */
+import type { ZipEntry } from "../../archive/unzip/stream.js";
 import { HyperlinkReader } from "./hyperlink-reader.js";
 import { WorkbookReaderBase, type CommonInput, type WorkbookReaderOptions, type WorksheetReadyEvent, WorkbookReaderOptionsSchema } from "./workbook-reader.browser.js";
 import { WorksheetReader } from "./worksheet-reader.js";
@@ -18,7 +19,7 @@ interface WaitingWorksheet {
 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>;
+    _storeWaitingWorksheet(sheetNo: string, entry: ZipEntry): Promise<WaitingWorksheet>;
     _processWaitingWorksheets(waitingWorksheets: WaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<WorksheetReader>>;
 }
 export { WorkbookReader, WorkbookReaderOptionsSchema };

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

@@ -10,11 +10,17 @@
 import { Zip } from "../../archive/zip/stream.js";
 import { DefinedNames } from "../defined-names.js";
 import { WorksheetWriter } from "./worksheet-writer.js";
-import type { ImageData, WorkbookView, AddWorksheetOptions } from "../types.js";
+import type { Font, ImageData, WorkbookView, WorkbookProtection, AddWorksheetOptions } from "../types.js";
 import { SharedStrings } from "../utils/shared-strings.js";
 import { StylesXform } from "../xlsx/xform/style/styles-xform.js";
 import type { Writable } from "../../stream/index.js";
-interface Medium extends ImageData {
+/**
+ * An image registered in the streaming writer.
+ *
+ * Extends the public {@link ImageData} shape with the unique stored name
+ * (`name`) assigned by `addImage`, and pins `type` to `"image"`.
+ */
+export interface Medium extends ImageData {
     type: "image";
     name: string;
 }
@@ -56,8 +62,8 @@ export interface WorkbookWriterOptions {
     trueStreaming?: boolean;
 }
 interface OutputStreamLike {
-    emit(eventName: string | symbol, ...args: any[]): boolean;
-    write(chunk: any): boolean | Promise<boolean>;
+    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    write(chunk: Uint8Array | string): boolean | Promise<boolean>;
     end(): void;
     once(eventName: string | symbol, listener: (...args: any[]) => void): this;
     removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
@@ -107,6 +113,18 @@ export declare abstract class WorkbookWriterBase<TWorksheetWriter extends Worksh
     compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
     media: Medium[];
     commentRefs: CommentRef[];
+    /** Number of cells with dynamic array formulas, accumulated during worksheet commit */
+    dynamicArrayCount: number;
+    /** Workbook-level structure protection */
+    protection?: {
+        lockStructure?: boolean;
+        lockWindows?: boolean;
+        lockRevision?: boolean;
+        algorithmName?: string;
+        hashValue?: string;
+        saltValue?: string;
+        spinCount?: number;
+    };
     zip: Zip;
     stream: OutputStreamLike;
     promise: Promise<void[] | void>;
@@ -118,12 +136,27 @@ export declare abstract class WorkbookWriterBase<TWorksheetWriter extends Worksh
      */
     protected _createOutputStream(options: WorkbookWriterOptions): OutputStreamLike;
     get definedNames(): DefinedNames;
+    /**
+     * The default font for the workbook (fontId=0 / "Normal" style).
+     * Must be set before any worksheet rows are committed.
+     */
+    get defaultFont(): Partial<Font> | undefined;
+    set defaultFont(font: Partial<Font> | undefined);
     protected _addFile(data: string | Uint8Array, name: string, base64?: boolean): void;
     private _commitWorksheets;
     commit(): Promise<void>;
     get nextId(): number;
     addImage(image: ImageData): number;
-    getImage(id: number): ImageData | undefined;
+    getImage(id: number): Medium | undefined;
+    /**
+     * Protect the workbook structure with an optional password.
+     * Prevents users from adding, deleting, renaming, moving, or copying worksheets.
+     */
+    protect(password?: string, options?: Partial<WorkbookProtection>): Promise<void>;
+    /**
+     * Remove workbook structure protection.
+     */
+    unprotect(): void;
     addWorksheet(name?: string, options?: Partial<AddWorksheetOptions>): TWorksheetWriter;
     getWorksheet(id?: string | number): TWorksheetWriter | undefined;
     addStyles(): Promise<void>;
@@ -144,6 +177,7 @@ export declare abstract class WorkbookWriterBase<TWorksheetWriter extends Worksh
     addCore(): Promise<void>;
     addSharedStrings(): Promise<void>;
     addFeaturePropertyBag(): Promise<void>;
+    addMetadata(): Promise<void>;
     addWorkbookRels(): Promise<void>;
     addWorkbook(): Promise<void>;
     private _finalize;

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

@@ -6,13 +6,14 @@
 import { WorkbookWriterBase, type WorkbookWriterOptions as BaseOptions, type WorkbookZipOptions, type ZlibOptions } from "./workbook-writer.browser.js";
 import { WorksheetWriter } from "./worksheet-writer.js";
 export type { WorkbookZipOptions, ZlibOptions };
+export type { Medium } from "./workbook-writer.browser.js";
 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>;
+    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    write(chunk: Uint8Array | string): boolean | Promise<boolean>;
     end(): void;
     once(eventName: string | symbol, listener: (...args: any[]) => void): this;
     removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;

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

@@ -3,11 +3,37 @@ import { Column } from "../column.js";
 import { DataValidations } from "../data-validations.js";
 import { Dimensions } from "../range.js";
 import { Row } from "../row.js";
-import type { RowBreak, ColBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions, AddImageRange, WatermarkOptions, RowValues } from "../types.js";
+import type { Medium as WriterMedium } from "./workbook-writer.js";
+import { type DrawingAnchor, type DrawingRel } from "../utils/drawing-utils.js";
+import type { SharedStrings } from "../utils/shared-strings.js";
+import type { StreamBuf } from "../utils/stream-buf.js";
+import type { RowBreak, ColBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions, AddImageRange, IgnoredError, WatermarkOptions, RowValues } from "../types.js";
+/**
+ * Structural view of the fields/methods WorksheetWriter needs from its
+ * parent WorkbookWriter. Defined here (rather than importing WorkbookWriter
+ * directly) to avoid the circular `workbook-writer.ts <-> worksheet-writer.ts`
+ * dependency. The shape must stay in sync with the concrete WorkbookWriter.
+ */
+export interface WorkbookWriterLike {
+    /** Shared-string table (deduplicates plain/rich-text cell values). */
+    readonly sharedStrings: SharedStrings;
+    /**
+     * Style manager. Typed loosely here (`unknown`) because the concrete
+     * `StylesXform` is an internal xform class and pulling it in would
+     * reintroduce the circular import. Xform methods accept it by duck-typing.
+     */
+    readonly styles: object;
+    /** Incremented once per dynamic-array formula cell during row commit. */
+    dynamicArrayCount: number;
+    /** Lookup a media (image/chart) by registered id. */
+    getImage(id: number): WriterMedium | undefined;
+    /** Open a streaming entry in the output zip for the given path. */
+    _openStream(path: string): InstanceType<typeof StreamBuf>;
+}
 interface WorksheetWriterOptions {
     id: number;
     name?: string;
-    workbook: any;
+    workbook: WorkbookWriterLike;
     useSharedStrings?: boolean;
     properties?: Partial<WorksheetProperties>;
     state?: WorksheetState;
@@ -38,6 +64,11 @@ interface WriterImageModel {
             height: number;
         };
         editAs?: string;
+        /** Absolute position in pixels — mutually exclusive with tl/br cell anchors. */
+        pos?: {
+            x: number;
+            y: number;
+        };
     };
     hyperlinks?: {
         hyperlink?: string;
@@ -67,6 +98,7 @@ declare class WorksheetWriter {
     private _formulae;
     private _siFormulae;
     conditionalFormatting: ConditionalFormattingOptions[];
+    ignoredErrors: IgnoredError[];
     rowBreaks: RowBreak[];
     colBreaks: ColBreak[];
     properties: Partial<WorksheetProperties> & {
@@ -104,8 +136,8 @@ declare class WorksheetWriter {
     /** Relationship Id - assigned by WorkbookWriter */
     rId?: string;
     constructor(options: WorksheetWriterOptions);
-    get workbook(): any;
-    get stream(): any;
+    get workbook(): WorkbookWriterLike;
+    get stream(): InstanceType<typeof StreamBuf>;
     destroy(): void;
     commit(): void;
     get dimensions(): Dimensions;
@@ -184,6 +216,7 @@ declare class WorksheetWriter {
      * The prepare phase was already done in _writeConditionalFormatting().
      */
     private _writeExtLst;
+    private _writeIgnoredErrors;
     private _writeRowBreaks;
     private _writeColBreaks;
     private _writeDataValidations;
@@ -197,8 +230,8 @@ declare class WorksheetWriter {
     get drawing(): {
         rId: string;
         name: string;
-        anchors: any[];
-        rels: any[];
+        anchors: DrawingAnchor[];
+        rels: DrawingRel[];
     } | undefined;
     private _writeBackground;
     private _writeLegacyData;