@extend-ai/react-xlsx 0.18.1 → 0.20.0

package/dist/internal-DrXSHYJZ.d.cts

@@ -0,0 +1,1498 @@
+import * as _dukelib_sheets_wasm from '@dukelib/sheets-wasm';
+import { Workbook, Worksheet } from '@dukelib/sheets-wasm';
+import { Properties } from 'csstype';
+
+interface XlsxThemePalette {
+    colorsByIndex: Record<number, string>;
+    majorLatinFont?: string;
+    minorLatinFont?: string;
+}
+interface XlsxResolvedCellStyle {
+    [key: string]: unknown;
+    alignment?: Record<string, unknown>;
+    border?: Record<string, Record<string, unknown>>;
+    cellControl?: {
+        kind: "checkbox";
+    };
+    fill?: Record<string, unknown>;
+    font?: Record<string, unknown>;
+    tableStyleOverrides?: XlsxResolvedCellStyle;
+}
+interface XlsxTableStyleDefinition {
+    [elementType: string]: XlsxResolvedCellStyle;
+}
+interface XlsxConditionalFormatValueObject {
+    type: string;
+    value?: number;
+}
+interface XlsxConditionalDataBarRule {
+    axisColor?: Record<string, unknown>;
+    border?: boolean;
+    color?: Record<string, unknown>;
+    borderColor?: Record<string, unknown>;
+    cfvos: XlsxConditionalFormatValueObject[];
+    gradient?: boolean;
+    kind: "dataBar";
+    maxLength?: number;
+    minLength?: number;
+    negativeBarBorderColorSameAsPositive?: boolean;
+    negativeBorderColor?: Record<string, unknown>;
+    negativeFillColor?: Record<string, unknown>;
+    priority: number;
+    ranges: XlsxCellRange[];
+    showValue?: boolean;
+}
+interface XlsxConditionalColorScaleRule {
+    cfvos: XlsxConditionalFormatValueObject[];
+    colors: Record<string, unknown>[];
+    kind: "colorScale";
+    priority: number;
+    ranges: XlsxCellRange[];
+}
+interface XlsxConditionalFormatIcon {
+    iconId: number;
+    iconSet: string;
+}
+interface XlsxConditionalIconSetRule {
+    cfvos: XlsxConditionalFormatValueObject[];
+    icons: XlsxConditionalFormatIcon[];
+    kind: "iconSet";
+    priority: number;
+    ranges: XlsxCellRange[];
+    reverse?: boolean;
+    showValue?: boolean;
+}
+interface XlsxConditionalStyledRule {
+    aboveAverage?: boolean;
+    bottom?: boolean;
+    equalAverage?: boolean;
+    formulas: string[];
+    kind: "styled";
+    operator?: string;
+    percent?: boolean;
+    priority: number;
+    rank?: number;
+    ranges: XlsxCellRange[];
+    ruleType: string;
+    stdDev?: number;
+    stopIfTrue?: boolean;
+    style: XlsxResolvedCellStyle;
+    text?: string;
+    timePeriod?: string;
+}
+type XlsxConditionalFormatRule = XlsxConditionalColorScaleRule | XlsxConditionalStyledRule | XlsxConditionalDataBarRule | XlsxConditionalIconSetRule;
+interface XlsxDataValidation {
+    allowBlank?: boolean;
+    errorMessage?: string;
+    errorStyle?: string;
+    inputMessage?: string;
+    listSource?: string;
+    ranges: XlsxCellRange[];
+    showDropdown?: boolean;
+    showErrorAlert?: boolean;
+    showInputMessage?: boolean;
+    validationType: string;
+}
+interface XlsxFreezePanes {
+    col: number;
+    row: number;
+}
+type XlsxSheetVisibility = "hidden" | "veryHidden" | "visible";
+interface XlsxSheetData {
+    cellStyleIds?: Record<string, number>;
+    autoFilterRanges: XlsxCellRange[];
+    cachedFormulaValues: Record<string, string>;
+    colWidthOverridesPx: Record<number, number>;
+    colStyleIds: Record<number, number>;
+    hiddenCols?: number[];
+    hiddenRows?: number[];
+    conditionalFormatRules: XlsxConditionalFormatRule[];
+    dataValidations: XlsxDataValidation[];
+    name: string;
+    visibility: XlsxSheetVisibility;
+    columnWidthCharacterWidthPx?: number;
+    defaultColWidthPx: number;
+    defaultRowHeightPx: number;
+    freezePanes: XlsxFreezePanes | null;
+    hasHorizontalMerges: boolean;
+    hasVerticalMerges: boolean;
+    maxHorizontalMergeEndCol: number;
+    maxVerticalMergeEndRow: number;
+    mergedRanges?: XlsxCellRange[];
+    minUsedCol: number;
+    minUsedRow: number;
+    maxUsedCol: number;
+    maxUsedRow: number;
+    rowCount: number;
+    colCount: number;
+    rowHeightOverridesPx: Record<number, number>;
+    rowStyleIds: Record<number, number>;
+    namedCellStyleByName: Record<string, XlsxResolvedCellStyle>;
+    styleById: Record<number, XlsxResolvedCellStyle>;
+    tableStyleByName: Record<string, XlsxTableStyleDefinition>;
+    visibleRows: number[];
+    visibleCols: number[];
+    colWidths: number[];
+    rowHeights: number[];
+    showGridLines: boolean;
+    sparklines: XlsxSparkline[];
+    themePalette: XlsxThemePalette;
+    workbookSheetIndex: number;
+    zoomScale?: number;
+}
+interface XlsxCellAddress {
+    col: number;
+    row: number;
+}
+interface XlsxCellRange {
+    end: XlsxCellAddress;
+    start: XlsxCellAddress;
+}
+type XlsxMergeMode = "cells" | "center" | "across";
+interface XlsxParsedRange {
+    kind: "cells" | "rows" | "columns";
+    range: XlsxCellRange;
+    sheetName: string | null;
+}
+interface XlsxHighlightRangeOptions {
+    /** Navigates to the worksheet and reveals the first range. Defaults to true. */
+    autoScroll?: boolean;
+    /** Visible worksheet index for an unqualified reference. Defaults to the active worksheet. */
+    sheetIndex?: number;
+}
+interface XlsxRangeHighlight extends XlsxParsedRange {
+    /** Whether this entry is the navigation target for the current highlight update. */
+    autoScroll: boolean;
+    sheetName: string;
+    workbookSheetIndex: number;
+}
+/**
+ * Color value accepted by persisted workbook style mutation APIs.
+ *
+ * Use `rgb` with a six-character `hex` value such as `"2563EB"` for the
+ * simplest browser-to-Excel mapping. `argb`, `theme`, and `indexed` are
+ * available for callers that need to preserve Excel-native color references.
+ */
+interface XlsxCellStyleColorInput {
+    /** Excel color representation to write. Defaults are handled by the workbook engine. */
+    colorType?: "auto" | "rgb" | "argb" | "theme" | "indexed";
+    /** Hex color string, for example `"2563EB"` for RGB or `"FF2563EB"` for ARGB. */
+    hex?: string;
+    /** Red channel, 0-255. */
+    r?: number;
+    /** Green channel, 0-255. */
+    g?: number;
+    /** Blue channel, 0-255. */
+    b?: number;
+    /** Alpha channel, 0-255, used by ARGB colors. */
+    a?: number;
+    /** Theme color index for Excel theme colors. */
+    themeIndex?: number;
+    /** Theme tint/shade adjustment. */
+    tint?: number;
+    /** Indexed color palette entry. */
+    paletteIndex?: number;
+}
+/** Font styling to persist on a cell or range. */
+interface XlsxCellFontStyleInput {
+    /** Font face name, such as `"Aptos"` or `"Calibri"`. */
+    name?: string;
+    /** Font size in points. */
+    size?: number;
+    /** Whether the font is bold. */
+    bold?: boolean;
+    /** Whether the font is italic. */
+    italic?: boolean;
+    /** Underline style. */
+    underline?: "none" | "single" | "double" | "singleAccounting" | "doubleAccounting";
+    /** Whether the font is struck through. */
+    strikethrough?: boolean;
+    /** Font color. */
+    color?: XlsxCellStyleColorInput;
+    /** Baseline, superscript, or subscript positioning. */
+    verticalAlign?: "baseline" | "superscript" | "subscript";
+    /** Excel font family classification. */
+    family?: number;
+    /** Font charset identifier. */
+    charset?: number;
+    /** Excel font scheme value. */
+    scheme?: string;
+}
+/** A color stop used by gradient fills. */
+interface XlsxCellGradientStopInput {
+    /** Stop position from 0 to 1. */
+    position: number;
+    /** Stop color. */
+    color: XlsxCellStyleColorInput;
+}
+/** Fill styling to persist on a cell or range. */
+interface XlsxCellFillStyleInput {
+    /** Fill type. Use `"solid"` with `color` for typical Excel fill color. */
+    fillType?: "none" | "solid" | "pattern" | "gradient";
+    /** Primary fill color. */
+    color?: XlsxCellStyleColorInput;
+    /** Excel pattern name for pattern fills. */
+    pattern?: string;
+    /** Foreground color for pattern fills. */
+    foreground?: XlsxCellStyleColorInput;
+    /** Background color for pattern fills. */
+    background?: XlsxCellStyleColorInput;
+    /** Gradient type for gradient fills. */
+    gradientType?: "linear" | "path";
+    /** Gradient angle in degrees. */
+    angle?: number;
+    /** Gradient color stops. */
+    stops?: XlsxCellGradientStopInput[];
+}
+/** A single border edge style. */
+interface XlsxCellBorderEdgeInput {
+    /** Excel border line style. */
+    style?: "none" | "thin" | "medium" | "thick" | "dashed" | "dotted" | "double" | "hair" | "mediumDashed" | "dashDot" | "mediumDashDot" | "dashDotDot" | "mediumDashDotDot" | "slantDashDot";
+    /** Border line color. */
+    color?: XlsxCellStyleColorInput;
+}
+/** Border styling to persist on a cell or range. */
+interface XlsxCellBorderStyleInput {
+    /** Left border edge. */
+    left?: XlsxCellBorderEdgeInput;
+    /** Right border edge. */
+    right?: XlsxCellBorderEdgeInput;
+    /** Top border edge. */
+    top?: XlsxCellBorderEdgeInput;
+    /** Bottom border edge. */
+    bottom?: XlsxCellBorderEdgeInput;
+    /** Diagonal border edge. */
+    diagonal?: XlsxCellBorderEdgeInput;
+    /** Diagonal border direction. */
+    diagonalDirection?: "none" | "down" | "up" | "both";
+}
+/** Alignment styling to persist on a cell or range. */
+interface XlsxCellAlignmentInput {
+    /** Horizontal alignment. */
+    horizontal?: "general" | "left" | "center" | "right" | "fill" | "justify" | "centerContinuous" | "distributed";
+    /** Vertical alignment. */
+    vertical?: "top" | "center" | "bottom" | "justify" | "distributed";
+    /** Whether text wraps inside the cell. */
+    wrapText?: boolean;
+    /** Whether text shrinks to fit the cell. */
+    shrinkToFit?: boolean;
+    /** Indentation level. */
+    indent?: number;
+    /** Text rotation in degrees. */
+    rotation?: number;
+    /** Text reading order. */
+    readingOrder?: "contextDependent" | "leftToRight" | "rightToLeft";
+}
+/** Number format styling to persist on a cell or range. */
+interface XlsxCellNumberFormatInput {
+    /** Number format source. Use `"custom"` with `formatString` for custom Excel formats. */
+    formatType?: "general" | "builtin" | "custom";
+    /** Built-in Excel number format id. */
+    id?: number;
+    /** Excel number format string, for example `"$#,##0.00"` or `"m/d/yyyy"`. */
+    formatString?: string;
+}
+/** Protection flags to persist on a cell or range. */
+interface XlsxCellProtectionInput {
+    /** Whether the cell is locked when sheet protection is enabled. */
+    locked?: boolean;
+    /** Whether the cell formula is hidden when sheet protection is enabled. */
+    hidden?: boolean;
+}
+/**
+ * Persisted Excel cell style patch.
+ *
+ * Passing a partial style updates the supplied style groups on the target cell
+ * or range. Unlike the `getCellStyle` render override prop, this mutates the
+ * workbook and is included in exported XLSX bytes.
+ */
+interface XlsxCellStyleInput {
+    /** Font formatting such as bold, italic, size, family, and font color. */
+    font?: XlsxCellFontStyleInput;
+    /** Cell fill formatting such as background color or gradient fill. */
+    fill?: XlsxCellFillStyleInput;
+    /** Border formatting for cell edges. */
+    border?: XlsxCellBorderStyleInput;
+    /** Alignment, wrapping, indentation, rotation, and reading order. */
+    alignment?: XlsxCellAlignmentInput;
+    /** Excel number/date/currency/percent format metadata. */
+    numberFormat?: XlsxCellNumberFormatInput;
+    /** Cell protection flags. */
+    protection?: XlsxCellProtectionInput;
+}
+interface XlsxSparkline {
+    color?: string;
+    firstColor?: string;
+    highColor?: string;
+    lastColor?: string;
+    lowColor?: string;
+    markerColor?: string;
+    markers?: boolean;
+    negative?: boolean;
+    negativeColor?: string;
+    range: XlsxCellRange;
+    sheetName?: string;
+    target: XlsxCellAddress;
+    type: "column" | "line" | "winLoss";
+}
+interface XlsxClipboardData {
+    html: string;
+    structured: string;
+    text: string;
+}
+interface XlsxTableColumn {
+    id: number;
+    index: number;
+    name: string;
+}
+interface XlsxTableStyleInfo {
+    name?: string;
+    showColumnStripes?: boolean;
+    showFirstColumn?: boolean;
+    showLastColumn?: boolean;
+    showRowStripes?: boolean;
+}
+interface XlsxTable {
+    columns: XlsxTableColumn[];
+    displayName: string;
+    end: XlsxCellAddress;
+    headerRowCount: number;
+    headerRowCellStyle?: string;
+    name: string;
+    reference: string;
+    start: XlsxCellAddress;
+    styleInfo?: XlsxTableStyleInfo;
+    totalsRowCount: number;
+    totalsRowShown: boolean;
+}
+type XlsxTableSortDirection = "ascending" | "descending";
+interface XlsxTableSortState {
+    columnIndex: number;
+    direction: XlsxTableSortDirection;
+    tableName: string;
+}
+interface XlsxImageMarker {
+    col: number;
+    colOffsetEmu: number;
+    row: number;
+    rowOffsetEmu: number;
+}
+type XlsxImageAnchor = {
+    from: XlsxImageMarker;
+    kind: "one-cell";
+    sizeEmu: {
+        cx: number;
+        cy: number;
+    };
+} | {
+    kind: "absolute";
+    positionEmu: {
+        x: number;
+        y: number;
+    };
+    sizeEmu: {
+        cx: number;
+        cy: number;
+    };
+} | {
+    from: XlsxImageMarker;
+    kind: "two-cell";
+    to: XlsxImageMarker;
+};
+interface XlsxImage {
+    anchor: XlsxImageAnchor;
+    description?: string;
+    editable?: boolean;
+    hyperlink?: string;
+    id: string;
+    mediaPath?: string;
+    mimeType: string;
+    name?: string;
+    sheetIndex: number;
+    src: string;
+    workbookSheetIndex: number;
+    zIndex: number;
+}
+interface XlsxShapeFill {
+    color?: string;
+    none?: boolean;
+    opacity?: number;
+}
+interface XlsxShapeStroke {
+    color?: string;
+    dash?: string;
+    headEndType?: string;
+    none?: boolean;
+    opacity?: number;
+    tailEndType?: string;
+    widthPx?: number;
+}
+interface XlsxShapeTextRun {
+    bold?: boolean;
+    color?: string;
+    fontFamily?: string;
+    fontSizePt?: number;
+    italic?: boolean;
+    text: string;
+    underline?: boolean;
+}
+interface XlsxShapeParagraph {
+    align?: "center" | "justify" | "left" | "right";
+    runs: XlsxShapeTextRun[];
+}
+interface XlsxShapeTextBox {
+    horizontalAlign?: "center" | "left";
+    insetPx?: {
+        bottom: number;
+        left: number;
+        right: number;
+        top: number;
+    };
+    verticalAlign?: "bottom" | "middle" | "top";
+}
+interface XlsxShape {
+    anchor: XlsxImageAnchor;
+    description?: string;
+    fill?: XlsxShapeFill;
+    flipH?: boolean;
+    flipV?: boolean;
+    geometry: string;
+    geometryAdjustments?: Record<string, number>;
+    hidden?: boolean;
+    hyperlink?: string;
+    id: string;
+    name?: string;
+    paragraphs: XlsxShapeParagraph[];
+    rotationDeg?: number;
+    scaleX?: number;
+    scaleY?: number;
+    sheetIndex: number;
+    svgPath?: string;
+    svgViewBox?: {
+        height: number;
+        width: number;
+    };
+    stroke?: XlsxShapeStroke;
+    textBox?: XlsxShapeTextBox;
+    workbookSheetIndex: number;
+    zIndex: number;
+}
+type XlsxFormControlKind = "button" | "checkbox" | "dropdown" | "editbox" | "group-box" | "label" | "listbox" | "radio" | "scrollbar" | "spinner" | "unknown";
+type XlsxFormControlState = "unchecked" | "checked" | "mixed";
+type XlsxFormControlSelectionMode = "single" | "multi" | "extend";
+interface XlsxFormControlCaptionRun {
+    font?: XlsxCellFontStyleInput;
+    text: string;
+}
+interface XlsxFormControlCaption {
+    horizontalAlignment?: "general" | "left" | "center" | "right" | "fill" | "justify" | "centerContinuous" | "distributed";
+    runs: XlsxFormControlCaptionRun[];
+    verticalAlignment?: "top" | "center" | "bottom" | "justify" | "distributed";
+}
+type XlsxFormControlCaptionInput = string | XlsxFormControlCaption;
+type XlsxFormControlKindInput = {
+    kind: "button";
+    caption: XlsxFormControlCaptionInput;
+} | {
+    kind: "checkbox";
+    caption: XlsxFormControlCaptionInput;
+    state: XlsxFormControlState;
+    cellLink?: string;
+    no3D?: boolean;
+} | {
+    kind: "optionButton";
+    caption: XlsxFormControlCaptionInput;
+    state: Exclude<XlsxFormControlState, "mixed">;
+    cellLink?: string;
+    no3D?: boolean;
+} | {
+    kind: "label";
+    caption: XlsxFormControlCaptionInput;
+} | {
+    kind: "groupBox";
+    caption: XlsxFormControlCaptionInput;
+    no3D?: boolean;
+} | {
+    kind: "listBox";
+    inputRange?: string;
+    cellLink?: string;
+    selection: XlsxFormControlSelectionMode;
+    selected?: number[];
+    no3D?: boolean;
+} | {
+    kind: "dropdown";
+    inputRange?: string;
+    cellLink?: string;
+    selected?: number;
+    lines: number;
+    no3D?: boolean;
+} | {
+    kind: "editbox";
+    caption: XlsxFormControlCaptionInput;
+    legacyObjectType?: number;
+    rawObj?: Uint8Array | number[];
+    rawProperties?: Array<[string, string]>;
+} | {
+    kind: "scrollbar";
+    value: number;
+    min: number;
+    max: number;
+    increment: number;
+    page: number;
+    horizontal?: boolean;
+    cellLink?: string;
+} | {
+    kind: "spinner";
+    value: number;
+    min: number;
+    max: number;
+    increment: number;
+    cellLink?: string;
+} | {
+    kind: "unknown";
+    objectType: string;
+    legacyObjectType?: number;
+    caption?: XlsxFormControlCaptionInput;
+    rawObj?: Uint8Array | number[];
+    rawProperties?: Array<[string, string]>;
+};
+interface XlsxFormControlMetadataInput {
+    altText?: string;
+    hidden?: boolean;
+    kind: XlsxFormControlKindInput;
+    locked?: boolean;
+    macroName?: string;
+    name?: string;
+    printable?: boolean;
+    rawClientData?: Array<Uint8Array | number[]>;
+    title?: string;
+}
+type XlsxFormControlInput = XlsxFormControlMetadataInput & ({
+    anchor: Extract<XlsxImageAnchor, {
+        kind: "two-cell";
+    }>;
+    editAs?: "twoCell" | "oneCell" | "absolute";
+} | {
+    anchor: Exclude<XlsxImageAnchor, {
+        kind: "two-cell";
+    }>;
+    editAs?: never;
+});
+type XlsxFormControlPatch = Partial<Omit<XlsxFormControlMetadataInput, "kind">> & {
+    anchor?: XlsxImageAnchor;
+    editAs?: "twoCell" | "oneCell" | "absolute";
+    kind?: XlsxFormControlKindInput;
+};
+interface XlsxFormControl {
+    anchor: XlsxImageAnchor;
+    altText?: string;
+    /** Original rich caption reported by Duke Sheets. */
+    caption?: XlsxFormControlCaption;
+    checked?: boolean;
+    /** Duke Sheets' stable zero-based index for this worksheet load. */
+    controlIndex?: number;
+    /** Original two-cell anchor behavior. */
+    editAs?: "twoCell" | "oneCell" | "absolute";
+    firstInGroup?: boolean;
+    fontFamily?: string;
+    fontSizePt?: number;
+    hidden?: boolean;
+    horizontal?: boolean;
+    id: string;
+    increment?: number;
+    inputRange?: string;
+    /** Current formatted labels resolved from a dropdown or list box input range. */
+    items?: string[];
+    kind: XlsxFormControlKind;
+    label?: string;
+    lines?: number;
+    linkedCell?: string;
+    locked?: boolean;
+    macroName?: string;
+    max?: number;
+    min?: number;
+    name?: string;
+    no3D?: boolean;
+    page?: number;
+    printable?: boolean;
+    objectType?: string;
+    legacyObjectType?: number;
+    rawClientData?: number[][];
+    rawObj?: number[];
+    rawProperties?: Array<[string, string]>;
+    /** Zero-based selected item index or indexes, matching Duke Sheets. */
+    selected?: number | number[];
+    selection?: XlsxFormControlSelectionMode;
+    sheetIndex: number;
+    state?: XlsxFormControlState;
+    textAlign?: "center" | "left" | "right";
+    textColor?: string;
+    title?: string;
+    value?: number;
+    workbookSheetIndex: number;
+    zIndex: number;
+}
+interface XlsxFormControlActionEvent {
+    control: XlsxFormControl;
+    type: "activate";
+}
+interface XlsxFormControlChangeEvent {
+    control: XlsxFormControl;
+    previousControl: XlsxFormControl;
+    type: "change";
+}
+interface XlsxChartReference {
+    formula?: string;
+    refType?: string;
+    values?: Array<number | string | null>;
+}
+interface XlsxChartDataLabels {
+    pointLabels?: XlsxChartPointDataLabel[];
+    raw?: Record<string, unknown>;
+    showBubbleSize?: boolean;
+    showCategoryName?: boolean;
+    showLegendKey?: boolean;
+    showPercent?: boolean;
+    showSeriesName?: boolean;
+    showValue?: boolean;
+}
+interface XlsxChartPointDataLabel {
+    deleted?: boolean;
+    fontSizePt?: number;
+    index: number;
+    showBubbleSize?: boolean;
+    showCategoryName?: boolean;
+    showPercent?: boolean;
+    showSeriesName?: boolean;
+    showValue?: boolean;
+    x?: number;
+    y?: number;
+}
+interface XlsxChartLegend {
+    overlay?: boolean;
+    position?: string;
+    raw?: Record<string, unknown>;
+}
+interface XlsxChartAxis {
+    crossId?: number;
+    crosses?: string;
+    crossBetween?: string;
+    delete?: boolean;
+    id?: number;
+    labelPosition?: string;
+    logBase?: number;
+    orientation?: string;
+    majorUnit?: number;
+    max?: number;
+    min?: number;
+    majorGridlines?: boolean;
+    majorGridlineColor?: string;
+    majorTickMark?: string;
+    minorUnit?: number;
+    minorGridlines?: boolean;
+    minorTickMark?: string;
+    numberFormat?: {
+        formatCode?: string;
+        sourceLinked?: boolean;
+    };
+    position?: string;
+    raw?: Record<string, unknown>;
+    shapeProperties?: Record<string, unknown>;
+    tickLabelSkip?: number;
+    tickMarkSkip?: number;
+}
+interface XlsxChartPointStyle {
+    color?: string;
+    explosion?: number;
+    index: number;
+    lineColor?: string;
+}
+interface XlsxChartSeries {
+    bubbleSizeRef?: XlsxChartReference | null;
+    bubbleSizes?: Array<number | null>;
+    categories: Array<number | string | null>;
+    categoriesRef?: XlsxChartReference | null;
+    color?: string;
+    dataPoints: unknown[];
+    dataPointStyles?: XlsxChartPointStyle[];
+    formatIdx?: number;
+    hidden?: boolean;
+    id: string;
+    invertIfNegative?: boolean;
+    lineColor?: string;
+    lineWidthPx?: number;
+    marker?: Record<string, unknown>;
+    markerColor?: string;
+    markerLineColor?: string;
+    markerSize?: number;
+    markerSymbol?: string;
+    name?: string;
+    negativeColor?: string;
+    negativeLineColor?: string;
+    raw?: Record<string, unknown>;
+    shapeProperties?: Record<string, unknown>;
+    smooth?: boolean;
+    values: Array<number | null>;
+    valuesRef?: XlsxChartReference | null;
+}
+type XlsxChartElementSelection = {
+    kind: "chart";
+    chartId: string;
+} | {
+    kind: "series";
+    chartId: string;
+    seriesId: string;
+    seriesIndex: number;
+} | {
+    kind: "point";
+    chartId: string;
+    seriesId: string;
+    seriesIndex: number;
+    pointIndex: number;
+} | {
+    kind: "legendEntry";
+    chartId: string;
+    seriesId: string;
+    seriesIndex: number;
+};
+type XlsxFormulaTarget = {
+    kind: "cell";
+    cell: XlsxCellAddress | null;
+} | {
+    kind: "chartSeries";
+    chartId: string;
+    seriesId: string;
+    seriesIndex: number;
+} | null;
+interface XlsxChartTypeGroup {
+    axisIds?: number[];
+    chartType: string;
+    dataLabels?: XlsxChartDataLabels | null;
+    gapWidth?: number;
+    is3d?: boolean;
+    overlap?: number;
+    raw?: Record<string, unknown>;
+    series: XlsxChartSeries[];
+    varyColors?: boolean;
+}
+interface XlsxChartWall {
+    fillColor?: string;
+    hidden?: boolean;
+    lineColor?: string;
+    thickness?: number;
+}
+interface XlsxChart {
+    anchor: XlsxImageAnchor;
+    autoTitleDeleted?: boolean;
+    axes: XlsxChartAxis[];
+    axisLabelColor?: string;
+    axisLineColor?: string;
+    categoryAxis?: XlsxChartAxis | null;
+    chartExLayout?: string;
+    chartAreaBorderColor?: string;
+    chartAreaFillColor?: string;
+    chartColorPalette?: string[];
+    chartColorPaletteOffset?: number;
+    chartPath?: string;
+    chartStyleId?: number;
+    chartType: string;
+    dataLabels?: XlsxChartDataLabels | null;
+    displayBlanksAs?: string;
+    editable?: boolean;
+    firstSliceAngle?: number;
+    fontFamily?: string;
+    gapWidth?: number;
+    holeSize?: number;
+    id: string;
+    is3d?: boolean;
+    legend?: XlsxChartLegend | null;
+    name?: string;
+    overlap?: number;
+    plotVisibleOnly?: boolean;
+    raw?: Record<string, unknown>;
+    radarStyle?: string;
+    scatterStyle?: string;
+    roundedCorners?: boolean;
+    shape3d?: string;
+    seriesAxis?: XlsxChartAxis | null;
+    series: XlsxChartSeries[];
+    sheetIndex: number;
+    showDlblsOverMax?: boolean;
+    sideWall?: XlsxChartWall | null;
+    backWall?: XlsxChartWall | null;
+    bubbleScale?: number;
+    bubble3d?: boolean;
+    floor?: XlsxChartWall | null;
+    surfaceMaterial?: string;
+    textColor?: string;
+    title?: string;
+    titleColor?: string;
+    titleFontFamily?: string;
+    typeGroups?: XlsxChartTypeGroup[];
+    valueAxis?: XlsxChartAxis | null;
+    varyColors?: boolean;
+    view3d?: {
+        depthPercent?: number;
+        heightPercent?: number;
+        perspective?: number;
+        rAngAx?: boolean;
+        rotX?: number;
+        rotY?: number;
+    };
+    wireframe?: boolean;
+    workbookSheetIndex: number;
+    zIndex: number;
+}
+interface XlsxChartsheet {
+    chartIds: string[];
+    chartPath?: string;
+    id: string;
+    index: number;
+    name: string;
+    raw?: Record<string, unknown>;
+    workbookSheetIndex?: number;
+}
+interface XlsxWorkbookTab {
+    chartsheetIndex?: number;
+    id: string;
+    index: number;
+    kind: "chartsheet" | "sheet";
+    name: string;
+    sheetIndex?: number;
+    visibility?: XlsxSheetVisibility;
+    workbookSheetIndex?: number;
+}
+interface XlsxImageRect {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+/** Rendered column widths and row heights in logical pixels, indexed by worksheet coordinates. */
+interface XlsxDrawingLayout {
+    columnWidths: readonly number[];
+    rowHeights: readonly number[];
+}
+type XlsxImageResizeHandlePosition = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+interface UseXlsxViewerControllerOptions {
+    /**
+     * Allows row and column resizing even while editing is disabled by `readOnly`.
+     *
+     * @default false
+     */
+    allowResizeInReadOnly?: boolean;
+    /**
+     * Defers loading until `continueDeferredLoad()` is called when the file is larger than this byte threshold.
+     * Set to `0` to parse immediately.
+     *
+     * @default 0
+     * @example
+     * ```tsx
+     * useXlsxViewerController({ file, deferLoadingAboveBytes: 10 * 1024 * 1024 })
+     * ```
+     */
+    deferLoadingAboveBytes?: number;
+    /**
+     * Local workbook bytes to load. Use either `file` or `src`.
+     *
+     * @example
+     * ```tsx
+     * <XlsxViewer file={await uploadedFile.arrayBuffer()} fileName={uploadedFile.name} />
+     * ```
+     */
+    file?: ArrayBuffer;
+    /**
+     * Optional display and download name for the workbook.
+     *
+     * @example
+     * ```tsx
+     * <XlsxViewer file={buffer} fileName="forecast.xlsx" />
+     * ```
+     */
+    fileName?: string;
+    /**
+     * Rejects files larger than this byte limit and renders `fileTooLargeState`.
+     *
+     * @default 25 * 1024 * 1024
+     */
+    maxFileSizeBytes?: number;
+    /**
+     * Disables workbook edits, paste, fill, undo/redo, and other mutation actions.
+     *
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Automatically enables read-only mode for files larger than this byte threshold.
+     * Set to `0` to disable the automatic switch.
+     *
+     * @default 0
+     */
+    readOnlyAboveBytes?: number;
+    /**
+     * Includes hidden and very hidden workbook sheets in the sheet tabs and controller state.
+     *
+     * @default false
+     */
+    showHiddenSheets?: boolean;
+    /**
+     * Skips OOXML ZIP/XML parsing and relies on `@dukelib/sheets-wasm` metadata only.
+     * This is automatically used for legacy `.xls` files.
+     *
+     * @default false
+     */
+    skipXmlParsing?: boolean;
+    /**
+     * Remote workbook URL to fetch and load. Use either `src` or `file`.
+     *
+     * @example
+     * ```tsx
+     * <XlsxViewer src="/workbooks/report.xlsx" />
+     * ```
+     */
+    src?: string;
+    /**
+     * Parses supported workbook data in a Web Worker so large files do not block React rendering.
+     *
+     * @default true
+     */
+    useWorker?: boolean;
+}
+interface XlsxViewerController {
+    activeCell: XlsxCellAddress | null;
+    activeCellAddress: string | null;
+    activeSheet: XlsxSheetData | null;
+    activeSheetIndex: number;
+    activeTab: XlsxWorkbookTab | null;
+    activeTabIndex: number;
+    canDownload: boolean;
+    canExport: boolean;
+    canLoadDeferred: boolean;
+    canRedo: boolean;
+    canUndo: boolean;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    /** Adds a Duke-supported form control to a visible worksheet and returns its worksheet-local index. */
+    addFormControl: (input: XlsxFormControlInput, sheetIndex?: number) => number | null;
+    clearSelectedCells: () => void;
+    clearSelection: () => void;
+    /** Removes all render-only range highlights. */
+    clearHighlightedRanges: () => void;
+    /** Replaces the highlights with validated A1 ranges. Returns false without changing state if any reference cannot be resolved. */
+    highlightRanges: (references: string | readonly string[], options?: XlsxHighlightRangeOptions) => boolean;
+    highlightedRanges: XlsxRangeHighlight[];
+    continueDeferredLoad: () => void;
+    copySelectionToClipboard: () => Promise<boolean>;
+    defaultZoomScale: number;
+    deferredLoadFileSize: number | null;
+    defineNamedRange: (name: string, range?: XlsxCellRange | null) => void;
+    displayFileName: string;
+    download: () => void;
+    charts: XlsxChart[];
+    chartsheets: XlsxChartsheet[];
+    exportCsv: () => void;
+    exportXlsx: () => void;
+    /** The current workbook as XLSX bytes, the same bytes `exportXlsx()` downloads; `null` before a workbook loads. */
+    getXlsxBytes: () => Uint8Array | null;
+    error: Error | null;
+    file?: ArrayBuffer;
+    fillSelection: (targetRange: XlsxCellRange) => void;
+    clearSelectedChart: () => void;
+    clearSelectedChartElement: () => void;
+    clearSelectedImage: () => void;
+    getChartById: (id: string) => XlsxChart | null;
+    getChartSeriesFormula: (chartId: string, seriesIndex: number) => string;
+    getChartsheetById: (id: string) => XlsxChartsheet | null;
+    formControls: XlsxFormControl[];
+    getSheetCharts: (sheetIndex?: number) => XlsxChart[];
+    getSheetFormControls: (sheetIndex?: number) => XlsxFormControl[];
+    /** Resolves a list/dropdown input range to its current formatted item labels. */
+    getFormControlItems: (controlIndex: number, sheetIndex?: number) => string[];
+    getImageById: (id: string) => XlsxImage | null;
+    getSheetImages: (sheetIndex?: number) => XlsxImage[];
+    getSheetShapes: (sheetIndex?: number) => XlsxShape[];
+    getClipboardData: () => XlsxClipboardData | null;
+    getCellDisplayValue: (cell?: XlsxCellAddress | null) => string;
+    getCellFormula: (cell?: XlsxCellAddress | null) => string;
+    getCellSnapshotAsync?: (workbookSheetIndex: number, row: number, col: number) => Promise<{
+        displayValue: string;
+        formula: string;
+    }>;
+    isLoadDeferred: boolean;
+    isLoading: boolean;
+    isChartsLoading: boolean;
+    isWorkerBacked?: boolean;
+    images: XlsxImage[];
+    moveChartBy: (id: string, deltaX: number, deltaY: number) => void;
+    shapes: XlsxShape[];
+    /** Merges the selection; defaults to preserving its existing alignment. */
+    mergeSelection: (mode?: XlsxMergeMode) => void;
+    maxZoomScale: number;
+    minZoomScale: number;
+    moveImageBy: (id: string, deltaX: number, deltaY: number) => void;
+    removeActiveSheet: () => void;
+    /** Removes a Duke-supported control by its worksheet-local index. */
+    removeFormControl: (controlIndex: number, sheetIndex?: number) => boolean;
+    readOnly: boolean;
+    recalculate: () => void;
+    revision: number;
+    resetZoom: () => void;
+    resizeChartBy: (id: string, handle: XlsxImageResizeHandlePosition, deltaX: number, deltaY: number) => void;
+    resizeImageBy: (id: string, handle: XlsxImageResizeHandlePosition, deltaX: number, deltaY: number) => void;
+    resizeColumn: (col: number, widthPx: number) => void;
+    resizeRow: (row: number, heightPx: number) => void;
+    redo: () => void;
+    pasteFromClipboard: () => Promise<boolean>;
+    pasteStructuredClipboardData: (payload: string) => boolean;
+    pasteText: (text: string) => boolean;
+    selectedRangeAddress: string | null;
+    selectedValue: string;
+    selectedFormula: string;
+    /**
+     * Sets the formula for a cell in the active worksheet.
+     *
+     * Pass an A1-style formula body or formula string, for example `"SUM(A1:A3)"`
+     * or `"=SUM(A1:A3)"`. The mutation is recorded in undo history and is included
+     * in exported workbook bytes.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param formula Formula text to write. Pass an empty string to clear the formula.
+     */
+    setCellFormula: (cell: XlsxCellAddress, formula: string) => void;
+    /**
+     * Applies persisted Excel style properties to a cell in the active worksheet.
+     *
+     * This mutates workbook data, records undo history, refreshes the viewer, and
+     * is included in exported XLSX bytes. Use the `getCellStyle` viewer prop only
+     * for render-time CSS overrides that should not modify the workbook.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param style Partial Excel style patch to apply to the target cell.
+     */
+    setCellStyle: (cell: XlsxCellAddress, style: XlsxCellStyleInput) => void;
+    /**
+     * Sets the value for a cell in the active worksheet.
+     *
+     * User-entered strings are coerced to booleans or numbers when they match
+     * Excel-like input. Prefix text with an apostrophe to force literal text.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param value Text entered by the user.
+     */
+    setCellValue: (cell: XlsxCellAddress, value: string) => void;
+    /**
+     * Applies persisted Excel style properties to every cell in a range.
+     *
+     * This mutates workbook data, records undo history, refreshes the viewer, and
+     * is included in exported XLSX bytes.
+     *
+     * @param range Zero-based cell range in the active worksheet.
+     * @param style Partial Excel style patch to apply to the target range.
+     */
+    setRangeStyle: (range: XlsxCellRange, style: XlsxCellStyleInput) => void;
+    setZoomScale: (zoomScale: number) => void;
+    selectCell: (cell: XlsxCellAddress, options?: {
+        extend?: boolean;
+    }) => void;
+    selectChart: (id: string | null) => void;
+    selectChartElement: (selection: XlsxChartElementSelection | null) => void;
+    selectRange: (range: XlsxCellRange) => void;
+    selection: XlsxCellRange | null;
+    setActiveSheetIndex: (index: number) => void;
+    setActiveTabIndex: (index: number) => void;
+    selectedChart: XlsxChart | null;
+    selectedChartElement: XlsxChartElementSelection | null;
+    selectedChartFormula: string | null;
+    selectedChartId: string | null;
+    selectedCellFormula: string;
+    selectedFormulaTarget: XlsxFormulaTarget;
+    selectedImage: XlsxImage | null;
+    selectedImageId: string | null;
+    setSelectedFormula: (formula: string) => boolean;
+    setSelectedCellFormula: (formula: string) => void;
+    /**
+     * Applies persisted Excel style properties to the active cell.
+     *
+     * No-ops when there is no active cell, when editing is disabled, or when no
+     * workbook is loaded. The mutation is recorded in undo history and is included
+     * in exported XLSX bytes.
+     *
+     * @param style Partial Excel style patch to apply to the active cell.
+     */
+    setSelectedCellStyle: (style: XlsxCellStyleInput) => void;
+    setSelectedCellValue: (value: string) => void;
+    sheets: XlsxSheetData[];
+    src?: string;
+    sortState: XlsxTableSortState | null;
+    sortTable: (tableName: string, columnIndex: number, direction: XlsxTableSortDirection) => void;
+    setChartSeriesFormula: (chartId: string, seriesIndex: number, formula: string) => boolean;
+    selectImage: (id: string | null) => void;
+    setChartRect: (id: string, rect: XlsxImageRect, layout?: XlsxDrawingLayout) => void;
+    setImageRect: (id: string, rect: XlsxImageRect, layout?: XlsxDrawingLayout) => void;
+    getRowsBatchAsync?: (workbookSheetIndex: number, startRow: number, rowCount: number) => Promise<unknown[] | null>;
+    tables: XlsxTable[];
+    tabs: XlsxWorkbookTab[];
+    undo: () => void;
+    unmergeSelection: () => void;
+    updateChart: (id: string, patch: Partial<XlsxChart>) => void;
+    /** Updates a Duke-supported control and participates in undo/redo and export. */
+    updateFormControl: (controlIndex: number, patch: XlsxFormControlPatch, sheetIndex?: number) => boolean;
+    workbook: Workbook | null;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomScale: number;
+    getActiveWorksheet: () => Worksheet | null;
+    addSheet: (name?: string) => void;
+}
+interface XlsxViewerSelection {
+    activeCell: XlsxCellAddress | null;
+    activeCellAddress: string | null;
+    clearSelection: () => void;
+    selectedRangeAddress: string | null;
+    selectCell: (cell: XlsxCellAddress, options?: {
+        extend?: boolean;
+    }) => void;
+    selectRange: (range: XlsxCellRange) => void;
+    selection: XlsxCellRange | null;
+}
+interface XlsxViewerZoom {
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    defaultZoomScale: number;
+    maxZoomScale: number;
+    minZoomScale: number;
+    resetZoom: () => void;
+    setZoomScale: (zoomScale: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomScale: number;
+}
+type XlsxContextMenuActionId = "cut" | "copy" | "paste" | "clearContents" | "editCell" | "undo" | "redo" | "mergeCells" | "mergeAndCenter" | "mergeAcross" | "unmergeCells" | "sortAscending" | "sortDescending" | "selectRow" | "selectColumn" | "selectAll";
+interface XlsxContextMenuAction {
+    id: XlsxContextMenuActionId;
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    destructive?: boolean;
+    separatorBefore?: boolean;
+}
+interface XlsxContextMenuContext {
+    kind: "cell" | "row" | "column" | "sheet";
+    cell: XlsxCellAddress;
+    selection: XlsxCellRange;
+    sheetIndex: number;
+    sheetName: string;
+    readOnly: boolean;
+}
+interface XlsxViewerEditing {
+    addSheet: (name?: string) => void;
+    addFormControl: (input: XlsxFormControlInput, sheetIndex?: number) => number | null;
+    canRedo: boolean;
+    canUndo: boolean;
+    clearSelectedCells: () => void;
+    copySelectionToClipboard: () => Promise<boolean>;
+    defineNamedRange: (name: string, range?: XlsxCellRange | null) => void;
+    fillSelection: (targetRange: XlsxCellRange) => void;
+    formControls: XlsxFormControl[];
+    getClipboardData: () => XlsxClipboardData | null;
+    getCellDisplayValue: (cell?: XlsxCellAddress | null) => string;
+    getCellFormula: (cell?: XlsxCellAddress | null) => string;
+    getFormControlItems: (controlIndex: number, sheetIndex?: number) => string[];
+    getSheetFormControls: (sheetIndex?: number) => XlsxFormControl[];
+    mergeSelection: (mode?: XlsxMergeMode) => void;
+    pasteFromClipboard: () => Promise<boolean>;
+    pasteStructuredClipboardData: (payload: string) => boolean;
+    pasteText: (text: string) => boolean;
+    removeActiveSheet: () => void;
+    removeFormControl: (controlIndex: number, sheetIndex?: number) => boolean;
+    readOnly: boolean;
+    redo: () => void;
+    selectedCellFormula: string;
+    selectedChartFormula: string | null;
+    selectedFormula: string;
+    selectedFormulaTarget: XlsxFormulaTarget;
+    selectedValue: string;
+    /**
+     * Sets the formula for a cell in the active worksheet.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param formula Formula text to write. Pass an empty string to clear the formula.
+     */
+    setCellFormula: (cell: XlsxCellAddress, formula: string) => void;
+    /**
+     * Applies persisted Excel style properties to a cell in the active worksheet.
+     *
+     * The mutation is recorded in undo history and is included in exported XLSX
+     * bytes. This is different from the `getCellStyle` render override prop.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param style Partial Excel style patch to apply to the target cell.
+     */
+    setCellStyle: (cell: XlsxCellAddress, style: XlsxCellStyleInput) => void;
+    /**
+     * Sets the value for a cell in the active worksheet.
+     *
+     * @param cell Zero-based row and column address in the active worksheet.
+     * @param value Text entered by the user.
+     */
+    setCellValue: (cell: XlsxCellAddress, value: string) => void;
+    /**
+     * Applies persisted Excel style properties to every cell in a range.
+     *
+     * @param range Zero-based cell range in the active worksheet.
+     * @param style Partial Excel style patch to apply to the target range.
+     */
+    setRangeStyle: (range: XlsxCellRange, style: XlsxCellStyleInput) => void;
+    setSelectedFormula: (formula: string) => boolean;
+    setSelectedCellFormula: (formula: string) => void;
+    /**
+     * Applies persisted Excel style properties to the active cell.
+     *
+     * @param style Partial Excel style patch to apply to the active cell.
+     */
+    setSelectedCellStyle: (style: XlsxCellStyleInput) => void;
+    setSelectedCellValue: (value: string) => void;
+    undo: () => void;
+    unmergeSelection: () => void;
+    updateFormControl: (controlIndex: number, patch: XlsxFormControlPatch, sheetIndex?: number) => boolean;
+}
+interface XlsxViewerTables {
+    sortState: XlsxTableSortState | null;
+    sortTable: (tableName: string, columnIndex: number, direction: XlsxTableSortDirection) => void;
+    tables: XlsxTable[];
+}
+interface XlsxViewerImages {
+    charts: XlsxChart[];
+    clearSelectedChart: () => void;
+    clearSelectedChartElement: () => void;
+    clearSelectedImage: () => void;
+    getChartById: (id: string) => XlsxChart | null;
+    getChartSeriesFormula: (chartId: string, seriesIndex: number) => string;
+    getSheetCharts: (sheetIndex?: number) => XlsxChart[];
+    getImageById: (id: string) => XlsxImage | null;
+    getSheetImages: (sheetIndex?: number) => XlsxImage[];
+    images: XlsxImage[];
+    moveChartBy: (id: string, deltaX: number, deltaY: number) => void;
+    moveImageBy: (id: string, deltaX: number, deltaY: number) => void;
+    isChartsLoading: boolean;
+    readOnly: boolean;
+    resizeChartBy: (id: string, handle: XlsxImageResizeHandlePosition, deltaX: number, deltaY: number) => void;
+    resizeImageBy: (id: string, handle: XlsxImageResizeHandlePosition, deltaX: number, deltaY: number) => void;
+    selectedChart: XlsxChart | null;
+    selectedChartElement: XlsxChartElementSelection | null;
+    selectedChartFormula: string | null;
+    selectedChartId: string | null;
+    selectedImage: XlsxImage | null;
+    selectedImageId: string | null;
+    selectChart: (id: string | null) => void;
+    selectChartElement: (selection: XlsxChartElementSelection | null) => void;
+    selectImage: (id: string | null) => void;
+    setChartSeriesFormula: (chartId: string, seriesIndex: number, formula: string) => boolean;
+    setChartRect: (id: string, rect: XlsxImageRect, layout?: XlsxDrawingLayout) => void;
+    setImageRect: (id: string, rect: XlsxImageRect, layout?: XlsxDrawingLayout) => void;
+    updateChart: (id: string, patch: Partial<XlsxChart>) => void;
+}
+interface XlsxViewerCharts {
+    activeTab: XlsxWorkbookTab | null;
+    activeTabIndex: number;
+    charts: XlsxChart[];
+    chartsheets: XlsxChartsheet[];
+    clearSelectedChart: () => void;
+    clearSelectedChartElement: () => void;
+    getChartById: (id: string) => XlsxChart | null;
+    getChartSeriesFormula: (chartId: string, seriesIndex: number) => string;
+    getChartsheetById: (id: string) => XlsxChartsheet | null;
+    getSheetCharts: (sheetIndex?: number) => XlsxChart[];
+    isChartsLoading: boolean;
+    moveChartBy: (id: string, deltaX: number, deltaY: number) => void;
+    readOnly: boolean;
+    resizeChartBy: (id: string, handle: XlsxImageResizeHandlePosition, deltaX: number, deltaY: number) => void;
+    selectChart: (id: string | null) => void;
+    selectedChart: XlsxChart | null;
+    selectedChartElement: XlsxChartElementSelection | null;
+    selectedChartFormula: string | null;
+    selectedChartId: string | null;
+    selectChartElement: (selection: XlsxChartElementSelection | null) => void;
+    setChartSeriesFormula: (chartId: string, seriesIndex: number, formula: string) => boolean;
+    setActiveTabIndex: (index: number) => void;
+    setChartRect: (id: string, rect: XlsxImageRect, layout?: XlsxDrawingLayout) => void;
+    tabs: XlsxWorkbookTab[];
+    updateChart: (id: string, patch: Partial<XlsxChart>) => void;
+}
+type XlsxSheetThumbnailResolution = number | {
+    maxHeight?: number;
+    maxWidth?: number;
+};
+interface UseXlsxViewerThumbnailsOptions {
+    includeHeaders?: boolean;
+    resolution?: XlsxSheetThumbnailResolution;
+}
+interface XlsxSheetThumbnail {
+    aspectRatio: number;
+    contentHeight: number;
+    contentWidth: number;
+    height: number;
+    paint: (canvas: HTMLCanvasElement | null) => boolean;
+    sheet: XlsxSheetData;
+    sheetIndex: number;
+    sourceRange: XlsxCellRange;
+    width: number;
+    workbookSheetIndex: number;
+}
+interface XlsxViewerThumbnails {
+    paintThumbnail: (sheetIndex: number, canvas: HTMLCanvasElement | null) => boolean;
+    thumbnails: XlsxSheetThumbnail[];
+}
+interface XlsxActiveCellOverlayRenderProps {
+    /** Address of the active cell. For merged cells this is the merge anchor. */
+    cell: XlsxCellAddress;
+    /**
+     * Pixel rect of the active cell (spanning the full merge) within the grid's scroll content,
+     * at the current zoom. The rendered node is already positioned to fill this rect.
+     */
+    rect: XlsxImageRect;
+}
+
+type XlsxVanillaContent = Node | string | number | null;
+type XlsxVanillaStyle = Properties<string | number>;
+interface XlsxVanillaChartLoadingRenderProps {
+    chart: XlsxChart;
+    rect: XlsxImageRect;
+    stage?: "metadata" | "renderer" | "map";
+}
+interface XlsxVanillaContextMenuRenderProps {
+    context: XlsxContextMenuContext;
+    actions: XlsxContextMenuAction[];
+    runAction: (actionId: XlsxContextMenuActionId) => Promise<boolean>;
+    closeMenu: () => void;
+    position: {
+        x: number;
+        y: number;
+    };
+    isDark: boolean;
+    busy: boolean;
+    error: string | null;
+}
+interface XlsxVanillaFileTooLargeRenderProps {
+    displayFileName: string;
+    fileSizeBytes: number;
+    maxFileSizeBytes: number;
+}
+interface XlsxVanillaImageRenderProps {
+    image: XlsxImage;
+    rect: XlsxImageRect;
+    style: XlsxVanillaStyle;
+}
+interface XlsxVanillaFormControlRenderProps {
+    activate: () => void;
+    checked: boolean;
+    control: XlsxFormControl;
+    disabled: boolean;
+    items: string[];
+    label: string;
+    mixed: boolean;
+    readOnly: boolean;
+    rect: XlsxImageRect;
+    setSelected: (selected: number | number[] | undefined) => boolean;
+    setState: (state: XlsxFormControlState) => boolean;
+    setValue: (value: number) => boolean;
+    stopPropagation: (event: Event) => void;
+    style: XlsxVanillaStyle;
+    zoomFactor: number;
+}
+interface XlsxVanillaCellStyleContext {
+    cell: XlsxCellAddress;
+    hasChartHighlight: boolean;
+    hasConditionalFormat: boolean;
+    hasHyperlink: boolean;
+    hasValidation: boolean;
+    isMerged: boolean;
+    isTableHeader: boolean;
+    resolvedStyle: XlsxVanillaStyle;
+    sheetName: string;
+    value: string;
+    workbookSheetIndex: number;
+}
+interface XlsxVanillaViewerOptions extends UseXlsxViewerControllerOptions {
+    highlightedRanges?: string | readonly string[] | null;
+    autoScrollToHighlightedRanges?: boolean;
+    highlightClassName?: string;
+    className?: string;
+    emptyState?: XlsxVanillaContent;
+    enableCanvasSelectionAnimation?: boolean;
+    enableGestureZoom?: boolean;
+    experimentalCanvas?: boolean;
+    errorState?: XlsxVanillaContent | ((error: Error) => XlsxVanillaContent);
+    fileTooLargeState?: XlsxVanillaContent | ((props: XlsxVanillaFileTooLargeRenderProps) => XlsxVanillaContent);
+    getCellStyle?: (context: XlsxVanillaCellStyleContext) => XlsxVanillaStyle | null | undefined;
+    headerBackgroundColor?: string;
+    headerTextColor?: string;
+    height?: XlsxVanillaStyle["height"];
+    isDark?: boolean;
+    loadingState?: XlsxVanillaContent;
+    onFormControlAction?: (event: XlsxFormControlActionEvent) => void;
+    onFormControlChange?: (event: XlsxFormControlChangeEvent) => void;
+    renderChartLoading?: (props: XlsxVanillaChartLoadingRenderProps) => XlsxVanillaContent;
+    renderContextMenu?: (props: XlsxVanillaContextMenuRenderProps) => XlsxVanillaContent;
+    enableContextMenu?: boolean;
+    contextMenuClassName?: string;
+    contextMenuStyle?: XlsxVanillaStyle & {
+        [property: `--${string}`]: string | number | undefined;
+    };
+    renderFormControl?: (props: XlsxVanillaFormControlRenderProps) => XlsxVanillaContent;
+    renderImage?: (props: XlsxVanillaImageRenderProps) => XlsxVanillaContent;
+    rounded?: boolean;
+    selectionColor?: string;
+    selectionFillColor?: string;
+    selectionHeaderColor?: string;
+    renderActiveCellOverlay?: (props: XlsxActiveCellOverlayRenderProps) => XlsxVanillaContent;
+    showImages?: boolean;
+    showDefaultToolbar?: boolean;
+    toolbar?: XlsxVanillaContent | ((controller: XlsxViewerController) => XlsxVanillaContent);
+}
+interface XlsxVanillaViewer {
+    readonly element: HTMLElement;
+    getController(): XlsxViewerController | null;
+    reload(): void;
+    setOptions(options: Partial<XlsxVanillaViewerOptions>): void;
+    subscribe(listener: (controller: XlsxViewerController) => void): () => void;
+    destroy(): void;
+}
+
+declare function formatBinaryBytes(bytes: number): string;
+declare class XlsxFileSizeLimitExceededError extends Error {
+    fileSizeBytes: number;
+    maxFileSizeBytes: number;
+    constructor(fileSizeBytes: number, maxFileSizeBytes: number);
+}
+
+type XlsxWasmSource = string | URL | Request | Response | BufferSource | WebAssembly.Module;
+type WorkerWasmSource = string | ArrayBuffer | WebAssembly.Module;
+declare function setWasmSource(source: XlsxWasmSource): void;
+declare function initWasm(source?: XlsxWasmSource): Promise<typeof _dukelib_sheets_wasm>;
+declare function canUseConfiguredWasmSourceInWorker(): boolean;
+declare function getConfiguredWorkerWasmSource(): WorkerWasmSource | undefined;
+declare function getSheetsWasmModule(): Promise<typeof _dukelib_sheets_wasm>;
+
+declare class XlsxViewer implements XlsxVanillaViewer {
+    readonly element: HTMLElement;
+    private readonly viewer;
+    constructor(container: Element | DocumentFragment, options?: XlsxVanillaViewerOptions);
+    getController(): XlsxViewerController | null;
+    setOptions(options: Partial<XlsxVanillaViewerOptions>): void;
+    reload(): void;
+    subscribe(listener: (controller: XlsxViewerController) => void): () => void;
+    destroy(): void;
+}
+declare function createXlsxViewer(container: Element | DocumentFragment, options?: XlsxVanillaViewerOptions): XlsxViewer;
+declare function __createControlledViewer(container: Element | DocumentFragment): {
+    update(props: unknown): void;
+    destroy(): void;
+};
+declare function __createContentNode(node: Node): unknown;
+declare function __createContentRoot(container: Element): {
+    update(content: unknown): void;
+    destroy(): void;
+};
+
+export { type XlsxFormControlState as $, type XlsxClipboardData as A, type XlsxConditionalColorScaleRule as B, type XlsxConditionalDataBarRule as C, type XlsxConditionalFormatIcon as D, type XlsxConditionalFormatRule as E, type XlsxConditionalFormatValueObject as F, type XlsxConditionalIconSetRule as G, type XlsxConditionalStyledRule as H, type XlsxContextMenuAction as I, type XlsxContextMenuActionId as J, type XlsxContextMenuContext as K, type XlsxDataValidation as L, type XlsxDrawingLayout as M, XlsxFileSizeLimitExceededError as N, type XlsxFormControl as O, type XlsxFormControlActionEvent as P, type XlsxFormControlCaption as Q, type XlsxFormControlCaptionInput as R, type XlsxFormControlCaptionRun as S, type XlsxFormControlChangeEvent as T, type UseXlsxViewerControllerOptions as U, type XlsxFormControlInput as V, type XlsxFormControlKind as W, type XlsxParsedRange as X, type XlsxFormControlKindInput as Y, type XlsxFormControlPatch as Z, type XlsxFormControlSelectionMode as _, type UseXlsxViewerThumbnailsOptions as a, type XlsxFormulaTarget as a0, type XlsxFreezePanes as a1, type XlsxHighlightRangeOptions as a2, type XlsxImage as a3, type XlsxImageAnchor as a4, type XlsxImageMarker as a5, type XlsxImageRect as a6, type XlsxImageResizeHandlePosition as a7, type XlsxMergeMode as a8, type XlsxRangeHighlight as a9, type XlsxVanillaStyle as aA, type XlsxVanillaViewer as aB, type XlsxVanillaViewerOptions as aC, XlsxViewer as aD, type XlsxViewerCharts as aE, type XlsxViewerController as aF, type XlsxViewerEditing as aG, type XlsxViewerImages as aH, type XlsxViewerSelection as aI, type XlsxViewerTables as aJ, type XlsxViewerThumbnails as aK, type XlsxViewerZoom as aL, type XlsxWasmSource as aM, type XlsxWorkbookTab as aN, createXlsxViewer as aO, initWasm as aP, setWasmSource as aQ, type WorkerWasmSource as aR, __createContentNode as aS, __createContentRoot as aT, __createControlledViewer as aU, canUseConfiguredWasmSourceInWorker as aV, formatBinaryBytes as aW, getConfiguredWorkerWasmSource as aX, getSheetsWasmModule as aY, type XlsxResolvedCellStyle as aa, type XlsxShape as ab, type XlsxShapeFill as ac, type XlsxShapeParagraph as ad, type XlsxShapeStroke as ae, type XlsxShapeTextBox as af, type XlsxShapeTextRun as ag, type XlsxSheetData as ah, type XlsxSheetThumbnail as ai, type XlsxSheetThumbnailResolution as aj, type XlsxSheetVisibility as ak, type XlsxSparkline as al, type XlsxTable as am, type XlsxTableColumn as an, type XlsxTableSortDirection as ao, type XlsxTableSortState as ap, type XlsxTableStyleDefinition as aq, type XlsxTableStyleInfo as ar, type XlsxThemePalette as as, type XlsxVanillaCellStyleContext as at, type XlsxVanillaChartLoadingRenderProps as au, type XlsxVanillaContent as av, type XlsxVanillaContextMenuRenderProps as aw, type XlsxVanillaFileTooLargeRenderProps as ax, type XlsxVanillaFormControlRenderProps as ay, type XlsxVanillaImageRenderProps as az, type XlsxActiveCellOverlayRenderProps as b, type XlsxCellAddress as c, type XlsxCellAlignmentInput as d, type XlsxCellBorderEdgeInput as e, type XlsxCellBorderStyleInput as f, type XlsxCellFillStyleInput as g, type XlsxCellFontStyleInput as h, type XlsxCellGradientStopInput as i, type XlsxCellNumberFormatInput as j, type XlsxCellProtectionInput as k, type XlsxCellRange as l, type XlsxCellStyleColorInput as m, type XlsxCellStyleInput as n, type XlsxChart as o, type XlsxChartAxis as p, type XlsxChartDataLabels as q, type XlsxChartElementSelection as r, type XlsxChartLegend as s, type XlsxChartPointDataLabel as t, type XlsxChartPointStyle as u, type XlsxChartReference as v, type XlsxChartSeries as w, type XlsxChartTypeGroup as x, type XlsxChartWall as y, type XlsxChartsheet as z };