@coco-vexel/coco-office 0.0.0-stage → 1.0.1

package/dist/excel.d.ts

@@ -0,0 +1,2252 @@
+import { a as Package } from './types-BVkkdcfh.js';
+
+type ExcelCellValue = string | number | boolean | null;
+type ExcelCellKind = 'blank' | 'string' | 'number' | 'boolean' | 'formula' | 'error';
+interface ExcelCellModel {
+    /** A1-style address, for example `C12`. */
+    address: string;
+    /** 1-based row index. */
+    row: number;
+    /** 1-based column index. */
+    column: number;
+    kind: ExcelCellKind;
+    value: ExcelCellValue;
+    /** Raw `<v>` text, before shared-string / boolean / number conversion. */
+    rawValue?: string;
+    /** Formula text without the leading `=`. */
+    formula?: string;
+    /** OOXML cell type attribute, for example `s`, `inlineStr`, `b`, `str`, `e`. */
+    dataType?: string;
+    /** OOXML style index from the `s` attribute. */
+    styleId?: number;
+    /** Shared string table index when `dataType === "s"`. */
+    sharedStringIndex?: number;
+}
+interface ExcelColumnModel {
+    min: number;
+    max: number;
+    width?: number;
+    hidden?: boolean;
+    styleId?: number;
+    customWidth?: boolean;
+}
+interface ExcelRowModel {
+    index: number;
+    height?: number;
+    hidden?: boolean;
+    styleId?: number;
+    customHeight?: boolean;
+}
+interface ExcelMergedRangeModel {
+    address: string;
+}
+interface ExcelHyperlinkModel {
+    ref: string;
+    relationshipId?: string;
+    target?: string;
+    targetMode?: string;
+    location?: string;
+    display?: string;
+    tooltip?: string;
+}
+interface ExcelTableColumnModel {
+    id: number;
+    name: string;
+    totalsRowLabel?: string;
+    totalsRowFunction?: string;
+}
+interface ExcelTableFilterColumnModel {
+    colId: number;
+    hiddenButton?: boolean;
+    showButton?: boolean;
+    filters?: string[];
+}
+interface ExcelTableSortConditionModel {
+    ref?: string;
+    descending?: boolean;
+    sortBy?: string;
+}
+interface ExcelTableSortStateModel {
+    ref?: string;
+    caseSensitive?: boolean;
+    sortMethod?: string;
+    conditions: ExcelTableSortConditionModel[];
+}
+interface ExcelTableAutoFilterModel {
+    ref?: string;
+    filterColumns: ExcelTableFilterColumnModel[];
+    sortState?: ExcelTableSortStateModel;
+}
+interface ExcelTableStyleModel {
+    name?: string;
+    showFirstColumn?: boolean;
+    showLastColumn?: boolean;
+    showRowStripes?: boolean;
+    showColumnStripes?: boolean;
+}
+interface ExcelTableModel {
+    id?: number;
+    name?: string;
+    displayName?: string;
+    relationshipId?: string;
+    path?: string;
+    ref?: string;
+    headerRowCount?: number;
+    totalsRowCount?: number;
+    totalsRowShown?: boolean;
+    autoFilterRef?: string;
+    autoFilter?: ExcelTableAutoFilterModel;
+    columns: ExcelTableColumnModel[];
+    style?: ExcelTableStyleModel;
+}
+interface ExcelDataValidationModel {
+    sqref?: string;
+    type?: string;
+    operator?: string;
+    allowBlank?: boolean;
+    showDropDown?: boolean;
+    showInputMessage?: boolean;
+    showErrorMessage?: boolean;
+    errorStyle?: string;
+    errorTitle?: string;
+    error?: string;
+    promptTitle?: string;
+    prompt?: string;
+    formula1?: string;
+    formula2?: string;
+}
+interface ExcelConditionalFormatRuleModel {
+    type?: string;
+    priority?: number;
+    operator?: string;
+    dxfId?: number;
+    stopIfTrue?: boolean;
+    aboveAverage?: boolean;
+    percent?: boolean;
+    bottom?: boolean;
+    rank?: number;
+    text?: string;
+    timePeriod?: string;
+    formulas: string[];
+}
+interface ExcelConditionalFormatModel {
+    sqref?: string;
+    rules: ExcelConditionalFormatRuleModel[];
+}
+interface ExcelCommentModel {
+    ref: string;
+    authorId?: number;
+    author?: string;
+    text: string;
+    shapeId?: number;
+}
+interface ExcelThreadedCommentModel {
+    ref: string;
+    id?: string;
+    personId?: string;
+    dateTime?: string;
+    text: string;
+}
+interface ExcelPaneModel {
+    xSplit?: number;
+    ySplit?: number;
+    topLeftCell?: string;
+    activePane?: string;
+    state?: string;
+}
+interface ExcelSelectionModel {
+    pane?: string;
+    activeCell?: string;
+    activeCellId?: number;
+    sqref?: string;
+}
+interface ExcelSheetViewModel {
+    workbookViewId?: number;
+    view?: string;
+    tabSelected?: boolean;
+    showGridLines?: boolean;
+    showRowColHeaders?: boolean;
+    zoomScale?: number;
+    zoomScaleNormal?: number;
+    topLeftCell?: string;
+    pane?: ExcelPaneModel;
+    selections: ExcelSelectionModel[];
+}
+interface ExcelDrawingMarkerModel {
+    row?: number;
+    rowOffset?: number;
+    column?: number;
+    columnOffset?: number;
+}
+interface ExcelDrawingObjectModel {
+    kind: 'chart' | 'image' | 'shape' | 'graphicFrame' | 'unknown';
+    name?: string;
+    relationshipId?: string;
+    targetPath?: string;
+    targetMode?: string;
+}
+interface ExcelDrawingAnchorModel {
+    kind: 'oneCell' | 'twoCell' | 'absolute';
+    from?: ExcelDrawingMarkerModel;
+    to?: ExcelDrawingMarkerModel;
+    object?: ExcelDrawingObjectModel;
+}
+interface ExcelDrawingModel {
+    relationshipId?: string;
+    path?: string;
+    anchors: ExcelDrawingAnchorModel[];
+}
+type ExcelChartType = 'columnClustered' | 'columnStacked' | 'barClustered' | 'barStacked' | 'line' | 'lineMarkers' | 'pie' | 'doughnut';
+interface ExcelChartSeriesModel {
+    name?: string;
+    values: string;
+}
+interface ExcelChartPositionModel {
+    from: ExcelDrawingMarkerModel;
+    to: ExcelDrawingMarkerModel;
+}
+interface ExcelChartAddOptions {
+    type: ExcelChartType;
+    title?: string;
+    categoryRange: string;
+    series: ExcelChartSeriesModel[];
+    position: ExcelChartPositionModel;
+}
+interface ExcelChartModel {
+    relationshipId?: string;
+    drawingPath?: string;
+    path?: string;
+    type?: ExcelChartType;
+    title?: string;
+    categoryRange?: string;
+    series?: ExcelChartSeriesModel[];
+    position?: ExcelChartPositionModel;
+    formulaRefs: string[];
+}
+interface ExcelImageModel {
+    relationshipId?: string;
+    drawingPath?: string;
+    path?: string;
+    targetMode?: string;
+    name?: string;
+}
+interface ExcelShapeModel {
+    drawingPath?: string;
+    name?: string;
+    anchor: ExcelDrawingAnchorModel;
+}
+interface ExcelColorModel {
+    /** Canonical RGB color in strict #RRGGBB form. */
+    rgb: string;
+}
+interface ExcelNumberFormatModel {
+    id: number;
+    code: string;
+}
+interface ExcelFontModel {
+    name?: string;
+    size?: number;
+    family?: number;
+    charset?: number;
+    scheme?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    color?: ExcelColorModel;
+}
+interface ExcelFillModel {
+    patternType?: string;
+    foregroundColor?: ExcelColorModel;
+    backgroundColor?: ExcelColorModel;
+}
+interface ExcelBorderSideModel {
+    style?: string;
+    color?: ExcelColorModel;
+}
+interface ExcelBorderModel {
+    left?: ExcelBorderSideModel;
+    right?: ExcelBorderSideModel;
+    top?: ExcelBorderSideModel;
+    bottom?: ExcelBorderSideModel;
+    diagonal?: ExcelBorderSideModel;
+}
+interface ExcelAlignmentModel {
+    horizontal?: string;
+    vertical?: string;
+    textRotation?: number;
+    wrapText?: boolean;
+    shrinkToFit?: boolean;
+    indent?: number;
+}
+interface ExcelCellFormatModel {
+    numberFormatId?: number;
+    numberFormatCode?: string;
+    fontId?: number;
+    fillId?: number;
+    borderId?: number;
+    xfId?: number;
+    applyNumberFormat?: boolean;
+    applyFont?: boolean;
+    applyFill?: boolean;
+    applyBorder?: boolean;
+    applyAlignment?: boolean;
+    alignment?: ExcelAlignmentModel;
+}
+interface ExcelStylesModel {
+    numberFormats: ExcelNumberFormatModel[];
+    fonts: ExcelFontModel[];
+    fills: ExcelFillModel[];
+    borders: ExcelBorderModel[];
+    cellFormats: ExcelCellFormatModel[];
+}
+interface ExcelSheetModel {
+    id: string;
+    name: string;
+    visibility?: string;
+    relationshipId?: string;
+    path?: string;
+    dimension?: string;
+    sheetViews: ExcelSheetViewModel[];
+    columns: ExcelColumnModel[];
+    rows: ExcelRowModel[];
+    mergedRanges: ExcelMergedRangeModel[];
+    hyperlinks: ExcelHyperlinkModel[];
+    tables: ExcelTableModel[];
+    dataValidations: ExcelDataValidationModel[];
+    conditionalFormats: ExcelConditionalFormatModel[];
+    comments: ExcelCommentModel[];
+    threadedComments: ExcelThreadedCommentModel[];
+    drawings: ExcelDrawingModel[];
+    charts: ExcelChartModel[];
+    images: ExcelImageModel[];
+    cells: ExcelCellModel[];
+}
+interface ExcelDefinedNameModel {
+    name: string;
+    text: string;
+    localSheetId?: number;
+}
+interface ExcelWorkbookModel {
+    sheets: ExcelSheetModel[];
+    sharedStrings: string[];
+    definedNames: ExcelDefinedNameModel[];
+    styles: ExcelStylesModel;
+}
+
+declare class ExcelNamedItem$1 {
+    private readonly model;
+    private readonly names;
+    constructor(model: ExcelDefinedNameModel, names: ExcelDefinedNameModel[]);
+    name(): string;
+    text(): string;
+    setText(text: string): void;
+    rename(name: string): void;
+    localSheetId(): number | undefined;
+    setLocalSheetId(localSheetId: number | undefined): void;
+    toModel(): ExcelDefinedNameModel;
+}
+declare class ExcelNamedItemCollection$1 {
+    private readonly itemsByModel;
+    private readonly models;
+    constructor(names: ExcelDefinedNameModel[]);
+    items(): ExcelNamedItem$1[];
+    getItem(name: string): ExcelNamedItem$1;
+    getItemOrNullObject(name: string): ExcelNamedItem$1 | null;
+    add(model: ExcelDefinedNameModel): ExcelNamedItem$1;
+    deleteItem(name: string): void;
+}
+
+type ExcelWorkbookMutation = ExcelRangeSetValuesMutation | ExcelRangeSetFormulasMutation | ExcelRangeClearMutation | ExcelRangeMergeMutation | ExcelRangeUnmergeMutation | ExcelRangeSetRowHeightMutation | ExcelRangeSetColumnWidthMutation | ExcelRangeSetFontColorMutation | ExcelRangeSetFillForegroundColorMutation | ExcelRangeSetBorderMutation | ExcelWorksheetAddMutation | ExcelWorksheetDeleteMutation | ExcelWorksheetRenameMutation | ExcelUnsafeMutation;
+interface ExcelMutationSheetRef {
+    sheetId?: string;
+    sheetName: string;
+}
+interface ExcelRangeMutationBase extends ExcelMutationSheetRef {
+    address: string;
+}
+interface ExcelRangeSetValuesMutation extends ExcelRangeMutationBase {
+    kind: 'range.setValues';
+    values: ExcelCellValue[][];
+}
+interface ExcelRangeSetFormulasMutation extends ExcelRangeMutationBase {
+    kind: 'range.setFormulas';
+    formulas: (string | null)[][];
+}
+interface ExcelRangeClearMutation extends ExcelRangeMutationBase {
+    kind: 'range.clear';
+}
+interface ExcelRangeMergeMutation extends ExcelRangeMutationBase {
+    kind: 'range.merge';
+}
+interface ExcelRangeUnmergeMutation extends ExcelRangeMutationBase {
+    kind: 'range.unmerge';
+}
+interface ExcelRangeSetRowHeightMutation extends ExcelRangeMutationBase {
+    kind: 'range.setRowHeight';
+    height: number | undefined;
+}
+interface ExcelRangeSetColumnWidthMutation extends ExcelRangeMutationBase {
+    kind: 'range.setColumnWidth';
+    width: number | undefined;
+}
+interface ExcelRangeSetFontColorMutation extends ExcelRangeMutationBase {
+    kind: 'range.format.font.setColor';
+    color: ExcelColorModel | undefined;
+}
+interface ExcelRangeSetFillForegroundColorMutation extends ExcelRangeMutationBase {
+    kind: 'range.format.fill.setForegroundColor';
+    color: ExcelColorModel | undefined;
+}
+interface ExcelRangeSetBorderMutation extends ExcelRangeMutationBase {
+    kind: 'range.format.border.setValue';
+    border: ExcelBorderModel;
+}
+interface ExcelWorksheetAddMutation extends ExcelMutationSheetRef {
+    kind: 'worksheet.add';
+}
+interface ExcelWorksheetDeleteMutation extends ExcelMutationSheetRef {
+    kind: 'worksheet.delete';
+}
+interface ExcelWorksheetRenameMutation extends ExcelMutationSheetRef {
+    kind: 'worksheet.rename';
+    oldName: string;
+    newName: string;
+}
+interface ExcelUnsafeMutation {
+    kind: 'unsafe';
+    scope: 'workbook' | 'worksheet' | 'range' | 'object';
+    sheetId?: string;
+    sheetName?: string;
+    reason: string;
+}
+type ExcelMutationRecorder = (mutation: ExcelWorkbookMutation) => void;
+declare function changedSheetNamesFromMutations(mutations: readonly ExcelWorkbookMutation[]): string[];
+
+type ReplayableRangeFormatMutation = Omit<ExcelRangeSetFontColorMutation, 'sheetId' | 'sheetName'> | Omit<ExcelRangeSetFillForegroundColorMutation, 'sheetId' | 'sheetName'> | Omit<ExcelRangeSetBorderMutation, 'sheetId' | 'sheetName'>;
+declare class ExcelRange$1 {
+    readonly format: ExcelRangeFormat$1;
+    private readonly sheet;
+    private readonly styles;
+    private readonly ref;
+    private readonly cellsByAddress;
+    private readonly recordMutation?;
+    constructor(sheet: ExcelSheetModel, address: string, styles?: ExcelStylesModel, recordMutation?: ExcelMutationRecorder);
+    address(): string;
+    rowIndex(): number;
+    columnIndex(): number;
+    rowCount(): number;
+    columnCount(): number;
+    values(): ExcelCellValue[][];
+    formulas(): (string | null)[][];
+    text(): string[][];
+    valueTypes(): ExcelCellKind[][];
+    rawValues(): (string | null)[][];
+    styleIds(): (number | undefined)[][];
+    setStyleId(styleId: number | undefined): void;
+    rowHeights(): Array<number | undefined>;
+    setRowHeight(height: number | undefined): void;
+    columnWidths(): Array<number | undefined>;
+    setColumnWidth(width: number | undefined): void;
+    merge(): void;
+    unmerge(): void;
+    setValues(values: ExcelCellValue[][]): void;
+    setFormulas(formulas: (string | null)[][]): void;
+    clear(): void;
+    getCell(rowOffset: number, columnOffset: number): ExcelCell$1;
+    getRow(rowOffset: number): ExcelRange$1;
+    getColumn(columnOffset: number): ExcelRange$1;
+    resize(rowCount: number, columnCount: number): ExcelRange$1;
+    offset(rowOffset: number, columnOffset: number, rowCount?: number, columnCount?: number): ExcelRange$1;
+    slice(rowOffset: number, columnOffset: number, rowCount: number, columnCount: number): ExcelRange$1;
+    toModel(): ExcelCellModel[];
+    getResolvedFormat(): ExcelCellFormatModel;
+    updateFormat(update: (format: ExcelCellFormatModel) => ExcelCellFormatModel, options?: {
+        recordUnsafe?: boolean;
+    }): void;
+    recordReplayableMutation(mutation: ReplayableRangeFormatMutation): void;
+    ensureFont(font: ExcelFontModel): number;
+    ensureFill(fill: ExcelFillModel): number;
+    ensureBorder(border: ExcelBorderModel): number;
+    ensureNumberFormat(code: string): number;
+    fontById(id: number | undefined): ExcelFontModel;
+    fillById(id: number | undefined): ExcelFillModel;
+    borderById(id: number | undefined): ExcelBorderModel;
+    private matrix;
+    private assertOffset;
+    private assertMatrixShape;
+    private setCellValue;
+    private setCellFormula;
+    private ensureCell;
+    private deleteCell;
+    private clearCellContent;
+    private ensureRow;
+    private ensureColumn;
+    private firstCell;
+}
+declare class ExcelCell$1 {
+    private readonly range;
+    constructor(sheet: ExcelSheetModel, address: string, styles?: ExcelStylesModel, recordMutation?: ExcelMutationRecorder);
+    address(): string;
+    value(): ExcelCellValue;
+    formula(): string | null;
+    text(): string;
+    valueType(): ExcelCellKind;
+    rawValue(): string | null;
+    styleId(): number | undefined;
+    setStyleId(styleId: number | undefined): void;
+    setValue(value: ExcelCellValue): void;
+    setFormula(formula: string | null): void;
+    clear(): void;
+    toRange(): ExcelRange$1;
+    toModel(): ExcelCellModel | null;
+}
+declare class ExcelRangeFormat$1 {
+    private readonly range;
+    readonly font: ExcelRangeFontFormat$1;
+    readonly fill: ExcelRangeFillFormat$1;
+    readonly border: ExcelRangeBorderFormat$1;
+    readonly alignment: ExcelRangeAlignmentFormat$1;
+    constructor(range: ExcelRange$1);
+    numberFormatCode(): string | undefined;
+    setNumberFormatCode(code: string | undefined): void;
+}
+declare class ExcelRangeFontFormat$1 {
+    private readonly range;
+    constructor(range: ExcelRange$1);
+    value(): ExcelFontModel;
+    setValue(font: ExcelFontModel, options?: {
+        recordUnsafe?: boolean;
+    }): void;
+    bold(): boolean | undefined;
+    setBold(value: boolean | undefined): void;
+    italic(): boolean | undefined;
+    setItalic(value: boolean | undefined): void;
+    underline(): boolean | undefined;
+    setUnderline(value: boolean | undefined): void;
+    color(): ExcelColorModel | undefined;
+    setColor(color: ExcelColorModel | undefined): void;
+    size(): number | undefined;
+    setSize(size: number | undefined): void;
+    name(): string | undefined;
+    setName(name: string | undefined): void;
+    private patch;
+}
+declare class ExcelRangeFillFormat$1 {
+    private readonly range;
+    constructor(range: ExcelRange$1);
+    value(): ExcelFillModel;
+    setValue(fill: ExcelFillModel, options?: {
+        recordUnsafe?: boolean;
+    }): void;
+    patternType(): string | undefined;
+    setPatternType(patternType: string | undefined): void;
+    foregroundColor(): ExcelColorModel | undefined;
+    setForegroundColor(color: ExcelColorModel | undefined): void;
+    backgroundColor(): ExcelColorModel | undefined;
+    setBackgroundColor(color: ExcelColorModel | undefined): void;
+    private patch;
+}
+declare class ExcelRangeBorderFormat$1 {
+    private readonly range;
+    constructor(range: ExcelRange$1);
+    value(): ExcelBorderModel;
+    setValue(border: ExcelBorderModel): void;
+    setLeft(side: ExcelBorderModel['left']): void;
+    setRight(side: ExcelBorderModel['right']): void;
+    setTop(side: ExcelBorderModel['top']): void;
+    setBottom(side: ExcelBorderModel['bottom']): void;
+    private patch;
+}
+declare class ExcelRangeAlignmentFormat$1 {
+    private readonly range;
+    constructor(range: ExcelRange$1);
+    value(): ExcelAlignmentModel | undefined;
+    setValue(alignment: ExcelAlignmentModel | undefined): void;
+    setHorizontal(horizontal: string | undefined): void;
+    setVertical(vertical: string | undefined): void;
+    setWrapText(wrapText: boolean | undefined): void;
+    private patch;
+}
+
+declare class ExcelTable$1 {
+    private readonly model;
+    private readonly remove?;
+    readonly columns: ExcelTableColumnCollection$1;
+    readonly style: ExcelTableStyle$1;
+    constructor(model: ExcelTableModel, remove?: (() => void) | undefined);
+    id(): number | undefined;
+    name(): string | undefined;
+    displayName(): string | undefined;
+    setName(name: string): void;
+    setDisplayName(displayName: string): void;
+    rangeAddress(): string | undefined;
+    setRange(address: string): void;
+    resize(address: string): void;
+    autoFilterRangeAddress(): string | undefined;
+    setAutoFilterRange(address: string | undefined): void;
+    headerRowCount(): number | undefined;
+    setHeaderRowCount(count: number | undefined): void;
+    totalsRowCount(): number | undefined;
+    setTotalsRowCount(count: number | undefined): void;
+    totalsRowShown(): boolean | undefined;
+    setTotalsRowShown(value: boolean | undefined): void;
+    autoFilter(): ExcelTableAutoFilterModel | undefined;
+    setAutoFilter(model: ExcelTableAutoFilterModel | undefined): void;
+    sortState(): ExcelTableSortStateModel | undefined;
+    setSortState(sortState: ExcelTableSortStateModel | undefined): void;
+    toModel(): ExcelTableModel;
+    delete(): void;
+}
+declare class ExcelTableColumn$1 {
+    private readonly model;
+    private readonly remove?;
+    constructor(model: ExcelTableColumnModel, remove?: (() => void) | undefined);
+    id(): number;
+    name(): string;
+    setName(name: string): void;
+    totalsRowLabel(): string | undefined;
+    setTotalsRowLabel(label: string | undefined): void;
+    totalsRowFunction(): string | undefined;
+    setTotalsRowFunction(fn: string | undefined): void;
+    toModel(): ExcelTableColumnModel;
+    delete(): void;
+}
+declare class ExcelTableColumnCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelTableColumnModel[]);
+    items(): ExcelTableColumn$1[];
+    getItem(nameOrId: string | number): ExcelTableColumn$1;
+    getItemOrNullObject(nameOrId: string | number): ExcelTableColumn$1 | null;
+    add(model: ExcelTableColumnModel): ExcelTableColumn$1;
+    delete(nameOrId: string | number): void;
+    deleteItem(nameOrId: string | number): void;
+    toModel(): ExcelTableColumnModel[];
+    private wrap;
+}
+declare class ExcelTableStyle$1 {
+    private readonly getModel;
+    constructor(getModel: () => ExcelTableStyleModel);
+    name(): string | undefined;
+    setName(name: string | undefined): void;
+    showFirstColumn(): boolean | undefined;
+    setShowFirstColumn(value: boolean | undefined): void;
+    showLastColumn(): boolean | undefined;
+    setShowLastColumn(value: boolean | undefined): void;
+    showRowStripes(): boolean | undefined;
+    setShowRowStripes(value: boolean | undefined): void;
+    showColumnStripes(): boolean | undefined;
+    setShowColumnStripes(value: boolean | undefined): void;
+    toModel(): ExcelTableStyleModel;
+}
+declare class ExcelTableCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelTableModel[]);
+    items(): ExcelTable$1[];
+    getItem(nameOrDisplayName: string): ExcelTable$1;
+    getItemOrNullObject(nameOrDisplayName: string): ExcelTable$1 | null;
+    add(model: ExcelTableModel): ExcelTable$1;
+    delete(nameOrDisplayName: string): void;
+    toModel(): ExcelTableModel[];
+    private wrap;
+}
+declare class ExcelHyperlink$1 {
+    private readonly model;
+    private readonly remove?;
+    constructor(model: ExcelHyperlinkModel, remove?: (() => void) | undefined);
+    ref(): string;
+    setRef(ref: string): void;
+    target(): string | undefined;
+    targetMode(): string | undefined;
+    display(): string | undefined;
+    setDisplay(display: string | undefined): void;
+    setLocation(location: string | undefined): void;
+    toModel(): ExcelHyperlinkModel;
+    delete(): void;
+}
+declare class ExcelHyperlinkCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelHyperlinkModel[]);
+    items(): ExcelHyperlink$1[];
+    add(model: ExcelHyperlinkModel): ExcelHyperlink$1;
+    getItem(ref: string): ExcelHyperlink$1;
+    getItemOrNullObject(ref: string): ExcelHyperlink$1 | null;
+    delete(ref: string): void;
+    toModel(): ExcelHyperlinkModel[];
+    private wrap;
+}
+declare class ExcelDataValidation$1 {
+    private readonly model;
+    private readonly remove?;
+    constructor(model: ExcelDataValidationModel, remove?: (() => void) | undefined);
+    rangeAddress(): string | undefined;
+    setRange(address: string): void;
+    type(): string | undefined;
+    setType(type: string | undefined): void;
+    operator(): string | undefined;
+    setOperator(operator: string | undefined): void;
+    allowBlank(): boolean | undefined;
+    setAllowBlank(value: boolean | undefined): void;
+    showDropDown(): boolean | undefined;
+    setShowDropDown(value: boolean | undefined): void;
+    showInputMessage(): boolean | undefined;
+    setShowInputMessage(value: boolean | undefined): void;
+    showErrorMessage(): boolean | undefined;
+    setShowErrorMessage(value: boolean | undefined): void;
+    errorStyle(): string | undefined;
+    setErrorStyle(style: string | undefined): void;
+    errorTitle(): string | undefined;
+    error(): string | undefined;
+    setError(title: string | undefined, message: string | undefined): void;
+    promptTitle(): string | undefined;
+    prompt(): string | undefined;
+    setPrompt(title: string | undefined, message: string | undefined): void;
+    formula1(): string | undefined;
+    setFormula1(formula: string | undefined): void;
+    formula2(): string | undefined;
+    setFormula2(formula: string | undefined): void;
+    toModel(): ExcelDataValidationModel;
+    delete(): void;
+}
+declare class ExcelDataValidationCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelDataValidationModel[]);
+    items(): ExcelDataValidation$1[];
+    add(model: ExcelDataValidationModel): ExcelDataValidation$1;
+    getItem(rangeAddress: string): ExcelDataValidation$1;
+    getItemOrNullObject(rangeAddress: string): ExcelDataValidation$1 | null;
+    delete(rangeAddress: string): void;
+    toModel(): ExcelDataValidationModel[];
+    private wrap;
+}
+declare class ExcelConditionalFormat$1 {
+    private readonly model;
+    private readonly remove?;
+    readonly rules: ExcelConditionalFormatRuleCollection$1;
+    constructor(model: ExcelConditionalFormatModel, remove?: (() => void) | undefined);
+    rangeAddress(): string | undefined;
+    setRange(address: string): void;
+    toModel(): ExcelConditionalFormatModel;
+    delete(): void;
+}
+declare class ExcelConditionalFormatRule$1 {
+    private readonly model;
+    private readonly remove?;
+    constructor(model: ExcelConditionalFormatRuleModel, remove?: (() => void) | undefined);
+    type(): string | undefined;
+    setType(type: string | undefined): void;
+    priority(): number | undefined;
+    setPriority(priority: number | undefined): void;
+    operator(): string | undefined;
+    setOperator(operator: string | undefined): void;
+    stopIfTrue(): boolean | undefined;
+    setStopIfTrue(value: boolean | undefined): void;
+    formulas(): string[];
+    setFormula(index: number, formula: string): void;
+    addFormula(formula: string): void;
+    deleteFormula(index: number): void;
+    toModel(): ExcelConditionalFormatRuleModel;
+    delete(): void;
+}
+declare class ExcelConditionalFormatRuleCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelConditionalFormatRuleModel[]);
+    items(): ExcelConditionalFormatRule$1[];
+    getItem(index: number): ExcelConditionalFormatRule$1;
+    getItemOrNullObject(index: number): ExcelConditionalFormatRule$1 | null;
+    add(model: ExcelConditionalFormatRuleModel): ExcelConditionalFormatRule$1;
+    delete(index: number): void;
+    toModel(): ExcelConditionalFormatRuleModel[];
+    private wrap;
+}
+declare class ExcelConditionalFormatCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelConditionalFormatModel[]);
+    items(): ExcelConditionalFormat$1[];
+    add(model: ExcelConditionalFormatModel): ExcelConditionalFormat$1;
+    getItem(rangeAddress: string): ExcelConditionalFormat$1;
+    getItemOrNullObject(rangeAddress: string): ExcelConditionalFormat$1 | null;
+    delete(rangeAddress: string): void;
+    toModel(): ExcelConditionalFormatModel[];
+    private wrap;
+}
+declare class ExcelComment$1 {
+    private readonly model;
+    private readonly remove?;
+    constructor(model: ExcelCommentModel, remove?: (() => void) | undefined);
+    ref(): string;
+    setRef(ref: string): void;
+    text(): string;
+    setText(text: string): void;
+    toModel(): ExcelCommentModel;
+    delete(): void;
+}
+declare class ExcelCommentCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelCommentModel[]);
+    items(): ExcelComment$1[];
+    add(model: ExcelCommentModel): ExcelComment$1;
+    getItem(ref: string): ExcelComment$1;
+    getItemOrNullObject(ref: string): ExcelComment$1 | null;
+    delete(ref: string): void;
+    toModel(): ExcelCommentModel[];
+    private wrap;
+}
+declare class ExcelThreadedComment$1 {
+    private readonly model;
+    private readonly deleteSelf?;
+    constructor(model: ExcelThreadedCommentModel, deleteSelf?: (() => void) | undefined);
+    ref(): string;
+    setRef(ref: string): void;
+    text(): string;
+    setText(text: string): void;
+    delete(): void;
+    toModel(): ExcelThreadedCommentModel;
+}
+declare class ExcelThreadedCommentCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelThreadedCommentModel[]);
+    items(): ExcelThreadedComment$1[];
+    getItem(ref: string): ExcelThreadedComment$1;
+    getItemOrNullObject(ref: string): ExcelThreadedComment$1 | null;
+    delete(ref: string): void;
+    toModel(): ExcelThreadedCommentModel[];
+    private wrap;
+}
+declare class ExcelDrawingCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelDrawingModel[]);
+    items(): ExcelDrawing$1[];
+    toModel(): ExcelDrawingModel[];
+}
+declare class ExcelDrawing$1 {
+    private readonly model;
+    readonly anchors: ExcelDrawingAnchorCollection$1;
+    constructor(model: ExcelDrawingModel);
+    relationshipId(): string | undefined;
+    path(): string | undefined;
+    toModel(): ExcelDrawingModel;
+}
+declare class ExcelDrawingAnchorCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelDrawingAnchorModel[]);
+    items(): ExcelDrawingAnchor$1[];
+    getItem(index: number): ExcelDrawingAnchor$1;
+    getItemOrNullObject(index: number): ExcelDrawingAnchor$1 | null;
+    toModel(): ExcelDrawingAnchorModel[];
+}
+declare class ExcelDrawingAnchor$1 {
+    private readonly model;
+    readonly from: ExcelDrawingMarker$1;
+    readonly to: ExcelDrawingMarker$1;
+    constructor(model: ExcelDrawingAnchorModel);
+    kind(): ExcelDrawingAnchorModel['kind'];
+    object(): ExcelDrawingAnchorModel['object'] | undefined;
+    toModel(): ExcelDrawingAnchorModel;
+}
+declare class ExcelDrawingMarker$1 {
+    private readonly getModel;
+    constructor(getModel: () => ExcelDrawingMarkerModel);
+    row(): number | undefined;
+    setRow(row: number | undefined): void;
+    column(): number | undefined;
+    setColumn(column: number | undefined): void;
+    rowOffset(): number | undefined;
+    setRowOffset(offset: number | undefined): void;
+    columnOffset(): number | undefined;
+    setColumnOffset(offset: number | undefined): void;
+    toModel(): ExcelDrawingMarkerModel;
+}
+declare class ExcelChartCollection$1 {
+    private readonly getModels;
+    private readonly getDrawings?;
+    constructor(getModels: () => ExcelChartModel[], getDrawings?: (() => ExcelDrawingModel[]) | undefined);
+    items(): ExcelChart$1[];
+    add(options: ExcelChartAddOptions): ExcelChart$1;
+    toModel(): ExcelChartModel[];
+}
+declare class ExcelChart$1 {
+    private readonly model;
+    readonly formulaRefs: ExcelFormulaRefCollection$1;
+    constructor(model: ExcelChartModel);
+    relationshipId(): string | undefined;
+    drawingPath(): string | undefined;
+    path(): string | undefined;
+    title(): string | undefined;
+    setTitle(title: string | undefined): void;
+    toModel(): ExcelChartModel;
+}
+declare class ExcelFormulaRefCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => string[]);
+    items(): string[];
+    getItem(index: number): string | undefined;
+    setItem(index: number, formulaRef: string): void;
+    add(formulaRef: string): void;
+    delete(index: number): void;
+    toModel(): string[];
+}
+declare class ExcelImageCollection$1 {
+    private readonly getModels;
+    constructor(getModels: () => ExcelImageModel[]);
+    items(): ExcelImage$1[];
+    toModel(): ExcelImageModel[];
+}
+declare class ExcelImage$1 {
+    private readonly model;
+    constructor(model: ExcelImageModel);
+    relationshipId(): string | undefined;
+    drawingPath(): string | undefined;
+    path(): string | undefined;
+    targetMode(): string | undefined;
+    name(): string | undefined;
+    toModel(): ExcelImageModel;
+}
+declare class ExcelShapeCollection$1 {
+    private readonly getDrawings;
+    constructor(getDrawings: () => ExcelDrawingModel[]);
+    items(): ExcelShape$1[];
+    getItem(name: string): ExcelShape$1;
+    getItemOrNullObject(name: string): ExcelShape$1 | null;
+    toModel(): ExcelShapeModel[];
+    private getShapeEntries;
+}
+declare class ExcelShape$1 {
+    private readonly entry;
+    readonly anchor: ExcelDrawingAnchor$1;
+    constructor(entry: ExcelShapeEntry);
+    drawingPath(): string | undefined;
+    name(): string | undefined;
+    setName(name: string | undefined): void;
+    toModel(): ExcelShapeModel;
+}
+interface ExcelShapeEntry {
+    drawing: ExcelDrawingModel;
+    anchor: ExcelDrawingAnchorModel;
+}
+
+declare class ExcelWorksheet$1 {
+    readonly hyperlinks: ExcelHyperlinkCollection$1;
+    readonly tables: ExcelTableCollection$1;
+    readonly dataValidations: ExcelDataValidationCollection$1;
+    readonly conditionalFormats: ExcelConditionalFormatCollection$1;
+    readonly comments: ExcelCommentCollection$1;
+    readonly threadedComments: ExcelThreadedCommentCollection$1;
+    readonly drawings: ExcelDrawingCollection$1;
+    readonly charts: ExcelChartCollection$1;
+    readonly images: ExcelImageCollection$1;
+    readonly shapes: ExcelShapeCollection$1;
+    private readonly model;
+    private readonly workbook?;
+    private readonly recordMutation?;
+    constructor(model: ExcelSheetModel, workbook?: ExcelWorkbookModel, recordMutation?: ExcelMutationRecorder);
+    id(): string;
+    name(): string;
+    rename(name: string): void;
+    insertRows(rowIndex: number, count?: number): void;
+    deleteRows(rowIndex: number, count?: number): void;
+    insertColumns(columnIndex: number, count?: number): void;
+    deleteColumns(columnIndex: number, count?: number): void;
+    visibility(): string | undefined;
+    setVisibility(visibility: string | undefined): void;
+    path(): string | undefined;
+    dimension(): string | undefined;
+    getRange(address: string): ExcelRange$1;
+    getCell(address: string): ExcelCell$1;
+    getUsedRange(): ExcelRange$1 | null;
+    cells(): {
+        address: string;
+        row: number;
+        column: number;
+        kind: ExcelCellKind;
+        value: ExcelCellValue;
+        rawValue?: string;
+        formula?: string;
+        dataType?: string;
+        styleId?: number;
+        sharedStringIndex?: number;
+    }[];
+    sheetViews(): ExcelSheetViewModel[];
+    setSheetViews(sheetViews: ExcelSheetViewModel[]): void;
+    columns(): {
+        min: number;
+        max: number;
+        width?: number;
+        hidden?: boolean;
+        styleId?: number;
+        customWidth?: boolean;
+    }[];
+    rows(): {
+        index: number;
+        height?: number;
+        hidden?: boolean;
+        styleId?: number;
+        customHeight?: boolean;
+    }[];
+    mergedRanges(): {
+        address: string;
+    }[];
+    toModel(): ExcelSheetModel;
+    private rewriteDefinedNames;
+    private rewriteRuleFormulas;
+    private rewriteWorkbookSheetFormulas;
+    private rewriteChartFormulaRefs;
+    private rewriteRangeReferences;
+    private moveRowMetadataForInsert;
+    private moveRowMetadataForDelete;
+    private moveColumnMetadataForInsert;
+    private moveColumnMetadataForDelete;
+    private moveDrawingAnchorsForRowInsert;
+    private moveDrawingAnchorsForRowDelete;
+    private moveDrawingAnchorsForColumnInsert;
+    private moveDrawingAnchorsForColumnDelete;
+    private drawingMarkers;
+    private assertUniqueWorksheetName;
+}
+declare class ExcelWorksheetCollection$1 {
+    private readonly worksheets;
+    private readonly sheets;
+    private readonly workbook?;
+    private readonly recordMutation?;
+    constructor(sheets: ExcelSheetModel[], workbook?: ExcelWorkbookModel, recordMutation?: ExcelMutationRecorder);
+    items(): ExcelWorksheet$1[];
+    getItem(nameOrId: string): ExcelWorksheet$1;
+    getItemOrNullObject(nameOrId: string): ExcelWorksheet$1 | null;
+    add(name: string): ExcelWorksheet$1;
+    deleteItem(nameOrId: string): void;
+    move(nameOrId: string, toIndex: number): void;
+    copy(nameOrId: string, newName?: string): ExcelWorksheet$1;
+}
+
+interface ExcelLoadOptions {
+    workbookId?: string;
+}
+declare class ExcelWorkbookCore {
+    readonly workbookId: string;
+    readonly worksheets: ExcelWorksheetCollection$1;
+    readonly names: ExcelNamedItemCollection$1;
+    private readonly pkg;
+    private readonly model;
+    private readonly mutationLog;
+    private constructor();
+    static fromZip(bytes: Uint8Array | ArrayBuffer, opts?: ExcelLoadOptions): Promise<ExcelWorkbookCore>;
+    static fromPackage(pkg: Package, opts?: ExcelLoadOptions): ExcelWorkbookCore;
+    static fromModel(model: ExcelWorkbookModel, opts?: ExcelLoadOptions): ExcelWorkbookCore;
+    toModel(): ExcelWorkbookModel;
+    styles(): ExcelStylesModel;
+    getMutations(): ExcelWorkbookMutation[];
+    _replaceModelForHistory(model: ExcelWorkbookModel): void;
+    clearMutations(): void;
+    getPackage(): Package;
+    toZip(): Promise<Uint8Array>;
+}
+
+type ExcelAggregateOperation = 'sum' | 'count' | 'average' | 'min' | 'max';
+type ExcelAggregateBucket = 'none' | 'year' | 'quarter' | 'month' | 'day';
+interface ExcelAggregateSource {
+    sheetName: string;
+    address?: string;
+    tableName?: string;
+    header?: 'firstRow' | 'none';
+}
+interface ExcelAggregateGroupBy {
+    column: string;
+    bucket?: ExcelAggregateBucket;
+    name?: string;
+}
+interface ExcelAggregateMetric {
+    column?: string;
+    op: ExcelAggregateOperation;
+    name?: string;
+}
+interface ExcelAggregateTableOptions {
+    source: ExcelAggregateSource;
+    groupBy: ExcelAggregateGroupBy[];
+    metrics: ExcelAggregateMetric[];
+    sort?: 'asc' | 'desc' | 'none';
+}
+interface ExcelAggregateResultRow {
+    key: ExcelCellValue[];
+    values: ExcelCellValue[];
+    rowCount: number;
+}
+interface ExcelAggregateTableResult {
+    ok: true;
+    sheetName: string;
+    sourceAddress: string;
+    headers: string[];
+    rows: ExcelAggregateResultRow[];
+    values: ExcelCellValue[][];
+    inputRowCount: number;
+    outputRowCount: number;
+}
+declare function aggregateExcelTable(workbook: ExcelWorkbookModel, options: ExcelAggregateTableOptions): ExcelAggregateTableResult;
+
+type ExcelTransactionSource = 'user' | 'agent' | 'import' | 'system';
+interface ExcelTransactionGroupMetadata {
+    actor?: string;
+    description?: string;
+    agentRunId?: string;
+    agentStepId?: string;
+    agentActionId?: string;
+    mergeKey?: string;
+    [key: string]: unknown;
+}
+interface ExcelTransactionGroupOptions {
+    source: ExcelTransactionSource;
+    label: string;
+    id?: string;
+    mergeKey?: string;
+    mergeWindowMs?: number;
+    metadata?: ExcelTransactionGroupMetadata;
+}
+interface ExcelAgentTransactionGroupOptions {
+    label: string;
+    id?: string;
+    actor?: string;
+    description?: string;
+    agentRunId?: string;
+    agentStepId?: string;
+    agentActionId?: string;
+    mergeKey?: string;
+    mergeWindowMs?: number;
+    metadata?: ExcelTransactionGroupMetadata;
+}
+interface ExcelTransactionGroup {
+    id: string;
+    source: ExcelTransactionSource;
+    label: string;
+    metadata?: ExcelTransactionGroupMetadata;
+    mergeKey?: string;
+    mergeWindowMs?: number;
+    workbookId: string;
+    transactions: ExcelTransaction[];
+    affectedSheets: string[];
+    affectedRanges: string[];
+    createdAt: number;
+    committedAt: number;
+}
+interface ExcelTransaction {
+    id: string;
+    label: string;
+    forward: ExcelPatch[];
+    inverse: ExcelPatch[];
+}
+type ExcelPatch = ExcelRangeCellsPatch | ExcelRangeFormatPatch | ExcelMergedRangesPatch | ExcelSheetViewsPatch | ExcelWorkbookSheetsPatch | ExcelSheetModelPatch | ExcelSheetRowsInsertPatch | ExcelSheetRowsDeletePatch | ExcelSheetRowsRestorePatch | ExcelSheetRowsRestoreDeltaPatch | ExcelSheetColumnsInsertPatch | ExcelSheetColumnsDeletePatch | ExcelSheetColumnsRestorePatch | ExcelSheetColumnsRestoreDeltaPatch | ExcelRowHeightPatch | ExcelColumnWidthPatch | ExcelSnapshotPatch;
+interface ExcelRangeCellsPatch {
+    kind: 'range.cells';
+    sheetName: string;
+    address: string;
+    cells: ExcelCellModel[];
+}
+interface ExcelRangeFormatPatch {
+    kind: 'range.format';
+    sheetName: string;
+    address: string;
+    formats: ExcelCellFormatSnapshot[];
+}
+interface ExcelCellFormatSnapshot {
+    row: number;
+    column: number;
+    styleId: number | undefined;
+}
+interface ExcelMergedRangesPatch {
+    kind: 'sheet.mergedRanges';
+    sheetName: string;
+    address: string;
+    mergedRanges: string[];
+}
+interface ExcelSheetViewsPatch {
+    kind: 'sheet.views';
+    sheetName: string;
+    address: string;
+    sheetViews: ExcelSheetViewModel[];
+}
+interface ExcelWorkbookSheetsPatch {
+    kind: 'workbook.sheets';
+    sheetName: string;
+    address: string;
+    sheets: ExcelSheetModel[];
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelSheetModelPatch {
+    kind: 'sheet.model';
+    sheetName: string;
+    address: string;
+    sheet: ExcelSheetModel;
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelSheetRowsInsertPatch {
+    kind: 'sheet.rows.insert';
+    sheetName: string;
+    address: string;
+    rowIndex: number;
+    count: number;
+}
+interface ExcelSheetRowsDeletePatch {
+    kind: 'sheet.rows.delete';
+    sheetName: string;
+    address: string;
+    rowIndex: number;
+    count: number;
+}
+interface ExcelSheetRowsRestorePatch {
+    kind: 'sheet.rows.restore';
+    sheetName: string;
+    address: string;
+    rowIndex: number;
+    count: number;
+    sheet: ExcelSheetModel;
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelSheetRowsRestoreDeltaPatch {
+    kind: 'sheet.rows.restoreDelta';
+    sheetName: string;
+    address: string;
+    rowIndex: number;
+    count: number;
+    cells: ExcelCellModel[];
+    rows: ExcelRowModel[];
+    mergedRanges: ExcelMergedRangeModel[];
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelSheetColumnsInsertPatch {
+    kind: 'sheet.columns.insert';
+    sheetName: string;
+    address: string;
+    columnIndex: number;
+    count: number;
+}
+interface ExcelSheetColumnsDeletePatch {
+    kind: 'sheet.columns.delete';
+    sheetName: string;
+    address: string;
+    columnIndex: number;
+    count: number;
+}
+interface ExcelSheetColumnsRestorePatch {
+    kind: 'sheet.columns.restore';
+    sheetName: string;
+    address: string;
+    columnIndex: number;
+    count: number;
+    sheet: ExcelSheetModel;
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelSheetColumnsRestoreDeltaPatch {
+    kind: 'sheet.columns.restoreDelta';
+    sheetName: string;
+    address: string;
+    columnIndex: number;
+    count: number;
+    cells: ExcelCellModel[];
+    columns: ExcelColumnModel[];
+    mergedRanges: ExcelMergedRangeModel[];
+    definedNames: ExcelDefinedNameModel[];
+}
+interface ExcelRowHeightPatch {
+    kind: 'row.height';
+    sheetName: string;
+    row: number;
+    height: number | undefined;
+}
+interface ExcelColumnWidthPatch {
+    kind: 'column.width';
+    sheetName: string;
+    column: number;
+    width: number | undefined;
+}
+interface ExcelSnapshotPatch {
+    kind: 'snapshot';
+    reason: string;
+    beforeModel: ExcelWorkbookModel;
+    afterModel: ExcelWorkbookModel;
+}
+interface ExcelHistoryApplyResult {
+    group: ExcelTransactionGroup;
+    affectedSheets: string[];
+    affectedRanges: string[];
+    summary: ExcelTransactionGroupSummary;
+}
+interface ExcelPatchSummary {
+    kind: ExcelPatch['kind'];
+    direction: 'forward' | 'inverse';
+    sheetName: string;
+    address: string;
+    snapshot: boolean;
+    structural: boolean;
+    restoreStrategy?: 'delta' | 'full';
+}
+interface ExcelTransactionSummary {
+    id: string;
+    label: string;
+    forwardPatchKinds: ExcelPatch['kind'][];
+    inversePatchKinds: ExcelPatch['kind'][];
+    patches: ExcelPatchSummary[];
+}
+interface ExcelTransactionGroupSummary {
+    id: string;
+    source: ExcelTransactionSource;
+    label: string;
+    metadata?: ExcelTransactionGroupMetadata;
+    mergeKey?: string;
+    workbookId: string;
+    transactionCount: number;
+    patchCount: number;
+    forwardPatchKinds: ExcelPatch['kind'][];
+    inversePatchKinds: ExcelPatch['kind'][];
+    affectedSheets: string[];
+    affectedRanges: string[];
+    containsSnapshot: boolean;
+    containsStructuralPatch: boolean;
+    restoreStrategies: ('delta' | 'full')[];
+    transactions: ExcelTransactionSummary[];
+    createdAt: number;
+    committedAt: number;
+}
+declare class ExcelWorkbookHistory {
+    private readonly workbook;
+    private readonly options;
+    private readonly undoStack;
+    private readonly redoStack;
+    constructor(workbook: ExcelWorkbook, options?: {
+        limit?: number;
+    });
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undoGroups(): ExcelTransactionGroup[];
+    redoGroups(): ExcelTransactionGroup[];
+    runGroup(options: ExcelTransactionGroupOptions, run: (transaction: ExcelTransactionBuilder) => Promise<void>): Promise<ExcelHistoryApplyResult | null>;
+    runAgentGroup(options: ExcelAgentTransactionGroupOptions, run: (transaction: ExcelTransactionBuilder) => Promise<void>): Promise<ExcelHistoryApplyResult | null>;
+    undo(): Promise<ExcelHistoryApplyResult | null>;
+    redo(): Promise<ExcelHistoryApplyResult | null>;
+    clear(): void;
+    private pushUndo;
+}
+interface ExcelTransactionBuilder {
+    setCellValue(sheetName: string, address: string, value: ExcelCellValue): Promise<void>;
+    setCellFormula(sheetName: string, address: string, formula: string | null): Promise<void>;
+    setRangeValues(sheetName: string, address: string, values: ExcelCellValue[][]): Promise<void>;
+    clearRange(sheetName: string, address: string): Promise<void>;
+    setRangeBold(sheetName: string, address: string, value: boolean | undefined): Promise<void>;
+    setRangeItalic(sheetName: string, address: string, value: boolean | undefined): Promise<void>;
+    setRangeUnderline(sheetName: string, address: string, value: boolean | undefined): Promise<void>;
+    setRangeFontColor(sheetName: string, address: string, color: ExcelColorModel | undefined): Promise<void>;
+    setRangeFillColor(sheetName: string, address: string, color: ExcelColorModel | undefined): Promise<void>;
+    setRangeHorizontalAlign(sheetName: string, address: string, horizontal: 'left' | 'center' | 'right' | undefined): Promise<void>;
+    setRangeVerticalAlign(sheetName: string, address: string, vertical: 'top' | 'center' | 'bottom' | undefined): Promise<void>;
+    setRangeNumberFormat(sheetName: string, address: string, code: string | undefined): Promise<void>;
+    clearRangeFormat(sheetName: string, address: string): Promise<void>;
+    setRangeStyleId(sheetName: string, address: string, styleId: number | undefined): Promise<void>;
+    setSheetViews(sheetName: string, sheetViews: ExcelSheetViewModel[]): Promise<void>;
+    addSheet(name: string): Promise<void>;
+    deleteSheet(nameOrId: string): Promise<void>;
+    renameSheet(nameOrId: string, name: string): Promise<void>;
+    copySheet(nameOrId: string, newName: string): Promise<void>;
+    moveSheet(nameOrId: string, toIndex: number): Promise<void>;
+    mergeRange(sheetName: string, address: string): Promise<void>;
+    unmergeRange(sheetName: string, address: string): Promise<void>;
+    insertRows(sheetName: string, rowIndex: number, count?: number): Promise<void>;
+    deleteRows(sheetName: string, rowIndex: number, count?: number): Promise<void>;
+    insertColumns(sheetName: string, columnIndex: number, count?: number): Promise<void>;
+    deleteColumns(sheetName: string, columnIndex: number, count?: number): Promise<void>;
+    setRangeBorder(sheetName: string, address: string, border: ExcelBorderModel): Promise<void>;
+    setRowHeight(sheetName: string, row: number, height: number | undefined): Promise<void>;
+    setColumnWidth(sheetName: string, column: number, width: number | undefined): Promise<void>;
+    runSnapshot(label: string, reason: string, mutate: () => Promise<void>): Promise<void>;
+}
+declare function applyExcelPatch(workbook: ExcelWorkbook, patch: ExcelPatch): Promise<void>;
+declare function summarizeExcelTransactionGroup(group: ExcelTransactionGroup): ExcelTransactionGroupSummary;
+
+interface ExcelWorkerPortLike {
+    postMessage(data: unknown, transferList?: unknown[]): void;
+    onMessage(listener: (data: unknown) => void): void;
+    onError(listener: (err: unknown) => void): void;
+    terminate(): Promise<void>;
+}
+
+type ExcelRuntimeMode = 'auto' | 'worker' | 'inline';
+type ExcelModeSource = 'explicit-inline' | 'explicit-worker' | 'auto/node-with-worker-config' | 'auto/node-no-worker-config' | 'auto/browser-factory' | 'auto/fallback';
+interface ExcelModeDecision {
+    mode: 'worker' | 'inline';
+    source: ExcelModeSource;
+}
+type ExcelWorkerFactory = () => ExcelWorkerPortLike | Promise<ExcelWorkerPortLike>;
+interface ExcelWorkbookLoadOptions extends ExcelLoadOptions {
+    mode?: ExcelRuntimeMode;
+    onModeResolved?: (decision: ExcelModeDecision, workbookId: string) => void;
+}
+declare class ExcelWorkbook {
+    readonly workbookId: string;
+    readonly mode: 'worker' | 'inline';
+    readonly modeSource: ExcelModeSource;
+    readonly worksheets: ExcelWorksheetCollection;
+    readonly names: ExcelNamedItemCollection;
+    private readonly inlineWorkbook?;
+    private readonly workerTransport?;
+    private readonly workbookHistory;
+    private disposed;
+    private constructor();
+    static fromZip(bytes: Uint8Array | ArrayBuffer, opts?: ExcelWorkbookLoadOptions): Promise<ExcelWorkbook>;
+    static fromModel(model: ExcelWorkbookModel, opts?: ExcelWorkbookLoadOptions): Promise<ExcelWorkbook>;
+    static fromPackage(pkg: Parameters<typeof ExcelWorkbookCore.fromPackage>[0], opts?: ExcelWorkbookLoadOptions): ExcelWorkbook;
+    static setDefaultMode(mode: ExcelRuntimeMode): void;
+    static setWorkerFactory(factory: ExcelWorkerFactory | undefined): void;
+    static setWorkerBundleUrl(url: string | URL | undefined): void;
+    static detectMode(): 'worker' | 'inline';
+    static detectModeDecision(mode?: ExcelRuntimeMode): ExcelModeDecision;
+    static _resetDefaults(): void;
+    executeCode<T = unknown>(code: string, args?: Record<string, unknown>, timeoutMs?: number, signal?: AbortSignal): Promise<T>;
+    toModel(): Promise<ExcelWorkbookModel>;
+    getMutations(): Promise<ExcelWorkbookMutation[]>;
+    clearMutations(): Promise<void>;
+    history(): ExcelWorkbookHistory;
+    aggregateTable(options: ExcelAggregateTableOptions): Promise<ExcelAggregateTableResult>;
+    toZip(): Promise<Uint8Array>;
+    dispose(): Promise<void>;
+    private static hasWorkerConfig;
+    private static createWorkerTransport;
+    private assertNotDisposed;
+}
+
+type ExcelRuntimeLoadOptions = ExcelWorkbookLoadOptions;
+declare class ExcelWorksheetCollection {
+    private readonly workbook;
+    constructor(workbook: ExcelWorkbook);
+    items(): Promise<ExcelWorksheet[]>;
+    getItem(nameOrId: string): ExcelWorksheet;
+    getItemOrNullObject(nameOrId: string): Promise<ExcelWorksheet | null>;
+    add(name: string): Promise<ExcelWorksheet>;
+    deleteItem(nameOrId: string): Promise<void>;
+    move(nameOrId: string, toIndex: number): Promise<void>;
+    copy(nameOrId: string, newName?: string): Promise<ExcelWorksheet>;
+}
+declare class ExcelWorksheet {
+    private readonly workbook;
+    private readonly nameOrId;
+    private readonly knownId?;
+    readonly tables: ExcelTableCollection;
+    readonly hyperlinks: ExcelHyperlinkCollection;
+    readonly comments: ExcelCommentCollection;
+    readonly threadedComments: ExcelThreadedCommentCollection;
+    readonly dataValidations: ExcelDataValidationCollection;
+    readonly conditionalFormats: ExcelConditionalFormatCollection;
+    readonly drawings: ExcelDrawingCollection;
+    readonly charts: ExcelChartCollection;
+    readonly images: ExcelImageCollection;
+    readonly shapes: ExcelShapeCollection;
+    constructor(workbook: ExcelWorkbook, nameOrId: string, knownId?: string | undefined);
+    id(): Promise<string>;
+    name(): Promise<string>;
+    rename(name: string): Promise<void>;
+    visibility(): Promise<string | undefined>;
+    setVisibility(visibility: string | undefined): Promise<void>;
+    path(): Promise<string | undefined>;
+    dimension(): Promise<string | undefined>;
+    getRange(address: string): ExcelRange;
+    getCell(address: string): ExcelCell;
+    getUsedRange(): Promise<ExcelRange | null>;
+    cells(): Promise<ExcelCellModel[]>;
+    sheetViews(): Promise<ExcelSheetViewModel[]>;
+    setSheetViews(sheetViews: ExcelSheetViewModel[]): Promise<void>;
+    columns(): Promise<ExcelColumnModel[]>;
+    rows(): Promise<ExcelRowModel[]>;
+    mergedRanges(): Promise<ExcelMergedRangeModel[]>;
+    insertRows(rowIndex: number, count?: number): Promise<void>;
+    deleteRows(rowIndex: number, count?: number): Promise<void>;
+    insertColumns(columnIndex: number, count?: number): Promise<void>;
+    deleteColumns(columnIndex: number, count?: number): Promise<void>;
+    toModel(): Promise<ExcelSheetModel>;
+    private run;
+}
+declare class ExcelRange {
+    protected readonly workbook: ExcelWorkbook;
+    protected readonly sheetNameOrId: string;
+    protected readonly rangeAddress: string;
+    readonly format: ExcelRangeFormat;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, rangeAddress: string);
+    address(): Promise<string>;
+    rowIndex(): Promise<number>;
+    columnIndex(): Promise<number>;
+    rowCount(): Promise<number>;
+    columnCount(): Promise<number>;
+    values(): Promise<ExcelCellValue[][]>;
+    formulas(): Promise<(string | null)[][]>;
+    text(): Promise<string[][]>;
+    valueTypes(): Promise<ExcelCellKind[][]>;
+    rawValues(): Promise<(string | null)[][]>;
+    styleIds(): Promise<(number | undefined)[][]>;
+    setStyleId(styleId: number | undefined): Promise<void>;
+    rowHeights(): Promise<Array<number | undefined>>;
+    setRowHeight(height: number | undefined): Promise<void>;
+    columnWidths(): Promise<Array<number | undefined>>;
+    setColumnWidth(width: number | undefined): Promise<void>;
+    merge(): Promise<void>;
+    unmerge(): Promise<void>;
+    setValues(values: ExcelCellValue[][]): Promise<void>;
+    setFormulas(formulas: (string | null)[][]): Promise<void>;
+    clear(): Promise<void>;
+    getCell(rowOffset: number, columnOffset: number): ExcelCell;
+    getRow(rowOffset: number): ExcelRange;
+    getColumn(columnOffset: number): ExcelRange;
+    resize(rowCount: number, columnCount: number): ExcelRange;
+    offset(rowOffset: number, columnOffset: number, rowCount?: number, columnCount?: number): ExcelRange;
+    slice(rowOffset: number, columnOffset: number, rowCount: number, columnCount: number): ExcelRange;
+    toModel(): Promise<ExcelCellModel[]>;
+    runFormat<T>(code: string, args?: Record<string, unknown>): Promise<T>;
+    protected run<T>(code: string, args?: Record<string, unknown>): Promise<T>;
+}
+declare class ExcelCell {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly cellAddressOrRangeAddress;
+    private readonly rowOffset?;
+    private readonly columnOffset?;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, cellAddressOrRangeAddress: string, rowOffset?: number | undefined, columnOffset?: number | undefined);
+    address(): Promise<string>;
+    value(): Promise<ExcelCellValue>;
+    formula(): Promise<string | null>;
+    text(): Promise<string>;
+    valueType(): Promise<ExcelCellKind>;
+    rawValue(): Promise<string | null>;
+    styleId(): Promise<number | undefined>;
+    setStyleId(styleId: number | undefined): Promise<void>;
+    setValue(value: ExcelCellValue): Promise<void>;
+    setFormula(formula: string | null): Promise<void>;
+    clear(): Promise<void>;
+    toRange(): ExcelRange;
+    toModel(): Promise<ExcelCellModel | null>;
+    private run;
+}
+declare class ExcelRangeFormat {
+    private readonly range;
+    readonly font: ExcelRangeFontFormat;
+    readonly fill: ExcelRangeFillFormat;
+    readonly border: ExcelRangeBorderFormat;
+    readonly alignment: ExcelRangeAlignmentFormat;
+    constructor(range: ExcelRange);
+    numberFormatCode(): Promise<string | undefined>;
+    setNumberFormatCode(code: string | undefined): Promise<void>;
+}
+declare class ExcelRangeFontFormat {
+    private readonly range;
+    constructor(range: ExcelRange);
+    value(): Promise<ExcelFontModel>;
+    setValue(font: ExcelFontModel): Promise<void>;
+    bold(): Promise<boolean | undefined>;
+    setBold(value: boolean | undefined): Promise<void>;
+    italic(): Promise<boolean | undefined>;
+    setItalic(value: boolean | undefined): Promise<void>;
+    underline(): Promise<boolean | undefined>;
+    setUnderline(value: boolean | undefined): Promise<void>;
+    color(): Promise<ExcelFontModel['color']>;
+    setColor(color: ExcelFontModel['color']): Promise<void>;
+    size(): Promise<number | undefined>;
+    setSize(size: number | undefined): Promise<void>;
+    name(): Promise<string | undefined>;
+    setName(name: string | undefined): Promise<void>;
+}
+declare class ExcelRangeFillFormat {
+    private readonly range;
+    constructor(range: ExcelRange);
+    value(): Promise<ExcelFillModel>;
+    setValue(fill: ExcelFillModel): Promise<void>;
+    patternType(): Promise<string | undefined>;
+    setPatternType(patternType: string | undefined): Promise<void>;
+    foregroundColor(): Promise<ExcelFillModel['foregroundColor']>;
+    setForegroundColor(color: ExcelFillModel['foregroundColor']): Promise<void>;
+    backgroundColor(): Promise<ExcelFillModel['backgroundColor']>;
+    setBackgroundColor(color: ExcelFillModel['backgroundColor']): Promise<void>;
+}
+declare class ExcelRangeBorderFormat {
+    private readonly range;
+    constructor(range: ExcelRange);
+    value(): Promise<ExcelBorderModel>;
+    setValue(border: ExcelBorderModel): Promise<void>;
+    setLeft(side: ExcelBorderModel['left']): Promise<void>;
+    setRight(side: ExcelBorderModel['right']): Promise<void>;
+    setTop(side: ExcelBorderModel['top']): Promise<void>;
+    setBottom(side: ExcelBorderModel['bottom']): Promise<void>;
+}
+declare class ExcelRangeAlignmentFormat {
+    private readonly range;
+    constructor(range: ExcelRange);
+    value(): Promise<ExcelAlignmentModel | undefined>;
+    setValue(alignment: ExcelAlignmentModel | undefined): Promise<void>;
+    setHorizontal(horizontal: string | undefined): Promise<void>;
+    setVertical(vertical: string | undefined): Promise<void>;
+    setWrapText(wrapText: boolean | undefined): Promise<void>;
+}
+declare class ExcelTableCollection {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+    items(): Promise<ExcelTable[]>;
+    getItem(nameOrDisplayName: string): ExcelTable;
+    getItemOrNullObject(nameOrDisplayName: string): Promise<ExcelTable | null>;
+    add(model: ExcelTableModel): Promise<ExcelTable>;
+    delete(nameOrDisplayName: string): Promise<void>;
+    toModel(): Promise<ExcelTableModel[]>;
+}
+declare class ExcelTable {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly nameOrDisplayName;
+    readonly columns: ExcelTableColumnCollection;
+    readonly style: ExcelTableStyle;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, nameOrDisplayName: string);
+    id(): Promise<number | undefined>;
+    name(): Promise<string | undefined>;
+    displayName(): Promise<string | undefined>;
+    setName(name: string): Promise<void>;
+    setDisplayName(displayName: string): Promise<void>;
+    rangeAddress(): Promise<string | undefined>;
+    setRange(address: string): Promise<void>;
+    resize(address: string): Promise<void>;
+    autoFilterRangeAddress(): Promise<string | undefined>;
+    setAutoFilterRange(address: string | undefined): Promise<void>;
+    headerRowCount(): Promise<number | undefined>;
+    setHeaderRowCount(count: number | undefined): Promise<void>;
+    totalsRowCount(): Promise<number | undefined>;
+    setTotalsRowCount(count: number | undefined): Promise<void>;
+    totalsRowShown(): Promise<boolean | undefined>;
+    setTotalsRowShown(value: boolean | undefined): Promise<void>;
+    autoFilter(): Promise<ExcelTableAutoFilterModel | undefined>;
+    setAutoFilter(model: ExcelTableAutoFilterModel | undefined): Promise<void>;
+    sortState(): Promise<ExcelTableSortStateModel | undefined>;
+    setSortState(sortState: ExcelTableSortStateModel | undefined): Promise<void>;
+    toModel(): Promise<ExcelTableModel>;
+    delete(): Promise<void>;
+    private run;
+}
+declare class ExcelTableColumnCollection {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly tableNameOrDisplayName;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, tableNameOrDisplayName: string);
+    items(): Promise<ExcelTableColumn[]>;
+    getItem(nameOrId: string | number): ExcelTableColumn;
+    add(model: ExcelTableModel['columns'][number]): Promise<ExcelTableColumn>;
+    delete(nameOrId: string | number): Promise<void>;
+    deleteItem(nameOrId: string | number): Promise<void>;
+    toModel(): Promise<ExcelTableModel['columns']>;
+    private run;
+}
+declare class ExcelTableColumn {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly tableNameOrDisplayName;
+    private readonly nameOrId;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, tableNameOrDisplayName: string, nameOrId: string | number);
+    id(): Promise<number>;
+    name(): Promise<string>;
+    setName(name: string): Promise<void>;
+    totalsRowLabel(): Promise<string | undefined>;
+    setTotalsRowLabel(label: string | undefined): Promise<void>;
+    totalsRowFunction(): Promise<string | undefined>;
+    setTotalsRowFunction(fn: string | undefined): Promise<void>;
+    toModel(): Promise<ExcelTableModel['columns'][number]>;
+    delete(): Promise<void>;
+    private run;
+}
+declare class ExcelTableStyle {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly tableNameOrDisplayName;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, tableNameOrDisplayName: string);
+    toModel(): Promise<ExcelTableModel['style']>;
+    name(): Promise<string | undefined>;
+    setName(name: string | undefined): Promise<void>;
+    showFirstColumn(): Promise<boolean | undefined>;
+    setShowFirstColumn(value: boolean | undefined): Promise<void>;
+    showLastColumn(): Promise<boolean | undefined>;
+    setShowLastColumn(value: boolean | undefined): Promise<void>;
+    showRowStripes(): Promise<boolean | undefined>;
+    setShowRowStripes(value: boolean | undefined): Promise<void>;
+    showColumnStripes(): Promise<boolean | undefined>;
+    setShowColumnStripes(value: boolean | undefined): Promise<void>;
+    private run;
+}
+declare abstract class SimpleSheetCollection<TModel, TItem> {
+    protected readonly workbook: ExcelWorkbook;
+    protected readonly sheetNameOrId: string;
+    private readonly collection;
+    private readonly wrap;
+    protected constructor(workbook: ExcelWorkbook, sheetNameOrId: string, collection: string, wrap: (workbook: ExcelWorkbook, sheetNameOrId: string, model: TModel) => TItem);
+    items(): Promise<TItem[]>;
+    getItem(key: string): TItem;
+    getItemOrNullObject(key: string): Promise<TItem | null>;
+    add(model: TModel): Promise<TItem>;
+    delete(key: string): Promise<void>;
+    toModel(): Promise<TModel[]>;
+}
+declare abstract class SimpleSheetItem<TModel> {
+    protected readonly workbook: ExcelWorkbook;
+    protected readonly sheetNameOrId: string;
+    protected key: string;
+    protected abstract readonly collection: string;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, key: string);
+    toModel(): Promise<TModel>;
+    delete(): Promise<void>;
+    protected run<T>(code: string, args?: Record<string, unknown>): Promise<T>;
+}
+declare abstract class ReadonlySheetCollection<TModel, TItem> {
+    protected readonly workbook: ExcelWorkbook;
+    protected readonly sheetNameOrId: string;
+    private readonly collection;
+    private readonly wrap;
+    protected constructor(workbook: ExcelWorkbook, sheetNameOrId: string, collection: string, wrap: (workbook: ExcelWorkbook, sheetNameOrId: string, index: number) => TItem);
+    items(): Promise<TItem[]>;
+    toModel(): Promise<TModel[]>;
+}
+declare abstract class IndexedSheetItem<TModel> {
+    protected readonly workbook: ExcelWorkbook;
+    protected readonly sheetNameOrId: string;
+    protected indexOrName: number | string;
+    protected abstract readonly collection: string;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, indexOrName: number | string);
+    toModel(): Promise<TModel>;
+    protected run<T>(code: string, args?: Record<string, unknown>): Promise<T>;
+}
+declare class ExcelHyperlinkCollection extends SimpleSheetCollection<ExcelHyperlinkModel, ExcelHyperlink> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelHyperlink extends SimpleSheetItem<ExcelHyperlinkModel> {
+    protected readonly collection = "hyperlinks";
+    ref(): Promise<string>;
+    setRef(ref: string): Promise<void>;
+    target(): Promise<string | undefined>;
+    targetMode(): Promise<string | undefined>;
+    display(): Promise<string | undefined>;
+    setDisplay(display: string | undefined): Promise<void>;
+    setLocation(location: string | undefined): Promise<void>;
+}
+declare class ExcelCommentCollection extends SimpleSheetCollection<ExcelCommentModel, ExcelComment> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelComment extends SimpleSheetItem<ExcelCommentModel> {
+    protected readonly collection = "comments";
+    ref(): Promise<string>;
+    setRef(ref: string): Promise<void>;
+    text(): Promise<string>;
+    setText(text: string): Promise<void>;
+}
+declare class ExcelThreadedCommentCollection extends SimpleSheetCollection<ExcelThreadedCommentModel, ExcelThreadedComment> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelThreadedComment extends SimpleSheetItem<ExcelThreadedCommentModel> {
+    protected readonly collection = "threadedComments";
+    ref(): Promise<string>;
+    setRef(ref: string): Promise<void>;
+    text(): Promise<string>;
+    setText(text: string): Promise<void>;
+}
+declare class ExcelDataValidationCollection extends SimpleSheetCollection<ExcelDataValidationModel, ExcelDataValidation> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelDataValidation extends SimpleSheetItem<ExcelDataValidationModel> {
+    protected readonly collection = "dataValidations";
+    rangeAddress(): Promise<string | undefined>;
+    setRange(address: string): Promise<void>;
+    type(): Promise<string | undefined>;
+    setType(type: string | undefined): Promise<void>;
+    operator(): Promise<string | undefined>;
+    setOperator(operator: string | undefined): Promise<void>;
+    allowBlank(): Promise<boolean | undefined>;
+    setAllowBlank(value: boolean | undefined): Promise<void>;
+    showDropDown(): Promise<boolean | undefined>;
+    setShowDropDown(value: boolean | undefined): Promise<void>;
+    showInputMessage(): Promise<boolean | undefined>;
+    setShowInputMessage(value: boolean | undefined): Promise<void>;
+    showErrorMessage(): Promise<boolean | undefined>;
+    setShowErrorMessage(value: boolean | undefined): Promise<void>;
+    errorStyle(): Promise<string | undefined>;
+    setErrorStyle(style: string | undefined): Promise<void>;
+    errorTitle(): Promise<string | undefined>;
+    error(): Promise<string | undefined>;
+    setError(title: string | undefined, message: string | undefined): Promise<void>;
+    promptTitle(): Promise<string | undefined>;
+    prompt(): Promise<string | undefined>;
+    setPrompt(title: string | undefined, message: string | undefined): Promise<void>;
+    formula1(): Promise<string | undefined>;
+    setFormula1(formula: string | undefined): Promise<void>;
+    formula2(): Promise<string | undefined>;
+    setFormula2(formula: string | undefined): Promise<void>;
+}
+declare class ExcelConditionalFormatCollection extends SimpleSheetCollection<ExcelConditionalFormatModel, ExcelConditionalFormat> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelConditionalFormat extends SimpleSheetItem<ExcelConditionalFormatModel> {
+    protected readonly collection = "conditionalFormats";
+    readonly rules: ExcelConditionalFormatRuleCollection;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, key: string);
+    rangeAddress(): Promise<string | undefined>;
+    setRange(address: string): Promise<void>;
+}
+declare class ExcelConditionalFormatRuleCollection {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    formatKey: string;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, formatKey: string);
+    items(): Promise<ExcelConditionalFormatRule[]>;
+    getItem(index: number): ExcelConditionalFormatRule;
+    getItemOrNullObject(index: number): Promise<ExcelConditionalFormatRule | null>;
+    add(model: ExcelConditionalFormatRuleModel): Promise<ExcelConditionalFormatRule>;
+    delete(index: number): Promise<void>;
+    toModel(): Promise<ExcelConditionalFormatRuleModel[]>;
+}
+declare class ExcelConditionalFormatRule {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly formatKey;
+    private readonly index;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, formatKey: string, index: number);
+    type(): Promise<string | undefined>;
+    setType(type: string | undefined): Promise<void>;
+    priority(): Promise<number | undefined>;
+    setPriority(priority: number | undefined): Promise<void>;
+    operator(): Promise<string | undefined>;
+    setOperator(operator: string | undefined): Promise<void>;
+    stopIfTrue(): Promise<boolean | undefined>;
+    setStopIfTrue(value: boolean | undefined): Promise<void>;
+    formulas(): Promise<string[]>;
+    setFormula(index: number, formula: string): Promise<void>;
+    addFormula(formula: string): Promise<void>;
+    deleteFormula(index: number): Promise<void>;
+    toModel(): Promise<ExcelConditionalFormatRuleModel>;
+    delete(): Promise<void>;
+    private run;
+}
+declare class ExcelDrawingCollection extends ReadonlySheetCollection<ExcelDrawingModel, ExcelDrawing> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelDrawing extends IndexedSheetItem<ExcelDrawingModel> {
+    protected readonly collection = "drawings";
+    readonly anchors: ExcelDrawingAnchorCollection;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, index: number);
+    relationshipId(): Promise<string | undefined>;
+    path(): Promise<string | undefined>;
+}
+declare class ExcelDrawingAnchorCollection {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly drawingIndex;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, drawingIndex: number);
+    items(): Promise<ExcelDrawingAnchor[]>;
+    getItem(index: number): ExcelDrawingAnchor;
+    getItemOrNullObject(index: number): Promise<ExcelDrawingAnchor | null>;
+    toModel(): Promise<ExcelDrawingAnchorModel[]>;
+}
+declare class ExcelDrawingAnchor {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly drawingIndex;
+    private readonly anchorIndex;
+    readonly from: ExcelDrawingMarker;
+    readonly to: ExcelDrawingMarker;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, drawingIndex: number, anchorIndex: number);
+    kind(): Promise<ExcelDrawingAnchorModel['kind']>;
+    object(): Promise<ExcelDrawingObjectModel | undefined>;
+    toModel(): Promise<ExcelDrawingAnchorModel>;
+    private run;
+}
+declare class ExcelDrawingMarker {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly drawingIndex;
+    private readonly anchorIndex;
+    private readonly markerName;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, drawingIndex: number, anchorIndex: number, markerName: 'from' | 'to');
+    row(): Promise<number | undefined>;
+    setRow(row: number | undefined): Promise<void>;
+    column(): Promise<number | undefined>;
+    setColumn(column: number | undefined): Promise<void>;
+    rowOffset(): Promise<number | undefined>;
+    setRowOffset(offset: number | undefined): Promise<void>;
+    columnOffset(): Promise<number | undefined>;
+    setColumnOffset(offset: number | undefined): Promise<void>;
+    toModel(): Promise<ExcelDrawingMarkerModel>;
+    private run;
+}
+declare class ExcelChartCollection extends ReadonlySheetCollection<ExcelChartModel, ExcelChart> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+    add(options: ExcelChartAddOptions): Promise<ExcelChart>;
+}
+declare class ExcelChart extends IndexedSheetItem<ExcelChartModel> {
+    protected readonly collection = "charts";
+    readonly formulaRefs: ExcelFormulaRefCollection;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, index: number);
+    relationshipId(): Promise<string | undefined>;
+    drawingPath(): Promise<string | undefined>;
+    path(): Promise<string | undefined>;
+    title(): Promise<string | undefined>;
+    setTitle(title: string | undefined): Promise<void>;
+}
+declare class ExcelFormulaRefCollection {
+    private readonly workbook;
+    private readonly sheetNameOrId;
+    private readonly chartIndex;
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string, chartIndex: number);
+    items(): Promise<string[]>;
+    getItem(index: number): Promise<string | undefined>;
+    setItem(index: number, formulaRef: string): Promise<void>;
+    add(formulaRef: string): Promise<void>;
+    delete(index: number): Promise<void>;
+    toModel(): Promise<string[]>;
+    private run;
+}
+declare class ExcelImageCollection extends ReadonlySheetCollection<ExcelImageModel, ExcelImage> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+}
+declare class ExcelImage extends IndexedSheetItem<ExcelImageModel> {
+    protected readonly collection = "images";
+    relationshipId(): Promise<string | undefined>;
+    drawingPath(): Promise<string | undefined>;
+    path(): Promise<string | undefined>;
+    targetMode(): Promise<string | undefined>;
+    name(): Promise<string | undefined>;
+}
+declare class ExcelShapeCollection extends ReadonlySheetCollection<ExcelShapeModel, ExcelShape> {
+    constructor(workbook: ExcelWorkbook, sheetNameOrId: string);
+    getItem(name: string): ExcelShape;
+}
+declare class ExcelShape extends IndexedSheetItem<ExcelShapeModel> {
+    protected readonly collection = "shapes";
+    drawingPath(): Promise<string | undefined>;
+    name(): Promise<string | undefined>;
+    setName(name: string | undefined): Promise<void>;
+}
+declare class ExcelNamedItemCollection {
+    private readonly workbook;
+    constructor(workbook: ExcelWorkbook);
+    items(): Promise<ExcelNamedItem[]>;
+    getItem(name: string): ExcelNamedItem;
+    getItemOrNullObject(name: string): Promise<ExcelNamedItem | null>;
+    add(model: ExcelDefinedNameModel): Promise<ExcelNamedItem>;
+    deleteItem(name: string): Promise<void>;
+}
+declare class ExcelNamedItem {
+    private readonly workbook;
+    private nameValue;
+    constructor(workbook: ExcelWorkbook, nameValue: string);
+    name(): Promise<string>;
+    text(): Promise<string>;
+    setText(text: string): Promise<void>;
+    rename(name: string): Promise<void>;
+    localSheetId(): Promise<number | undefined>;
+    setLocalSheetId(localSheetId: number | undefined): Promise<void>;
+    private run;
+}
+
+/** Receivers exposed inside ExcelWorkbook.executeCode scripts. */
+interface ExcelScriptApiReceiverMap {
+    workbook: ExcelWorkbookCore;
+    'workbook.worksheets': ExcelWorksheetCollection$1;
+    sheet: ExcelWorksheet$1;
+    'sheet.drawings': ExcelDrawingCollection$1;
+    'sheet.images': ExcelImageCollection$1;
+    'sheet.shapes': ExcelShapeCollection$1;
+    'sheet.charts': ExcelChartCollection$1;
+    range: ExcelRange$1;
+    'range.format': ExcelRangeFormat$1;
+    'range.format.font': ExcelRangeFontFormat$1;
+    'range.format.fill': ExcelRangeFillFormat$1;
+    'range.format.border': ExcelRangeBorderFormat$1;
+    'range.format.alignment': ExcelRangeAlignmentFormat$1;
+    cell: ExcelCell$1;
+    chart: ExcelChart$1;
+    'chart.formulaRefs': ExcelFormulaRefCollection$1;
+}
+type ExcelScriptApiReceiver = keyof ExcelScriptApiReceiverMap;
+type MethodName<T> = {
+    [K in keyof T]-?: T[K] extends (...args: never[]) => unknown ? K : never;
+}[keyof T] & string;
+/** Type-safe receiver-qualified method path for the synchronous Excel script runtime. */
+type ExcelScriptApiPath = {
+    [R in ExcelScriptApiReceiver]: `${R}.${MethodName<ExcelScriptApiReceiverMap[R]>}`;
+}[ExcelScriptApiReceiver];
+
+declare function readWorkbookModel(pkg: Package): ExcelWorkbookModel;
+
+interface CellAddress {
+    address: string;
+    row: number;
+    column: number;
+}
+interface RangeAddress {
+    address: string;
+    sheetName?: string;
+    startRow: number;
+    startColumn: number;
+    rowCount: number;
+    columnCount: number;
+}
+interface SheetQualifiedAddress {
+    sheetName?: string;
+    address: string;
+}
+declare function columnNameToIndex(columnName: string): number;
+declare function columnIndexToName(column: number): string;
+declare function parseCellAddress(address: string): CellAddress;
+declare function formatCellAddress(row: number, column: number): string;
+declare function parseRangeAddress(address: string): RangeAddress;
+declare function splitSheetQualifiedAddress(input: string): SheetQualifiedAddress;
+declare function formatRangeAddress(startRow: number, startColumn: number, rowCount: number, columnCount: number): string;
+
+interface ExcelReferenceRewriteOptions {
+    sheetName?: string;
+}
+type ExcelReferenceRewriteResult = {
+    ok: true;
+    address: string;
+} | {
+    ok: false;
+    address: '#REF!';
+};
+type ExcelFormulaReferenceRewriter = (reference: string) => ExcelReferenceRewriteResult;
+declare function renameSheetInReference(address: string, oldName: string, newName: string): string;
+declare function rewriteFormulaReferences(formula: string, rewrite: ExcelFormulaReferenceRewriter): string;
+declare function renameSheetInFormula(formula: string, oldName: string, newName: string): string;
+declare function rewriteFormulaForRowInsert(formula: string, rowIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): string;
+declare function rewriteFormulaForRowDelete(formula: string, rowIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): string;
+declare function rewriteFormulaForColumnInsert(formula: string, columnIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): string;
+declare function rewriteFormulaForColumnDelete(formula: string, columnIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): string;
+/**
+ * Rebase a formula as if its containing cell moved by the supplied offsets.
+ * Relative row/column coordinates move; absolute coordinates and string literals stay unchanged.
+ */
+declare function shiftFormulaReferences(formula: string, rowOffset: number, columnOffset: number): string;
+/** Rewrites relative row references when a formula's source rows are reordered. */
+declare function rewriteFormulaForRowSort(formula: string, rowMap: ReadonlyMap<number, number>, options?: ExcelReferenceRewriteOptions): string;
+declare function shiftReferenceRelative(address: string, rowOffset: number, columnOffset: number): ExcelReferenceRewriteResult;
+declare function rewriteReferenceForRowInsert(address: string, rowIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): ExcelReferenceRewriteResult;
+declare function rewriteReferenceForRowDelete(address: string, rowIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): ExcelReferenceRewriteResult;
+declare function rewriteReferenceForColumnInsert(address: string, columnIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): ExcelReferenceRewriteResult;
+declare function rewriteReferenceForColumnDelete(address: string, columnIndex: number, count?: number, options?: ExcelReferenceRewriteOptions): ExcelReferenceRewriteResult;
+
+type SpreadsheetFormulaError = '#DIV/0!' | '#NUM!' | '#VALUE!' | '#REF!' | '#NAME?' | '#N/A' | '#CALC!' | '#SPILL!' | '#CYCLE!';
+type SpreadsheetFormulaScalar = ExcelCellValue | boolean;
+type SpreadsheetFormulaValue = SpreadsheetFormulaScalar | SpreadsheetFormulaScalar[][];
+interface SpreadsheetFormulaCellReference {
+    kind: 'cell';
+    address: string;
+    sheetName?: string;
+}
+interface SpreadsheetFormulaRangeReference {
+    kind: 'range';
+    startAddress: string;
+    endAddress: string;
+    sheetName?: string;
+}
+type SpreadsheetFormulaReference = SpreadsheetFormulaCellReference | SpreadsheetFormulaRangeReference;
+type SpreadsheetFormulaAst = {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'name';
+    name: string;
+} | {
+    kind: 'cell';
+    address: string;
+    sheetName?: string;
+} | {
+    kind: 'range';
+    startAddress: string;
+    endAddress: string;
+    sheetName?: string;
+} | {
+    kind: 'unary';
+    operator: '+' | '-' | '%';
+    argument: SpreadsheetFormulaAst;
+} | {
+    kind: 'binary';
+    operator: '+' | '-' | '*' | '/' | '&' | '=' | '<>' | '>' | '>=' | '<' | '<=';
+    left: SpreadsheetFormulaAst;
+    right: SpreadsheetFormulaAst;
+} | {
+    kind: 'call';
+    name: string;
+    args: SpreadsheetFormulaAst[];
+};
+interface SpreadsheetFormulaResult {
+    value: SpreadsheetFormulaValue;
+    displayText: string;
+    error: SpreadsheetFormulaError | null;
+    dependencies: SpreadsheetFormulaReference[];
+}
+
+declare function parseSpreadsheetFormula(formula: string): SpreadsheetFormulaAst;
+declare function collectSpreadsheetFormulaReferences(formula: string): SpreadsheetFormulaReference[];
+
+interface SpreadsheetFormulaEvaluationContext {
+    getCellValue(address: string, sheetName?: string): SpreadsheetFormulaScalar;
+    getCellEvaluation?(address: string, sheetName?: string): SpreadsheetFormulaEvaluation;
+    getNameValue?(name: string): SpreadsheetFormulaEvaluation;
+    isRowHidden?(row: number, sheetName?: string): boolean;
+    /** Returns today's date as an Excel serial number. Injectable for deterministic hosts/tests. */
+    getToday?: () => number;
+}
+interface SpreadsheetFormulaEvaluation {
+    value: SpreadsheetFormulaValue;
+    error: SpreadsheetFormulaError | null;
+    dependencies: SpreadsheetFormulaReference[];
+}
+declare function evaluateSpreadsheetFormulaAst(ast: SpreadsheetFormulaAst, context: SpreadsheetFormulaEvaluationContext): SpreadsheetFormulaEvaluation;
+
+interface SpreadsheetFormulaEngineOptions {
+    /** Evaluation date used by TODAY(). Defaults to the host's current local date. */
+    today?: Date;
+    /** Workbook sheets used to resolve quoted cross-sheet references. */
+    sheets?: readonly ExcelSheetModel[];
+}
+declare class SpreadsheetFormulaEngine {
+    private readonly sheet;
+    private readonly options;
+    private readonly cellsByAddress;
+    private readonly resultsByAddress;
+    private readonly resultsBySheetAddress;
+    private readonly dependenciesByAddress;
+    private readonly dependentsByAddress;
+    private readonly evaluating;
+    private readonly cellsBySheet;
+    private readonly sheetsByName;
+    constructor(sheet: ExcelSheetModel, options?: SpreadsheetFormulaEngineOptions);
+    calculate(): Map<string, SpreadsheetFormulaResult>;
+    recalculate(changedAddresses: Iterable<string>): Map<string, SpreadsheetFormulaResult>;
+    updateCellValue(address: string, value: ExcelCellValue): Map<string, SpreadsheetFormulaResult>;
+    updateCellFormula(address: string, formula: string | null): Map<string, SpreadsheetFormulaResult>;
+    evaluateFormulaCell(address: string): SpreadsheetFormulaResult;
+    private evaluateFormulaCellAt;
+    getDependencies(address: string): SpreadsheetFormulaReference[];
+    getDependents(address: string): string[];
+    getAffectedFormulaAddresses(changedAddresses: Iterable<string>): string[];
+    private registerDependencies;
+    private addDependentEdges;
+    private rebuildDependents;
+    private recalculateKnownAffected;
+    private clearCalculationState;
+    private withSpillResults;
+    private setCellValue;
+    private setCellFormula;
+    private ensureCell;
+    private deleteCell;
+    private sortAffectedFormulaAddresses;
+}
+declare function calculateSpreadsheetSheetFormulas(sheet: ExcelSheetModel, options?: SpreadsheetFormulaEngineOptions): Map<string, SpreadsheetFormulaResult>;
+
+type ExcelWritebackStrategy = 'no-op' | 'workbook-package-replace' | 'sheet-shadow-replace' | 'diff-patch' | 'unsupported';
+type ExcelWritebackPreference = 'auto' | 'package' | 'sheet-shadow' | 'diff';
+interface ExcelWritebackCapabilities {
+    /**
+     * Host can replace the currently-open workbook with a full xlsx package in place.
+     * This is usually desktop/file-system territory, not Office/WPS/ONLYOFFICE plugin mode.
+     */
+    canReplaceWorkbookPackage?: boolean;
+    /** Host can insert sheets from a generated workbook package or shadow workbook. */
+    canInsertShadowSheets?: boolean;
+    /** Host can copy sheet/range content from a shadow sheet into an existing sheet. */
+    canCopySheetContent?: boolean;
+    /** Host can delete temporary or existing sheets. */
+    canDeleteSheet?: boolean;
+    /** Host can rename sheets. */
+    canRenameSheet?: boolean;
+    /** Host can patch cell values/formulas directly through live object calls. */
+    canPatchCells?: boolean;
+    /** Host can patch non-cell sheet objects such as tables, drawings, comments, validations, and formats. */
+    canPatchSheetObjects?: boolean;
+    /** Upper bound for live cell patch operations before planner should prefer sheet/package replacement. */
+    maxCellPatchCount?: number;
+}
+interface ExcelWritebackPlanOptions {
+    preference?: ExcelWritebackPreference;
+}
+type ExcelWorkbookDiffKind = 'added' | 'deleted' | 'renamed' | 'modified';
+type ExcelCellDiffKind = 'added' | 'deleted' | 'modified';
+interface ExcelCellDiff {
+    kind: ExcelCellDiffKind;
+    address: string;
+    before?: ExcelCellModel;
+    after?: ExcelCellModel;
+}
+interface ExcelSheetDiff {
+    kind: ExcelWorkbookDiffKind;
+    sheetId: string;
+    beforeName?: string;
+    afterName?: string;
+    cellChanges: number;
+    cells: ExcelCellDiff[];
+    structuralChanged: boolean;
+    objectChanged: boolean;
+}
+interface ExcelWorkbookDiff {
+    changed: boolean;
+    sheets: ExcelSheetDiff[];
+}
+type ExcelWritebackOperation = {
+    type: 'replaceWorkbookPackage';
+} | {
+    type: 'insertShadowSheet';
+    sheetId: string;
+    sheetName: string;
+    targetSheet: ExcelSheetModel;
+    targetStyles: ExcelStylesModel;
+} | {
+    type: 'copySheetContent';
+    fromSheetName: string;
+    toSheetName: string;
+} | {
+    type: 'repairSheetObjects';
+    sheetName: string;
+} | {
+    type: 'deleteSheet';
+    sheetName: string;
+} | {
+    type: 'renameSheet';
+    fromName: string;
+    toName: string;
+} | {
+    type: 'patchCells';
+    sheetName: string;
+    cellCount: number;
+    changes: ExcelCellDiff[];
+} | {
+    type: 'patchSheetObjects';
+    sheetName: string;
+};
+interface ExcelWritebackPlan {
+    strategy: ExcelWritebackStrategy;
+    diff: ExcelWorkbookDiff;
+    operations: ExcelWritebackOperation[];
+    warnings: string[];
+    unsupportedReasons: string[];
+}
+declare function diffExcelWorkbookModels(before: ExcelWorkbookModel, after: ExcelWorkbookModel): ExcelWorkbookDiff;
+declare function planExcelWriteback(before: ExcelWorkbookModel, after: ExcelWorkbookModel, capabilities: ExcelWritebackCapabilities, options?: ExcelWritebackPlanOptions): ExcelWritebackPlan;
+
+interface ExcelShadowWorkbookOptions {
+    /** Name written into the one-sheet workbook. Usually the planner's temporary shadow sheet name. */
+    sheetName?: string;
+    /** Sheet id written into the one-sheet workbook. Defaults to the source sheet id. */
+    sheetId?: string;
+    /** Workbook styles required by cells, rows, columns, tables, and formats referenced by style ids. */
+    styles?: ExcelStylesModel;
+    /** Optional workbook defined names to include in the generated package. */
+    definedNames?: ExcelDefinedNameModel[];
+}
+interface ExcelShadowWorkbookPayload {
+    sheetName: string;
+    model: ExcelWorkbookModel;
+    package: Package;
+    bytes: Uint8Array;
+    base64: string;
+}
+declare function createShadowWorkbookPayload(sheet: ExcelSheetModel, options?: ExcelShadowWorkbookOptions): Promise<ExcelShadowWorkbookPayload>;
+declare function createShadowWorkbookModel(sheet: ExcelSheetModel, options?: ExcelShadowWorkbookOptions): ExcelWorkbookModel;
+
+declare const SS_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+declare const REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+declare const OFFICE_REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+
+export { type CellAddress, type ExcelAgentTransactionGroupOptions, type ExcelAggregateBucket, type ExcelAggregateGroupBy, type ExcelAggregateMetric, type ExcelAggregateOperation, type ExcelAggregateResultRow, type ExcelAggregateSource, type ExcelAggregateTableOptions, type ExcelAggregateTableResult, type ExcelAlignmentModel, type ExcelBorderModel, type ExcelBorderSideModel, ExcelCell, ExcelCell$1 as ExcelCellCore, type ExcelCellDiff, type ExcelCellDiffKind, type ExcelCellFormatModel, type ExcelCellFormatSnapshot, type ExcelCellKind, type ExcelCellModel, type ExcelCellValue, ExcelChart, type ExcelChartAddOptions, ExcelChartCollection, ExcelChartCollection$1 as ExcelChartCollectionCore, ExcelChart$1 as ExcelChartCore, type ExcelChartModel, type ExcelChartPositionModel, type ExcelChartSeriesModel, type ExcelChartType, type ExcelColorModel, type ExcelColumnModel, type ExcelColumnWidthPatch, ExcelComment, ExcelCommentCollection, ExcelCommentCollection$1 as ExcelCommentCollectionCore, ExcelComment$1 as ExcelCommentCore, type ExcelCommentModel, ExcelConditionalFormat, ExcelConditionalFormatCollection, ExcelConditionalFormatCollection$1 as ExcelConditionalFormatCollectionCore, ExcelConditionalFormat$1 as ExcelConditionalFormatCore, type ExcelConditionalFormatModel, ExcelConditionalFormatRule, ExcelConditionalFormatRuleCollection, ExcelConditionalFormatRuleCollection$1 as ExcelConditionalFormatRuleCollectionCore, ExcelConditionalFormatRule$1 as ExcelConditionalFormatRuleCore, type ExcelConditionalFormatRuleModel, ExcelDataValidation, ExcelDataValidationCollection, ExcelDataValidationCollection$1 as ExcelDataValidationCollectionCore, ExcelDataValidation$1 as ExcelDataValidationCore, type ExcelDataValidationModel, type ExcelDefinedNameModel, ExcelDrawing, ExcelDrawingAnchor, ExcelDrawingAnchorCollection, ExcelDrawingAnchorCollection$1 as ExcelDrawingAnchorCollectionCore, ExcelDrawingAnchor$1 as ExcelDrawingAnchorCore, type ExcelDrawingAnchorModel, ExcelDrawingCollection, ExcelDrawingCollection$1 as ExcelDrawingCollectionCore, ExcelDrawing$1 as ExcelDrawingCore, ExcelDrawingMarker, ExcelDrawingMarker$1 as ExcelDrawingMarkerCore, type ExcelDrawingMarkerModel, type ExcelDrawingModel, type ExcelDrawingObjectModel, type ExcelFillModel, type ExcelFontModel, ExcelFormulaRefCollection, ExcelFormulaRefCollection$1 as ExcelFormulaRefCollectionCore, type ExcelFormulaReferenceRewriter, type ExcelHistoryApplyResult, ExcelHyperlink, ExcelHyperlinkCollection, ExcelHyperlinkCollection$1 as ExcelHyperlinkCollectionCore, ExcelHyperlink$1 as ExcelHyperlinkCore, type ExcelHyperlinkModel, ExcelImage, ExcelImageCollection, ExcelImageCollection$1 as ExcelImageCollectionCore, ExcelImage$1 as ExcelImageCore, type ExcelImageModel, type ExcelLoadOptions, type ExcelMergedRangeModel, type ExcelMergedRangesPatch, type ExcelModeDecision, type ExcelModeSource, type ExcelMutationRecorder, type ExcelMutationSheetRef, ExcelNamedItem, ExcelNamedItemCollection, ExcelNamedItemCollection$1 as ExcelNamedItemCollectionCore, ExcelNamedItem$1 as ExcelNamedItemCore, type ExcelNumberFormatModel, type ExcelPaneModel, type ExcelPatch, type ExcelPatchSummary, ExcelRange, ExcelRangeAlignmentFormat, ExcelRangeAlignmentFormat$1 as ExcelRangeAlignmentFormatCore, ExcelRangeBorderFormat, ExcelRangeBorderFormat$1 as ExcelRangeBorderFormatCore, type ExcelRangeCellsPatch, type ExcelRangeClearMutation, ExcelRange$1 as ExcelRangeCore, ExcelRangeFillFormat, ExcelRangeFillFormat$1 as ExcelRangeFillFormatCore, ExcelRangeFontFormat, ExcelRangeFontFormat$1 as ExcelRangeFontFormatCore, ExcelRangeFormat, ExcelRangeFormat$1 as ExcelRangeFormatCore, type ExcelRangeFormatPatch, type ExcelRangeMergeMutation, type ExcelRangeMutationBase, type ExcelRangeSetFormulasMutation, type ExcelRangeSetValuesMutation, type ExcelRangeUnmergeMutation, type ExcelReferenceRewriteOptions, type ExcelReferenceRewriteResult, type ExcelRowHeightPatch, type ExcelRowModel, type ExcelRuntimeLoadOptions, type ExcelRuntimeMode, ExcelWorkbook as ExcelRuntimeWorkbook, type ExcelScriptApiPath, type ExcelScriptApiReceiver, type ExcelScriptApiReceiverMap, type ExcelSelectionModel, type ExcelShadowWorkbookOptions, type ExcelShadowWorkbookPayload, ExcelShape, ExcelShapeCollection, ExcelShapeCollection$1 as ExcelShapeCollectionCore, ExcelShape$1 as ExcelShapeCore, type ExcelShapeModel, type ExcelSheetDiff, type ExcelSheetModel, type ExcelSheetViewModel, type ExcelSnapshotPatch, type ExcelStylesModel, ExcelTable, type ExcelTableAutoFilterModel, ExcelTableCollection, ExcelTableCollection$1 as ExcelTableCollectionCore, ExcelTableColumn, ExcelTableColumnCollection, ExcelTableColumnCollection$1 as ExcelTableColumnCollectionCore, ExcelTableColumn$1 as ExcelTableColumnCore, type ExcelTableColumnModel, ExcelTable$1 as ExcelTableCore, type ExcelTableFilterColumnModel, type ExcelTableModel, type ExcelTableSortConditionModel, type ExcelTableSortStateModel, ExcelTableStyle, ExcelTableStyle$1 as ExcelTableStyleCore, type ExcelTableStyleModel, ExcelThreadedComment, ExcelThreadedCommentCollection, ExcelThreadedCommentCollection$1 as ExcelThreadedCommentCollectionCore, ExcelThreadedComment$1 as ExcelThreadedCommentCore, type ExcelThreadedCommentModel, type ExcelTransaction, type ExcelTransactionBuilder, type ExcelTransactionGroup, type ExcelTransactionGroupMetadata, type ExcelTransactionGroupOptions, type ExcelTransactionGroupSummary, type ExcelTransactionSource, type ExcelTransactionSummary, type ExcelUnsafeMutation, ExcelWorkbook, ExcelWorkbookCore, type ExcelWorkbookDiff, type ExcelWorkbookDiffKind, ExcelWorkbookHistory, type ExcelWorkbookLoadOptions, type ExcelWorkbookModel, type ExcelWorkbookMutation, type ExcelWorkerFactory, ExcelWorksheet, type ExcelWorksheetAddMutation, ExcelWorksheetCollection, ExcelWorksheetCollection$1 as ExcelWorksheetCollectionCore, ExcelWorksheet$1 as ExcelWorksheetCore, type ExcelWorksheetDeleteMutation, type ExcelWorksheetRenameMutation, type ExcelWritebackCapabilities, type ExcelWritebackOperation, type ExcelWritebackPlan, type ExcelWritebackPlanOptions, type ExcelWritebackPreference, type ExcelWritebackStrategy, OFFICE_REL_NS, REL_NS, type RangeAddress, SS_NS, type SheetQualifiedAddress, type SpreadsheetFormulaAst, type SpreadsheetFormulaCellReference, SpreadsheetFormulaEngine, type SpreadsheetFormulaError, type SpreadsheetFormulaEvaluation, type SpreadsheetFormulaEvaluationContext, type SpreadsheetFormulaRangeReference, type SpreadsheetFormulaReference, type SpreadsheetFormulaResult, type SpreadsheetFormulaScalar, type SpreadsheetFormulaValue, aggregateExcelTable, applyExcelPatch, calculateSpreadsheetSheetFormulas, changedSheetNamesFromMutations, collectSpreadsheetFormulaReferences, columnIndexToName, columnNameToIndex, createShadowWorkbookModel, createShadowWorkbookPayload, diffExcelWorkbookModels, evaluateSpreadsheetFormulaAst, formatCellAddress, formatRangeAddress, parseCellAddress, parseRangeAddress, parseSpreadsheetFormula, planExcelWriteback, readWorkbookModel, renameSheetInFormula, renameSheetInReference, rewriteFormulaForColumnDelete, rewriteFormulaForColumnInsert, rewriteFormulaForRowDelete, rewriteFormulaForRowInsert, rewriteFormulaForRowSort, rewriteFormulaReferences, rewriteReferenceForColumnDelete, rewriteReferenceForColumnInsert, rewriteReferenceForRowDelete, rewriteReferenceForRowInsert, shiftFormulaReferences, shiftReferenceRelative, splitSheetQualifiedAddress, summarizeExcelTransactionGroup };