@rowsncolumns/spreadsheet 10.2.68

package/dist/cjs/types.d.ts

@@ -0,0 +1,1215 @@
+import type { BooleanCondition, SheetRange, SortOrder } from "@rowsncolumns/common-types";
+import type { FormulaResult } from "@rowsncolumns/fast-formula-parser";
+import type { CellInterface, GridRange, SelectionArea, Style } from "@rowsncolumns/grid";
+import type { ColorIndex } from "./themes";
+export type { BooleanCondition, CellData, ConditionType, ConditionValue, CustomFormulaResult, DataValidationInputMessage, DataValidationRule, DataValidationRuleAlert, ErrorValue, ExtendedValue, Mention, PivotGroup, PivotTable, PivotValue, PivotValueSummarizeFunction, SheetCoordinate, SheetRange, SortOrder, StructuredValue, StyleReference, TextFormatRun, DataValidationRuleRecord, } from "@rowsncolumns/common-types";
+export { CONDITION_TYPES } from "@rowsncolumns/common-types";
+/**
+ * Utility type for values that can be undefined or null
+ */
+export type Maybe<T> = T | undefined | null;
+/**
+ * Worksheet-level protection (`<sheetProtection>`), mirroring the OOXML
+ * `CT_SheetProtection` attribute set 1:1 in camelCase. `sheet` is the master
+ * switch Excel sets (`sheet="1"`) when a worksheet is protected. For every
+ * action flag, `true` prohibits the action, `false` allows it, and an absent
+ * flag falls back to the OOXML schema default (prohibited for everything
+ * except `selectLockedCells`/`selectUnlockedCells`). The password fields ride
+ * along verbatim for round-trip fidelity — the UI never verifies them.
+ * Enforcement is UI-layer only (Excel-strength advisory), owned by
+ * `canEditCell` + the per-interaction gates in `@rowsncolumns/spreadsheet-state`;
+ * see `isActionBlockedBySheetProtection`.
+ */
+export type SheetProtection = {
+    sheet?: Maybe<boolean>;
+    objects?: Maybe<boolean>;
+    scenarios?: Maybe<boolean>;
+    formatCells?: Maybe<boolean>;
+    formatColumns?: Maybe<boolean>;
+    formatRows?: Maybe<boolean>;
+    insertColumns?: Maybe<boolean>;
+    insertRows?: Maybe<boolean>;
+    insertHyperlinks?: Maybe<boolean>;
+    deleteColumns?: Maybe<boolean>;
+    deleteRows?: Maybe<boolean>;
+    selectLockedCells?: Maybe<boolean>;
+    sort?: Maybe<boolean>;
+    autoFilter?: Maybe<boolean>;
+    pivotTables?: Maybe<boolean>;
+    selectUnlockedCells?: Maybe<boolean>;
+    /** Legacy 16-bit password hash (`password="CC1A"`). Round-trip only. */
+    password?: Maybe<string>;
+    /** Agile hash quartet (`algorithmName`/`hashValue`/`saltValue`/`spinCount`). Round-trip only. */
+    algorithmName?: Maybe<string>;
+    hashValue?: Maybe<string>;
+    saltValue?: Maybe<string>;
+    spinCount?: Maybe<number>;
+};
+export type Sheet = {
+    title: string;
+    index?: Maybe<number>;
+    sheetId: number;
+    tabColor?: Maybe<Color>;
+    hidden?: Maybe<boolean>;
+    /**
+     * Full Excel visibility state. When set, this is the source of truth;
+     * `hidden` mirrors it as `true` for both "hidden" and "veryHidden" so
+     * existing consumers that read `hidden` keep working.
+     * - "visible" (default): user sees the tab.
+     * - "hidden": user can right-click → Unhide to bring it back.
+     * - "veryHidden": only changeable via the API; not in the Unhide menu.
+     */
+    visibility?: Maybe<"visible" | "hidden" | "veryHidden">;
+    rowCount?: Maybe<number>;
+    columnCount?: Maybe<number>;
+    frozenRowCount?: Maybe<number>;
+    frozenColumnCount?: Maybe<number>;
+    showGridLines?: Maybe<boolean>;
+    showRowColHeaders?: Maybe<boolean>;
+    showZeros?: Maybe<boolean>;
+    /**
+     * Per-sheet zoom level as an integer percent (10–400). Mirrors
+     * OOXML `<sheetView zoomScale="...">`. Default 100 when omitted.
+     * Convert to canvas-grid `scale` via `zoomScale / 100`.
+     */
+    zoomScale?: Maybe<number>;
+    /**
+     * The sheet displays right-to-left (column A on the right). Mirrors
+     * OOXML `<sheetView rightToLeft="1">`. Round-tripped and queryable;
+     * the canvas grid does NOT mirror yet. Default false when omitted.
+     */
+    rightToLeft?: Maybe<boolean>;
+    merges?: Maybe<GridRange[]>;
+    basicFilter?: Maybe<FilterView>;
+    rowMetadata?: Maybe<Maybe<DimensionProperties>[]>;
+    columnMetadata?: Maybe<Maybe<DimensionProperties>[]>;
+    /**
+     * Sheet default row height in pixels. Used when a row has no explicit
+     * `rowMetadata` height. Mirrors OOXML `<sheetFormatPr defaultRowHeight>`
+     * (which is stored in points and converted on round-trip).
+     */
+    defaultRowHeight?: Maybe<number>;
+    /**
+     * Sheet default column width in pixels. Mirrors OOXML
+     * `<sheetFormatPr defaultColWidth>` (stored in characters, converted).
+     */
+    defaultColumnWidth?: Maybe<number>;
+    /**
+     * Outline-direction preferences for row/column grouping. Mirrors
+     * OOXML `<sheetPr><outlinePr summaryBelow summaryRight/></sheetPr>`.
+     * Both default to `true` when omitted (matches Excel's defaults).
+     *   - `summaryBelow`: summary row sits below its group (true) or above (false).
+     *   - `summaryRight`: summary column sits right of its group (true) or left (false).
+     */
+    outlinePr?: Maybe<{
+        summaryBelow?: Maybe<boolean>;
+        summaryRight?: Maybe<boolean>;
+    }>;
+    /**
+     * Worksheet-level protection flags (`<sheetProtection>`). When
+     * `sheetProtection.sheet` is enabled, LOCKED cells (a cell is locked unless
+     * its `protection.locked` is `false` — Excel's default) refuse edits and
+     * structural operations gate on their matching action flag. Absent =
+     * unprotected.
+     */
+    sheetProtection?: Maybe<SheetProtection>;
+};
+export type BandedRange = BandedDefinition & {
+    bandedRangeId: number | string;
+    range: SheetRange;
+};
+export type BandedDefinition = {
+    rowProperties?: Maybe<BandingProperties>;
+    columnProperties?: Maybe<BandingProperties>;
+};
+export type BandingProperties = {
+    headerColor?: Maybe<Color | string>;
+    footerColor?: Maybe<Color | string>;
+    firstBandColor?: Maybe<Color | string>;
+    secondBandColor?: Maybe<Color | string>;
+    headerBorder?: Maybe<Borders>;
+    footerBorder?: Maybe<Borders>;
+    firstBandBorder?: Maybe<Borders>;
+    secondBandBorder?: Maybe<Borders>;
+    totalRowColor?: Maybe<Color | string>;
+    totalRowBorder?: Maybe<Borders>;
+};
+export type NamedRange = {
+    namedRangeId: string | number;
+    name: string;
+    /**
+     * This can point to a sheet reference
+     */
+    range?: Maybe<SheetRange>;
+    /**
+     * TBD: Allow formula support
+     */
+    value?: Maybe<string | FormulaResult>;
+    /**
+     * Hidden defined name (`hidden="1"` in OOXML). Excel uses this for
+     * names that shouldn't appear in the Name Box / Name Manager but still
+     * affect calculation. Preserved for round-trip fidelity; UI consumers
+     * can filter these out of pickers.
+     */
+    hidden?: Maybe<boolean>;
+};
+export type EmbeddedObjectProperty = {
+    resizable?: Maybe<boolean>;
+    draggable?: Maybe<boolean>;
+    rotatable?: Maybe<boolean>;
+};
+export type EmbeddedObject = {
+    embedId: string | number;
+    spec: EmbedImageSpec | EmbedObjectSpec | EmbedTextBoxSpec | EmbedShapeSpec | AnyEmbed;
+    position: EmbeddedObjectPosition;
+    rotation?: Maybe<number>;
+    borderColor?: Maybe<string>;
+    lockAspectRatio?: Maybe<boolean>;
+} & EmbeddedObjectProperty;
+export type EmbedImageSpec = {
+    type: "image";
+    description?: Maybe<string>;
+    imageUrl: string;
+};
+export type TextBoxRichTextRun = {
+    text: string;
+    format?: Maybe<TextFormat>;
+};
+export type EmbedTextBoxSpec = {
+    type: "textbox";
+    text?: Maybe<string>;
+    richText?: Maybe<TextBoxRichTextRun[]>;
+    textFormat?: Maybe<TextFormat>;
+    verticalAlignment?: Maybe<VerticalAlign>;
+    horizontalAlignment?: Maybe<HorizontalAlign>;
+    backgroundColor?: Maybe<Color>;
+    borders?: Maybe<Borders>;
+    wrapStrategy?: Maybe<WrapStrategy>;
+    textRotation?: Maybe<number | "vertical">;
+    padding?: Maybe<number>;
+};
+/**
+ * Preset geometries the shape renderer understands — the common subset of
+ * OOXML `<a:prstGeom prst="…">` (ECMA-376 defines ~187; unrecognized presets
+ * are carried as their raw string and may render as a plain rectangle).
+ * `(string & {})` keeps autocomplete for the known names while still
+ * accepting any preset for lossless round-trip.
+ */
+export type ShapePresetKind = "rect" | "roundRect" | "snipSingleCornerRect" | "ellipse" | "triangle" | "rightTriangle" | "diamond" | "parallelogram" | "trapezoid" | "pentagon" | "hexagon" | "octagon" | "star5" | "rightArrow" | "leftArrow" | "upArrow" | "downArrow" | "leftRightArrow" | "chevron" | "wedgeRectCallout" | "wedgeRoundRectCallout" | "wedgeEllipseCallout" | (string & {});
+/**
+ * A shape's outline geometry. `adjustments` mirrors the preset's `<a:avLst>`
+ * adjust guides keyed by name (`adj`, `adj1`, `adj2`, …), values in the
+ * preset's own guide units (typically 1/1000 of a percent — `roundRect`'s
+ * default corner radius is `adj: 16667` ≈ 16.67% of the shorter side).
+ * An empty/omitted map means the preset's defaults.
+ */
+export type ShapeGeometry = {
+    preset: ShapePresetKind;
+    adjustments?: Maybe<Record<string, number>>;
+};
+/** One color stop of a shape gradient fill. `position` is a 0–1 fraction along
+ * the gradient. Distinct from the cell-fill `GradientStop` (string-color,
+ * OOXML `<gradientFill>`): shape stops are DrawingML and may be theme colors. */
+export type ShapeGradientStop = {
+    position: number;
+    color: Color;
+    /** 0–1; omitted = fully opaque. Mirrors `<a:alpha>`. */
+    opacity?: Maybe<number>;
+};
+/**
+ * A shape's fill. Discriminated on `kind` (the embed spec's own `type` field
+ * is taken by the `"shape"` discriminant). Theme-driven fills (`<xdr:style>`
+ * `<a:fillRef>`) are resolved by the importer into one of these using the
+ * referenced scheme color — see {@link ShapeStyleRefs} for re-resolution on
+ * theme change.
+ */
+export type ShapeFill = {
+    kind: "none";
+} | {
+    kind: "solid";
+    color: Color;
+    /** 0–1; omitted = fully opaque. */
+    opacity?: Maybe<number>;
+} | {
+    kind: "gradient";
+    stops: ShapeGradientStop[];
+    /** Linear gradient angle in degrees, clockwise from pointing right (OOXML `ang` / 60000). */
+    angle?: Maybe<number>;
+    /** Omitted = "linear". */
+    shading?: Maybe<"linear" | "radial">;
+};
+/** Dash pattern of a shape outline — OOXML `<a:prstDash val="…">` (subset). */
+export type ShapeLineDash = "solid" | "dot" | "dash" | "dashDot" | "longDash" | "longDashDot" | "longDashDotDot";
+/** A shape's outline (`<a:ln>`). Distinct from cell `Borders`: one stroke around the geometry. */
+export type ShapeOutline = {
+    color?: Maybe<Color>;
+    /** Stroke width in px (OOXML `w` EMU / 9525). Omitted = 1px hairline. */
+    width?: Maybe<number>;
+    dash?: Maybe<ShapeLineDash>;
+    /** 0–1; omitted = fully opaque. */
+    opacity?: Maybe<number>;
+};
+/** A shape's outer shadow (`<a:effectLst><a:outerShdw>`), the only effect rendered. */
+export type ShapeShadow = {
+    color?: Maybe<Color>;
+    /** 0–1; omitted ≈ 0.4 (Excel's subtle preset). */
+    opacity?: Maybe<number>;
+    /** Blur radius in px. */
+    blurRadius?: Maybe<number>;
+    offsetXPixels?: Maybe<number>;
+    offsetYPixels?: Maybe<number>;
+};
+/**
+ * The shape's theme style block (`<xdr:sp><xdr:style>`): fill/line/effect/font
+ * as *references* into the document theme's format-scheme tables plus a scheme
+ * color. Kept alongside the resolved `fill`/`outline`/`shadow` so a theme
+ * change (or export) can re-derive them the way Excel does; when both are
+ * present the explicit resolved properties win.
+ */
+export type ShapeStyleRef = {
+    /** 1-based index into the theme's fill/line/effect style lists (`idx`). 0 = none. */
+    index: number;
+    color: Color;
+};
+export type ShapeStyleRefs = {
+    fill?: Maybe<ShapeStyleRef>;
+    line?: Maybe<ShapeStyleRef>;
+    effect?: Maybe<ShapeStyleRef>;
+    font?: Maybe<{
+        scheme: "major" | "minor";
+        color?: Maybe<Color>;
+    }>;
+};
+/**
+ * Text hosted inside a shape (`<xdr:txBody>`) — same content model as
+ * {@link EmbedTextBoxSpec} (in OOXML a text box IS a `rect` shape with text),
+ * minus the box-level background/borders, which a shape expresses through
+ * `fill`/`outline`.
+ */
+export type ShapeTextBody = {
+    /** Plain text (used if richText is not provided). */
+    text?: Maybe<string>;
+    /** Rich text with per-run formatting. */
+    richText?: Maybe<TextBoxRichTextRun[]>;
+    /** Default text format for the whole body. */
+    textFormat?: Maybe<TextFormat>;
+    verticalAlignment?: Maybe<VerticalAlign>;
+    horizontalAlignment?: Maybe<HorizontalAlign>;
+    wrapStrategy?: Maybe<WrapStrategy>;
+    textRotation?: Maybe<number | "vertical">;
+    /** Inner padding in px (average of OOXML l/r/t/b insets). */
+    padding?: Maybe<number>;
+};
+/**
+ * A drawing shape (`<xdr:sp>` with a preset geometry). Position/size/rotation
+ * live on the wrapping {@link EmbeddedObject}; the spec carries everything
+ * that draws inside that frame. A shape with only `textBody` set and a `rect`
+ * preset is equivalent to a {@link EmbedTextBoxSpec}.
+ */
+export type EmbedShapeSpec = {
+    type: "shape";
+    /** Author-visible name from `<xdr:cNvPr name>` (e.g. "Rectangle: Rounded Corners 1"). */
+    name?: Maybe<string>;
+    geometry: ShapeGeometry;
+    fill?: Maybe<ShapeFill>;
+    outline?: Maybe<ShapeOutline>;
+    shadow?: Maybe<ShapeShadow>;
+    styleRefs?: Maybe<ShapeStyleRefs>;
+    textBody?: Maybe<ShapeTextBody>;
+    /** Mirror the geometry across its own axis (`<a:xfrm flipH/flipV>`). */
+    flipHorizontal?: Maybe<boolean>;
+    flipVertical?: Maybe<boolean>;
+};
+export type AnyEmbed = Record<string, any> & {
+    type: string;
+};
+export type EmbedObjectSpec = {
+    type: "object";
+    id: string | number;
+};
+export type EmbeddedChart = {
+    chartId: string | number;
+    spec: ChartSpec;
+    position: EmbeddedObjectPosition;
+    borderColor?: Maybe<string>;
+} & EmbeddedObjectProperty;
+export type ChartSpec = {
+    title?: Maybe<string>;
+    /** Chart title text formatting. Mirrors `<c:title><c:txPr>` /
+     * `<c:title><c:tx><c:rich>` text-run properties. */
+    titleTextFormat?: Maybe<ChartTextFormat>;
+    subtitle?: Maybe<string>;
+    backgroundColor?: Maybe<string>;
+    filterSpecs?: Maybe<FilterSpec[]>;
+    sortSpecs?: Maybe<SortSpecs[]>;
+    dataRange?: Maybe<SheetRange>;
+    hiddenDimensionStrategy?: Maybe<HIDDEN_DIMENSION_STRATEGY>;
+    verticalAxisTitle?: Maybe<string>;
+    horizontalAxisTitle?: Maybe<string>;
+    /**
+     * Legend display options. When omitted, the renderer falls back to its
+     * default (typically: show when there's more than one series). Mirrors
+     * Excel's `<c:legend><c:legendPos val="…"/>`.
+     */
+    legend?: Maybe<ChartLegendOptions>;
+    /**
+     * Data-label overrides applied to every series. Mirrors Excel's
+     * `<c:dLbls>` at the chart level. Individual series can still override
+     * via `ChartData.dataLabels` (per-series, not yet supported).
+     */
+    dataLabels?: Maybe<ChartDataLabelsOptions>;
+    /**
+     * Value axis (numeric / y-axis for column/bar/line, x for bar) options.
+     * Mirrors `<c:valAx>` formatting.
+     */
+    valueAxisOptions?: Maybe<ChartAxisOptions>;
+    /**
+     * Category axis (x-axis for column/line, y for bar) options. Mirrors
+     * `<c:catAx>` formatting.
+     */
+    categoryAxisOptions?: Maybe<ChartAxisOptions>;
+    /**
+     * Secondary value axis options. Only consulted when at least one
+     * series has `useSecondaryAxis: true`. Mirrors the second `<c:valAx>`
+     * in OOXML chart XML.
+     */
+    secondaryValueAxisOptions?: Maybe<ChartAxisOptions>;
+    /**
+     * Whether the chart frame paints with rounded corners. Mirrors the
+     * OOXML `<c:roundedCorners val="1"/>` element at the chartSpace
+     * root. Default (per spec) is `false`. When `true`, the renderer
+     * applies a small `border-radius` to the chart's outer container so
+     * the frame matches Excel's "Rounded Corners" chart style option.
+     */
+    roundedCorners?: Maybe<boolean>;
+} & (BasicChartSpec | TreemapChart | BubbleChartSpec);
+/**
+ * Text formatting applied to chart text elements (titles, axis labels,
+ * legend entries, data labels). Mirrors the relevant subset of OOXML
+ * `<c:txPr><a:p><a:pPr><a:defRPr>` properties. All fields are optional
+ * — renderers fall back to their theme-derived defaults when a field
+ * is absent.
+ */
+export type ChartTextFormat = {
+    /** Resolved hex color (`#RRGGBB`). Both `<a:srgbClr>` (literal) and
+     * `<a:schemeClr>` (theme reference with lumMod/lumOff/tint) resolve
+     * to a concrete hex during import. */
+    color?: Maybe<string>;
+    /** Font family — Excel's `<a:latin typeface=…>`. */
+    fontFamily?: Maybe<string>;
+    /** Font size in points. OOXML stores 100ths of a point in `sz`; we
+     * normalize to points (e.g. `sz="900"` → `9`). */
+    fontSize?: Maybe<number>;
+    bold?: Maybe<boolean>;
+    italic?: Maybe<boolean>;
+    underline?: Maybe<boolean>;
+    strikethrough?: Maybe<boolean>;
+};
+export type ChartLegendOptions = {
+    /** "none" suppresses the legend entirely. */
+    position?: Maybe<"top" | "bottom" | "left" | "right" | "topRight" | "none">;
+    /** Legend entry text formatting. Mirrors `<c:legend><c:txPr>`. */
+    textFormat?: Maybe<ChartTextFormat>;
+};
+export type ChartDataLabelsOptions = {
+    /** Master switch. Defaults to false when omitted. */
+    show?: Maybe<boolean>;
+    /**
+     * Where the label sits relative to the data point. Excel's full set is
+     * larger but these cover the user-visible options.
+     */
+    position?: Maybe<"center" | "inside" | "outside" | "insideEnd" | "outsideEnd" | "bestFit">;
+    /** Show the numeric value (default for most chart types). */
+    showValue?: Maybe<boolean>;
+    /** Pie/doughnut only — show category name. */
+    showCategoryName?: Maybe<boolean>;
+    /** Pie/doughnut only — show percent of total. */
+    showPercent?: Maybe<boolean>;
+    /** Show the series name (e.g. "Sales") alongside the value. */
+    showSeriesName?: Maybe<boolean>;
+    /** Label text formatting. Mirrors `<c:dLbls><c:txPr>`. */
+    textFormat?: Maybe<ChartTextFormat>;
+    /**
+     * Number-format pattern applied to the displayed value. Mirrors
+     * `<c:dLbls><c:numFmt formatCode="…"/>`. When set, the renderer
+     * formats each value through this pattern (e.g. `"$"#,##0` shows
+     * `$1,831`) before falling back to the raw numeric string. Useful
+     * for currency-styled charts that should render `$1,831` rather
+     * than `1831`.
+     */
+    numberFormatPattern?: Maybe<string>;
+};
+export type ChartAxisOptions = {
+    /** Hard minimum. When omitted, the renderer auto-scales. */
+    min?: Maybe<number>;
+    /** Hard maximum. */
+    max?: Maybe<number>;
+    /** Use a logarithmic scale. */
+    logarithmic?: Maybe<boolean>;
+    /** Render the axis in reverse direction. */
+    reverse?: Maybe<boolean>;
+    /** Show major gridlines (default true). */
+    showMajorGridlines?: Maybe<boolean>;
+    /** Show the axis line + tick labels (default true). */
+    visible?: Maybe<boolean>;
+    /** Axis tick-label text formatting. Mirrors `<c:valAx><c:txPr>` /
+     * `<c:catAx><c:txPr>`. */
+    textFormat?: Maybe<ChartTextFormat>;
+};
+export type BasicChartSpec = {
+    chartType: "bar" | "column" | "line" | "pie" | "area" | "doughnut" | "radar" | "stock" | "histogram" | "boxplot" | "waterfall" | "funnel" | "combo" | "regionMap";
+    domains: ChartData[];
+    series: ChartData[];
+    stackedType?: Maybe<BasicChartStackedType>;
+    radius?: Maybe<(string | number)[]>;
+    smooth?: Maybe<boolean>;
+    /**
+     * Doughnut only — inner radius as a fraction (0-1) of the outer
+     * radius. Default 0.5 when omitted.
+     */
+    doughnutHoleSize?: Maybe<number>;
+    /**
+     * Radar only — sub-style: "standard" (lines), "marker" (lines +
+     * points), or "filled" (filled polygon).
+     */
+    radarStyle?: Maybe<"standard" | "marker" | "filled">;
+    /**
+     * Stock only — variant: HLC, OHLC, VHLC, VOHLC. Default "HLC".
+     */
+    stockVariant?: Maybe<"HLC" | "OHLC" | "VHLC" | "VOHLC">;
+    /**
+     * Histogram only — number of bins. When omitted the renderer picks
+     * a sensible default (echarts uses Sturges' rule, plotly auto-bins).
+     */
+    binCount?: Maybe<number>;
+    /**
+     * Original authored chart type when the payload was degraded to a
+     * renderer-supported `chartType`. Persisted verbatim through the
+     * document. e.g. `"PARETO"` marks a histogram that renders as a
+     * Pareto chart: bins sorted descending plus a cumulative-percentage
+     * line on a secondary 0-100% axis, and `"REGION_MAP"` marks a filled
+     * map (OOXML chartex `<cx:regionMap>`) that renders as a choropleth.
+     */
+    sourceChartType?: Maybe<string>;
+    /**
+     * Region map (filled map / choropleth) only — the geo scope the
+     * values are plotted on, i.e. the name of a registered echarts map.
+     * `"world"` (the default when omitted) is lazily loaded by the
+     * renderer from a bundled world GeoJSON; any other name must first
+     * be registered by the host via `registerChartGeoMap(name, geoJson)`
+     * from `@rowsncolumns/charts`. Region labels come from the chart's
+     * category domain (`domains[0]`) and the first series carries the
+     * numeric values — labels that don't match a region on the map are
+     * skipped, never fatal.
+     */
+    geoScope?: Maybe<string>;
+    /**
+     * Pie-of-pie / bar-of-pie only (`sourceChartType: "OF_PIE"`) — the
+     * shape of the secondary plot: "pie" (pie-of-pie) or "bar"
+     * (bar-of-pie). Mirrors OOXML `<c:ofPieType val="pie|bar"/>`.
+     * Default "pie".
+     */
+    ofPieType?: Maybe<"pie" | "bar">;
+    /**
+     * Of-pie only — the rule that decides which data points move to the
+     * secondary plot. Mirrors `<c:splitType>`: "position" (`pos`) moves
+     * the last `splitPos` categories, "value" (`val`) moves points whose
+     * value is < `splitPos`, "percent" moves points whose share of the
+     * total is < `splitPos`%. OOXML `auto`/`cust` have no renderer
+     * equivalent and are treated as "position" with the default
+     * `splitPos`. Default "position".
+     */
+    splitType?: Maybe<"position" | "value" | "percent">;
+    /**
+     * Of-pie only — threshold for `splitType`. Mirrors `<c:splitPos>`.
+     * Default 3 (Excel's default: the last 3 values move to the second
+     * plot).
+     */
+    splitPos?: Maybe<number>;
+    /**
+     * Of-pie only — size of the secondary plot as a percentage of the
+     * main pie (5-200). Mirrors `<c:secondPieSize val="…"/>`. Excel
+     * default 75.
+     */
+    secondPieSize?: Maybe<number>;
+    /**
+     * Boxplot only — quartile calculation method. Mirrors Excel's box &
+     * whisker "Quartile Calculation" option: "inclusive" = QUARTILE.INC
+     * (linear interpolation over `(n-1)*q`, median included),
+     * "exclusive" = QUARTILE.EXC (`(n+1)*q`, median excluded). When
+     * omitted the renderer keeps its default statistics (inclusive
+     * interpolation in echarts; plotly's own box-trace default).
+     */
+    quartileMethod?: Maybe<"inclusive" | "exclusive">;
+    /**
+     * Boxplot only — show individual outlier points beyond the 1.5×IQR
+     * fences. Mirrors Excel's "Show outlier points": when false the
+     * whiskers extend to the full min/max instead. When omitted each
+     * renderer keeps its current default.
+     */
+    showOutliers?: Maybe<boolean>;
+    /**
+     * Boxplot only — draw a mean marker inside each box. Mirrors Excel's
+     * "Show mean markers". Default off.
+     */
+    showMeanMarker?: Maybe<boolean>;
+    /**
+     * Waterfall only — zero-based indices of data points rendered as
+     * subtotal/total bars. A total bar is drawn from the zero baseline
+     * (instead of floating from the running sum) with a distinct fill,
+     * and the running total resets to that bar's value. Mirrors the
+     * OOXML chartex `<cx:subtotals>` point indices.
+     */
+    totalIndices?: Maybe<number[]>;
+    /**
+     * Bar/column only — per-series overlap percentage. Mirrors
+     * `<c:overlap val="-100..100"/>`: 100 = bars fully stacked at same
+     * X coordinate, 0 = side-by-side touching, -100 = full gap.
+     * Default 0 (clustered) when omitted. For stacked/percentStacked
+     * Excel writes `overlap=100` since stacked bars share the X slot.
+     */
+    overlap?: Maybe<number>;
+    /**
+     * Bar/column only — gap width between category clusters as a
+     * percentage of bar width. Mirrors `<c:gapWidth val="0..500"/>`.
+     * Excel default is 150 (gap = 1.5× bar width). Smaller values pack
+     * bars tighter; 0 makes bars touch.
+     */
+    gapWidth?: Maybe<number>;
+};
+export type BubbleChartSpec = {
+    chartType: "bubble" | "scatter";
+    bubbleLabels: ChartData[];
+    domains: ChartData[];
+    series: ChartData[];
+    bubbleSizes?: Maybe<ChartData[]>;
+    useFirstRowAsHeaders?: Maybe<boolean>;
+    /**
+     * Scatter only — controls whether points are connected by a line and
+     * whether markers are drawn. Mirrors OOXML `<c:scatterStyle val=…>`:
+     *   - `lineMarker` — straight line + markers (Excel default)
+     *   - `line` — straight line only, no markers
+     *   - `marker` — markers only (no connecting line)
+     *   - `smoothMarker` — smooth (spline) line + markers
+     *   - `smooth` — smooth line, no markers
+     * Ignored for bubble charts.
+     */
+    scatterStyle?: Maybe<"line" | "marker" | "lineMarker" | "smoothMarker" | "smooth" | "none">;
+};
+export type TreemapChart = {
+    chartType: "treemap" | "sunburst";
+    labels: ChartData[];
+    parentLabels: ChartData[];
+    sizeData: ChartData[];
+    useFirstRowAsHeaders?: Maybe<boolean>;
+};
+export type BasicChartStackedType = "STACKED" | "PERCENT_STACKED" | "UNSTACKED";
+export type ChartData = {
+    dataLabel?: Maybe<string>;
+    aggregateType?: Maybe<ChartAggregateType>;
+    color?: Maybe<string>;
+    /**
+     * Color to use for negative values when invertIfNegative is true
+     */
+    negativeColor?: Maybe<string>;
+    /**
+     * Gradient fill on the series. Overrides `color` when present.
+     * Mirrors OOXML `<a:gradFill>` inside `<c:spPr>` — either a linear
+     * gradient (`type: "linear"` with a `degree` rotation) or a path
+     * gradient (`type: "path"` with axis-of-radial insets). The
+     * stops array drives the color ramp from `position: 0` to
+     * `position: 1`. The exporter emits this directly into the
+     * series shape properties; the parser hydrates it from the
+     * OOXML attrs.
+     */
+    gradient?: Maybe<{
+        type: "linear" | "path";
+        degree?: number;
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+        stops: Array<{
+            position: number;
+            color: string;
+        }>;
+    }>;
+    /**
+     * When true, bars with negative values will use negativeColor instead of color
+     */
+    invertIfNegative?: Maybe<boolean>;
+    /**
+     * Chart type for this specific series (for combo charts).
+     * If not specified, uses the chart-level chartType.
+     */
+    seriesChartType?: Maybe<"bar" | "column" | "line" | "area">;
+    /**
+     * Trendlines drawn over this series. Each spec is rendered as a
+     * separate overlay; multiple trendlines per series are allowed.
+     * Mirrors `<c:trendline>` inside `<c:ser>`.
+     */
+    trendlines?: Maybe<ChartTrendlineSpec[]>;
+    /**
+     * Error bars for this series. Mirrors `<c:errBars>`.
+     */
+    errorBars?: Maybe<ChartErrorBarSpec>;
+    /**
+     * Plot this series against the secondary value axis. Used for combo
+     * charts where one series needs its own scale.
+     */
+    useSecondaryAxis?: Maybe<boolean>;
+    /**
+     * Transparent series — mirrors `<c:spPr><a:noFill/>` on a series.
+     * Used for the "invisible offset" series in Gantt-style stacked-bar
+     * charts (first series carries the lag from chart start to task
+     * start, must not be visible). When true, renderers skip the fill;
+     * `color` is typically undefined in this case but if both are set
+     * `noFill` wins.
+     */
+    noFill?: Maybe<boolean>;
+    /**
+     * Per-data-point color overrides — mirrors `<c:dPt>` inside `<c:ser>`.
+     * Each entry pins a specific category index to a different color
+     * (Gantt charts colour each task differently; pie charts colour
+     * slices individually). Renderers apply these on top of the series
+     * `color`. The `idx` matches the category index.
+     */
+    dataPointColors?: Maybe<Array<{
+        idx: number;
+        color: string;
+    }>>;
+    /**
+     * Per-series marker style. Mainly for scatter/bubble where individual
+     * series can carry their own `<c:marker><c:symbol>/<c:size>`. When
+     * `symbol` is `"none"` no markers are drawn (renders as a pure line
+     * series); otherwise the shape is used along with `size` (pixels).
+     * Other chart types use this for line/area markers.
+     */
+    marker?: Maybe<{
+        symbol?: Maybe<"none" | "circle" | "square" | "diamond" | "triangle" | "x" | "plus" | "star" | "dash" | "dot" | "auto" | "picture">;
+        /** Marker diameter in pixels. */
+        size?: Maybe<number>;
+        /** Fill color override (defaults to series color). */
+        color?: Maybe<string>;
+    }>;
+} & ChartSourceRange;
+export type ChartTrendlineSpec = {
+    /** Curve type. Defaults to "linear". */
+    type?: Maybe<"linear" | "exp" | "log" | "poly" | "power" | "movingAvg">;
+    /** Polynomial degree (only when type is "poly"). 2-6 typical. */
+    order?: Maybe<number>;
+    /** Moving average period (only when type is "movingAvg"). */
+    period?: Maybe<number>;
+    /** Display name shown in the legend. */
+    name?: Maybe<string>;
+    /** Trendline color. */
+    color?: Maybe<string>;
+    /** Forecast forward/backward periods. */
+    forecastForward?: Maybe<number>;
+    forecastBackward?: Maybe<number>;
+    /** Show the equation / R² in the chart. */
+    showEquation?: Maybe<boolean>;
+    showRSquared?: Maybe<boolean>;
+};
+export type ChartErrorBarSpec = {
+    /** Which axis the bars apply to. Defaults to "y". */
+    direction?: Maybe<"x" | "y">;
+    /** Bar shape: both, plus, minus. Defaults to "both". */
+    barType?: Maybe<"both" | "plus" | "minus">;
+    /**
+     * Value source. `fixedVal` uses `value` as a constant; `percentage`
+     * scales by `value` (0-100); `stdDev` multiplies by `value` standard
+     * deviations; `stdErr` uses standard error; `custom` reads per-point
+     * plus/minus magnitudes from `plusRange` / `minusRange`.
+     */
+    valueType?: Maybe<"fixedVal" | "percentage" | "stdDev" | "stdErr" | "custom">;
+    /** Numeric magnitude when valueType is fixedVal/percentage/stdDev. */
+    value?: Maybe<number>;
+    /** Whether end caps are drawn. */
+    noEndCap?: Maybe<boolean>;
+    /**
+     * Custom only — worksheet range supplying the per-point upward
+     * magnitudes (one value per data point, index-aligned with the
+     * series values). Mirrors `<c:plus><c:numRef>` in OOXML.
+     */
+    plusRange?: Maybe<SheetRange>;
+    /**
+     * Custom only — worksheet range supplying the per-point downward
+     * magnitudes. Mirrors `<c:minus><c:numRef>`.
+     */
+    minusRange?: Maybe<SheetRange>;
+};
+export type ChartAggregateType = "AVERAGE" | "COUNT" | "MAX" | "MEDIAN" | "MIN" | "SUM";
+export type ChartSourceRange = {
+    /**
+     * Cell-range source(s). Empty when the data is inline in the chart
+     * XML (`<c:strLit>` / `<c:numLit>`) rather than referencing the sheet.
+     * Both layers exist because a single chart can mix: an axis category
+     * may be a literal list (`["Estimated", "Actual"]`) while the value
+     * series is a cell range. Renderers prefer `inlineValues` when
+     * `sources` is empty.
+     */
+    sources: SheetRange[];
+    /**
+     * Inline values supplied directly by the chart XML — used when the
+     * source carries `<c:strLit>` / `<c:numLit>` (no cell reference).
+     * When present, renderers use these in place of range-extracted
+     * values. When both fields are populated (unusual), sources win.
+     */
+    inlineValues?: Maybe<Array<string | number | boolean>>;
+};
+export type EmbeddedObjectPosition = {
+    sheetId: number;
+    overlayPosition: OverlayPosition;
+};
+export type OverlayPosition = {
+    anchorCell: CellInterface;
+    heightPixels?: Maybe<number>;
+    widthPixels?: Maybe<number>;
+    offsetXPixels?: Maybe<number>;
+    offsetYPixels?: Maybe<number>;
+};
+export type HIDDEN_DIMENSION_STRATEGY = "SKIP_HIDDEN_ROWS_AND_COLUMNS" | "SKIP_HIDDEN_ROWS" | "SKIP_HIDDEN_COLUMNS" | "SHOW_ALL";
+export type ErrorType = "ERROR_TYPE_UNSPECIFIED" | "ERROR" | "NULL_VALUE" | "DIVIDE_BY_ZERO" | "VALUE" | "REF" | "NAME" | "NUM" | "N_A" | "LOADING";
+export type FillPattern = "none" | "solid" | "mediumGray" | "darkGray" | "lightGray" | "darkHorizontal" | "darkVertical" | "darkDown" | "darkUp" | "darkGrid" | "darkTrellis" | "lightHorizontal" | "lightVertical" | "lightDown" | "lightUp" | "lightGrid" | "lightTrellis" | "gray125" | "gray0625";
+export type GradientStop = {
+    position: number;
+    color: string;
+};
+export type GradientFill = {
+    type: "linear" | "path";
+    degree?: number;
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    stops: GradientStop[];
+};
+export type CellFormat = {
+    backgroundColor?: Maybe<Color>;
+    borders?: Maybe<Borders>;
+    textFormat?: Maybe<TextFormat>;
+    numberFormat?: Maybe<NumberFormat>;
+    horizontalAlignment?: Maybe<HorizontalAlign>;
+    verticalAlignment?: Maybe<VerticalAlign>;
+    wrapStrategy?: Maybe<WrapStrategy>;
+    indent?: Maybe<number>;
+    relativeIndent?: Maybe<number>;
+    textRotation?: Maybe<number | "vertical">;
+    shrinkToFit?: Maybe<boolean>;
+    fillPattern?: Maybe<FillPattern>;
+    foregroundColor?: Maybe<Color>;
+    gradient?: Maybe<GradientFill>;
+    conditionalIcon?: Maybe<{
+        glyph: string;
+        color?: Maybe<string>;
+        /** Source iconSet family (e.g. "3Arrows"). Needed for icon filters. */
+        iconSet?: Maybe<string>;
+        /** 0-based index within that iconSet (e.g. 0 = first glyph). */
+        iconId?: Maybe<number>;
+    }>;
+    conditionalDataBar?: Maybe<{
+        color: string;
+        fillFraction: number;
+        negative?: boolean;
+        borderColor?: string;
+        direction?: "leftToRight" | "rightToLeft";
+    }>;
+};
+export type WrapStrategy = "overflow" | "wrap" | "clip";
+export type NumberFormat = {
+    type: NumberFormatType;
+    pattern?: Maybe<string>;
+};
+export type NumberFormatType = "GENERAL" | "NUMBER" | "CURRENCY" | "ACCOUNTING" | "DATE" | "TIME" | "DATE_TIME" | "PERCENT" | "FRACTION" | "SCIENTIFIC" | "TEXT" | "SPECIAL";
+export type HorizontalAlign = "left" | "right" | "center";
+export type VerticalAlign = "top" | "middle" | "bottom";
+export type Borders = {
+    top?: Maybe<Border>;
+    right?: Maybe<Border>;
+    bottom?: Maybe<Border>;
+    left?: Maybe<Border>;
+    diagonalUp?: Maybe<Border>;
+    diagonalDown?: Maybe<Border>;
+};
+export type Border = {
+    style: BorderStyle;
+    width: number;
+    color?: Maybe<Color>;
+};
+export type BorderStyle = "dotted" | "dashed" | "solid" | "thin" | "solid_medium" | "solid_thick" | "double" | "hair" | "mediumDashed" | "mediumDashDot" | "dashDot" | "dashDotDot" | "slantDashDot";
+export type BaselineOffset = "superscript" | "subscript";
+export type TextFormat = {
+    color?: Maybe<Color>;
+    fontFamily?: Maybe<string>;
+    fontSize?: Maybe<number>;
+    bold?: Maybe<boolean>;
+    italic?: Maybe<boolean>;
+    strikethrough?: Maybe<boolean>;
+    underline?: Maybe<boolean>;
+    baselineOffset?: Maybe<BaselineOffset>;
+};
+export type ColorTheme = {
+    theme: ColorIndex;
+    tint?: Maybe<number>;
+};
+export type Color = string | ColorTheme;
+export type FilterView = {
+    id: number | string;
+    /**
+     * The name of the filter view.
+     */
+    title?: Maybe<string>;
+    /**
+     * The range this filter view covers.
+     */
+    range: GridRange | SheetRange;
+    /**
+     * The filter criteria associated with a specific column.
+     */
+    filterSpecs?: Maybe<FilterSpec[]>;
+    /**
+     * The sort order per column. Later specifications are used when values are equal in the earlier specifications.
+     */
+    sortSpecs?: Maybe<SortSpecs[]>;
+};
+export type FilterSpec = {
+    /**
+     * The column index.
+     */
+    columnIndex: number;
+    /**
+     * Criteria for showing/hiding rows in a filter or filter view.
+     */
+    filterCriteria: FilterCriteria;
+};
+export type FilterCriteria = {
+    /**
+     * A condition that must be true for values to be shown. (This does not override hiddenValues -- if a value is listed there, it will still be hidden.)
+     */
+    condition?: Maybe<BooleanCondition>;
+    /**
+     * Values that should be hidden.
+     * @deprecated Use visibleValues instead
+     */
+    hiddenValues?: Maybe<string[]>;
+    /**
+     * Allow visible values
+     */
+    visibleValues?: Maybe<string[]>;
+    /**
+     * Show only cells whose fill or font color matches. Mirrors Excel's
+     * `<colorFilter dxfId cellColor>` — `mode` distinguishes whether the
+     * match is against the cell fill (`cellColor`) or text (`fontColor`).
+     */
+    colorFilter?: Maybe<ColorFilterCriteria>;
+    /**
+     * Show only cells whose conditional-formatting iconSet produced the
+     * specified glyph. Mirrors Excel's `<iconFilter iconSet iconId>`.
+     */
+    iconFilter?: Maybe<IconFilterCriteria>;
+};
+export type ColorFilterCriteria = {
+    /** Hex color string, e.g. "#FF0000". Compared case-insensitively. */
+    color: string;
+    /** "cellColor" matches cell fill; "fontColor" matches text color. */
+    mode: "cellColor" | "fontColor";
+};
+export type IconFilterCriteria = {
+    /** iconSet family, e.g. "3Arrows", "5Rating", "3TrafficLights1". */
+    iconSet: string;
+    /** 0-based glyph index within the iconSet. */
+    iconId: number;
+};
+export type TableView = FilterView & {
+    title: string;
+    sheetId: number;
+    headerRow?: Maybe<boolean>;
+    totalRow?: Maybe<boolean>;
+    showRowStripes?: Maybe<boolean>;
+    showColumnStripes?: Maybe<boolean>;
+    showFirstColumn?: Maybe<boolean>;
+    showLastColumn?: Maybe<boolean>;
+    filterButton?: Maybe<boolean>;
+    bandedRange?: Maybe<BandedDefinition>;
+    columns?: Maybe<(Column | CalculatedColumn)[]>;
+    theme?: Maybe<TableTheme>;
+};
+export type Column = {
+    name: string;
+    filterButton?: Maybe<boolean>;
+};
+export type CalculatedColumn = Column & {
+    formula: string;
+};
+export type ProtectedRange = {
+    protectedRangeId?: Maybe<number | string>;
+    range: Partial<GridRange> & {
+        sheetId: number;
+    };
+    requestingUserCanEdit?: Maybe<boolean>;
+    unprotectedRanges?: Maybe<SheetRange[]>;
+};
+export type ConditionalFormatRule = {
+    id: string | number;
+    enabled?: Maybe<boolean>;
+    priority?: Maybe<number>;
+    stopIfTrue?: Maybe<boolean>;
+    ranges: SheetRange[];
+    booleanRule?: Maybe<BooleanRule>;
+    gradientRule?: Maybe<GradientRule>;
+    topBottomRule?: Maybe<TopBottomRule>;
+    distinctRule?: Maybe<DistinctRule>;
+    iconSetRule?: Maybe<IconSetRule>;
+    dataBarRule?: Maybe<DataBarRule>;
+    /**
+     * Verbatim source-xlsx representation captured on import. When set, the
+     * xlsx exporter writes the cfRule using these fields directly instead of
+     * synthesizing from `booleanRule`/`topBottomRule`/`distinctRule`. This
+     * preserves the original cfRule type (`containsText`, `beginsWith`,
+     * `timePeriod`, etc.), the original operator, the user's formula text,
+     * and rule attributes (`text`, `rank`, `percent`, `aboveAverage`, etc.).
+     *
+     * Newly-created rules (from the UI) won't carry this field; the exporter
+     * falls back to synthesis for those.
+     */
+    xlsxSource?: Maybe<{
+        type: string;
+        operator?: string;
+        text?: string;
+        timePeriod?: string;
+        rank?: number;
+        percent?: boolean;
+        bottom?: boolean;
+        aboveAverage?: boolean;
+        equalAverage?: boolean;
+        stdDev?: number;
+        formulas?: string[];
+        /**
+         * Opaque parsed XML subtrees for cfRule children that the high-level
+         * model can't represent losslessly (3-color scales with non-{min,mid,max}
+         * cfvo types, custom thresholds, data bars, icon sets). When present,
+         * the exporter serializes these back via XMLBuilder verbatim. Stored as
+         * fast-xml-parser parsed objects (with `a$` / `t$` conventions).
+         */
+        colorScale?: unknown;
+        dataBar?: unknown;
+        iconSet?: unknown;
+    }>;
+};
+export type BooleanRule = {
+    condition?: BooleanCondition;
+    format: CellFormat;
+    formula?: string;
+};
+export type GradientRule = {
+    minpoint?: Maybe<InterpolationPoint>;
+    midpoint?: Maybe<InterpolationPoint>;
+    maxpoint?: Maybe<InterpolationPoint>;
+};
+export type TopBottomRule = {
+    type: "TOP" | "BOTTOM";
+    rank: number;
+    isPercent?: Maybe<boolean>;
+    format: CellFormat;
+};
+export type DistinctRule = {
+    type: "DUPLICATE" | "UNIQUE";
+    format: CellFormat;
+};
+export type InterpolationPoint = {
+    color: Color;
+    type: "MIN" | "MAX" | "NUMBER" | "PERCENT" | "PERCENTILE" | "FORMULA";
+    value?: Maybe<string | number>;
+};
+export type IconSetFamily = "3Arrows" | "3ArrowsGray" | "3Flags" | "3TrafficLights1" | "3TrafficLights2" | "3Signs" | "3Symbols" | "3Symbols2" | "4Arrows" | "4ArrowsGray" | "4RedToBlack" | "4Rating" | "4TrafficLights" | "5Arrows" | "5ArrowsGray" | "5Rating" | "5Quarters";
+export type CfThreshold = {
+    type: "MIN" | "MAX" | "NUMBER" | "PERCENT" | "PERCENTILE" | "FORMULA";
+    value?: Maybe<string | number>;
+};
+export type IconSetRule = {
+    iconSet: IconSetFamily;
+    thresholds: CfThreshold[];
+    reverse?: Maybe<boolean>;
+    showValue?: Maybe<boolean>;
+};
+export type DataBarRule = {
+    minpoint: CfThreshold;
+    maxpoint: CfThreshold;
+    color: Color;
+    negativeColor?: Maybe<Color>;
+    borderColor?: Maybe<Color>;
+    showValue?: Maybe<boolean>;
+    direction?: Maybe<"leftToRight" | "rightToLeft" | "context">;
+    gradient?: Maybe<boolean>;
+};
+export type DimensionProperties = {
+    size?: Maybe<number>;
+    resizedByUser?: Maybe<boolean>;
+    /**
+     * Mirrors the xlsx `customHeight="1"` (or `customWidth="1"`) attribute
+     * captured at import time. Distinct from `resizedByUser` — that runtime
+     * flag can be flipped by engine paths (column-resize side effects,
+     * autofit, etc.) and is not safe to use as the export gate for
+     * `customHeight`. When the source carried the explicit `customHeight`
+     * marker, this stays true through round-trip and tells the exporter
+     * to emit `customHeight="1"` even when `size` matches the sheet
+     * default — which round-trips Excel's "user locked this row even though
+     * it happens to be the default height" behavior verbatim.
+     */
+    customHeight?: Maybe<boolean>;
+    hiddenByUser?: Maybe<boolean>;
+    hiddenByFilter?: Maybe<boolean>;
+    /**
+     * Hidden because the parent outline group is collapsed. Kept separate
+     * from `hiddenByUser` so expanding the group doesn't blow away a
+     * manual hide. Render layer ORs all three.
+     */
+    hiddenByGroup?: Maybe<boolean>;
+    /**
+     * Excel outline depth (0–7). 0 = no grouping. Mirrors OOXML
+     * `<row outlineLevel=…>` / `<col outlineLevel=…>`. Persisted only
+     * when > 0.
+     */
+    outlineLevel?: Maybe<number>;
+    /**
+     * True on the SUMMARY row/column of a group when the group is in
+     * the collapsed state — that's where the `+` button is drawn.
+     * Mirrors OOXML `<row collapsed="1">` / `<col collapsed="1">`.
+     */
+    collapsed?: Maybe<boolean>;
+};
+export type SortSpecs = {
+    dimensionIndex: number;
+    sortOrder: SortOrder;
+    /**
+     * What to sort by. Defaults to "value" (the cell's effective value).
+     * `cellColor`/`fontColor` surface cells whose corresponding color
+     * matches `sortColor` to the top (ASCENDING) or bottom (DESCENDING).
+     * `icon` does the same with a CF iconSet+iconId.
+     */
+    sortBy?: Maybe<"value" | "cellColor" | "fontColor" | "icon">;
+    /**
+     * For `sortBy = cellColor | fontColor`, the color to surface.
+     * Hex string (e.g. "#FF0000"). Compared case-insensitively.
+     */
+    sortColor?: Maybe<string>;
+    /**
+     * For `sortBy = icon`, the CF icon to surface.
+     */
+    sortIcon?: Maybe<{
+        iconSet: string;
+        iconId: number;
+    }>;
+    /**
+     * Custom sort order — when set, values are sorted by their position in
+     * this list (case-insensitive). Anything not in the list goes after.
+     * Mirrors Excel's "Custom Lists" (e.g. Mon, Tue, Wed…).
+     */
+    customList?: Maybe<string[]>;
+};
+export type AXIS = "x" | "y";
+export type Collaborator = {
+    title: string;
+    userId: string | number;
+    style?: Maybe<Style>;
+    isEditing?: Maybe<boolean>;
+    activeCell?: CellInterface;
+    sheetId?: number;
+    /**
+     * Legacy field — prefer `kind`. Kept so older consumers continue to compile.
+     */
+    type?: "user" | "agent";
+    /**
+     * Identifies whether this presence comes from a human user or an agent run.
+     * Canvas renderers and presence stacks can use this to style agent cursors
+     * differently (e.g. slate squircle with "A") and to deduplicate by initiator.
+     */
+    kind?: "human" | "agent";
+    /**
+     * For `kind === "agent"`, the human who initiated the agent run.
+     * Lets us label "Athena · Brendon's run" and deduplicate concurrent agent
+     * cursors by their initiator.
+     */
+    agentInitiator?: string;
+    /**
+     * Current selection range(s). When set, the collaborator's footprint is
+     * the full range (e.g. A1:E10) rather than just `activeCell`.
+     */
+    selections?: SelectionArea[];
+};
+export declare enum MimeTypes {
+    html = "text/html",
+    csv = "text/csv",
+    plain = "text/plain",
+    json = "application/json"
+}
+export type Token = {
+    image: string;
+    startOffset: number;
+    startColumn: number;
+    endOffset: number;
+    endColumn: number;
+    endLine: number;
+    tokenType: {
+        name: string;
+    };
+    tokenTypeIdx: number;
+};
+export type ParsedToken = Token & {
+    index?: number;
+    sheetName?: string;
+    selection?: boolean;
+    isNamedRange?: boolean;
+    isColumnRange?: boolean;
+    isRowRange?: boolean;
+    tableName?: string;
+    columnNames?: string[];
+    thisRow?: boolean;
+    specialItem?: SpecialItem;
+    structured?: boolean;
+    property?: string | null;
+    resolvedSheetName?: string;
+    resolvedRowIndex?: number;
+    resolvedColumnIndex?: number;
+};
+export type SpecialItem = "#Totals" | "#Data" | "#All" | "#Headers" | "#This Row";
+export type AutoFillType = "FillCopy" | "FillDays" | "FillDefault" | "FillFormats" | "FillMonths" | "FillSeries" | "FillValues" | "FillWeekdays" | "FillYears" | "FlashFill" | "GrowthTrend" | "LinearTrend";
+export type TableTheme = "None" | "TableStyleLight1" | "TableStyleLight2" | "TableStyleLight3" | "TableStyleLight4" | "TableStyleLight5" | "TableStyleLight6" | "TableStyleLight7" | "TableStyleLight8" | "TableStyleLight9" | "TableStyleLight10" | "TableStyleLight11" | "TableStyleLight12" | "TableStyleLight13" | "TableStyleLight14" | "TableStyleLight15" | "TableStyleLight16" | "TableStyleLight17" | "TableStyleLight18" | "TableStyleLight19" | "TableStyleLight20" | "TableStyleLight21" | "TableStyleMedium1" | "TableStyleMedium2" | "TableStyleMedium3" | "TableStyleMedium4" | "TableStyleMedium5" | "TableStyleMedium6" | "TableStyleMedium7" | "TableStyleMedium8" | "TableStyleMedium9" | "TableStyleMedium10" | "TableStyleMedium11" | "TableStyleMedium12" | "TableStyleMedium13" | "TableStyleMedium14" | "TableStyleMedium15" | "TableStyleMedium16" | "TableStyleMedium17" | "TableStyleMedium18" | "TableStyleMedium19" | "TableStyleMedium20" | "TableStyleMedium21" | "TableStyleMedium22" | "TableStyleMedium23" | "TableStyleMedium24" | "TableStyleMedium25" | "TableStyleMedium26" | "TableStyleMedium27" | "TableStyleMedium28" | "TableStyleDark1" | "TableStyleDark2" | "TableStyleDark3" | "TableStyleDark4" | "TableStyleDark5" | "TableStyleDark6" | "TableStyleDark7" | "TableStyleDark8" | "TableStyleDark9" | "TableStyleDark10" | "TableStyleDark11";
+export type TimePeriodTypes = "lastWeek" | "thisWeek" | "nextWeek" | "yesterday" | "today" | "tomorrow" | "last7Days" | "lastMonth" | "thisMonth" | "nextMonth";
+export type AgentSuggestion = {
+    id: string;
+    range: SheetRange;
+    createdAt?: Maybe<string>;
+    proposedChanges: (string | number | null | undefined | boolean)[][];
+    status?: Maybe<"pending" | "accepted" | "rejected">;
+    reason?: Maybe<string>;
+    agentId?: Maybe<string>;
+    agentName?: Maybe<string>;
+};
+/**
+ * Slicers
+ */
+export type Slicer = {
+    slicerId: number | string;
+    spec: SlicerSpec;
+    position: EmbeddedObjectPosition;
+    borderColor?: Maybe<Color>;
+    numberOfColumns?: Maybe<number>;
+    showItemsWithNoData?: Maybe<boolean>;
+    sortOrder?: Maybe<"ascending" | "descending" | "data-source">;
+} & EmbeddedObjectProperty;
+export type SlicerSpec = TableSlicerSpec | PivotSlicerSpec;
+export type TableSlicerSpec = {
+    type: "table";
+    tableIds: TableView["id"][];
+    columnIndex: number;
+    title?: string;
+};
+export type PivotSlicerSpec = {
+    type: "pivot";
+    pivotTableIds: (string | number)[];
+    fieldName: string;
+    title: string;
+};
+//# sourceMappingURL=types.d.ts.map