@rowsncolumns/common-types 5.2.29

package/LICENSE.md

@@ -0,0 +1,100 @@
+# Rows n' Columns Commercial License Agreement
+
+This Rows n' Columns Commercial License Agreement (the "Agreement") governs
+the use of the Rows n' Columns software packages published under the
+`@rowsncolumns` npm scope, including associated JavaScript, WebAssembly
+binaries, stylesheets, type definitions and documentation (the "Software").
+
+The Software is **not** open source. Downloading or installing the Software
+from a public package registry does not grant any right to use it beyond the
+evaluation use described below.
+
+## 1. Definitions
+
+- **"Licensor"** means Rows n' Columns (rowsncolumns.app).
+- **"Licensee"** means the individual or legal entity identified in an Order.
+- **"Order"** means a purchase of a license for the Software from Licensor,
+  identified by an order ID and associated with a License Key.
+- **"License Key"** means the signed key issued by Licensor that identifies
+  the Licensee, license tier, and Update Window.
+- **"Update Window"** means the period stated in the Order during which
+  Software versions released by Licensor are covered by the License Key.
+
+## 2. License Grant
+
+Subject to payment of the applicable fees and compliance with this Agreement,
+Licensor grants Licensee a non-exclusive, non-transferable, worldwide license
+to use, and to distribute in compiled form as an embedded component of
+Licensee's own applications, any version of the Software released during the
+Update Window, in accordance with the license tier stated in the Order.
+
+This grant is perpetual for versions released during the Update Window:
+Licensee may continue to use those versions after the Update Window ends.
+Versions released after the Update Window ends require a new or renewed
+Order.
+
+## 3. Evaluation Use
+
+The Software may be used without a License Key solely for internal
+evaluation and development purposes. Evaluation use in production, or
+removal or suppression of evaluation notices, is not permitted.
+
+## 4. Restrictions
+
+Except as expressly permitted by this Agreement or by applicable law that
+cannot be contractually waived, Licensee shall not:
+
+1. redistribute, resell, sublicense, or otherwise make the Software
+   available as a standalone product, library, or development component;
+2. use the Software to build a product that competes with the Software;
+3. remove, alter, or circumvent License Key validation, evaluation notices,
+   watermarks, or copyright notices in the Software;
+4. share License Keys with any third party, or use a License Key outside
+   the scope of the tier stated in the Order;
+5. reverse engineer, decompile, or disassemble the Software except to the
+   extent permitted by applicable law.
+
+## 5. Ownership
+
+The Software is licensed, not sold. Licensor and its licensors retain all
+right, title, and interest in and to the Software, including all
+intellectual property rights.
+
+## 6. Third-Party Components
+
+The Software may include third-party open-source components. Those
+components remain governed by their own license terms, which are included
+with the applicable component and are not limited by this Agreement.
+
+## 7. Termination
+
+This Agreement terminates automatically upon material breach by Licensee
+that remains uncured 30 days after written notice. Upon termination,
+Licensee must cease use and distribution of the Software, except that
+end-user copies of Licensee applications already distributed in compliance
+with this Agreement are unaffected.
+
+## 8. Warranty Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+## 9. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL LICENSOR BE LIABLE
+FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES,
+OR ANY LOSS OF PROFITS, DATA, OR GOODWILL, ARISING OUT OF OR RELATED TO THIS
+AGREEMENT, AND LICENSOR'S AGGREGATE LIABILITY SHALL NOT EXCEED THE FEES PAID
+BY LICENSEE IN THE TWELVE MONTHS PRECEDING THE CLAIM.
+
+## 10. General
+
+This Agreement constitutes the entire agreement between the parties
+concerning the Software and supersedes any prior agreements. If any
+provision is held unenforceable, the remainder remains in effect. Failure to
+enforce a provision is not a waiver.
+
+For licensing inquiries, visit <https://www.rowsncolumns.app/pricing>.
+
+Copyright © Rows n' Columns. All rights reserved.

package/dist/cjs/index.d.ts

@@ -0,0 +1,581 @@
+export type BaseStructuredResult = {
+    kind: string;
+    formattedValue?: string;
+};
+export type HyperlinkResult = BaseStructuredResult & {
+    kind: "hyperlink";
+    title: string;
+    url: string;
+};
+export type HyperlinkValue = {
+    kind: "external";
+    url: string;
+    display?: string;
+    tooltip?: string;
+} | {
+    kind: "internal";
+    location: string;
+    display?: string;
+    tooltip?: string;
+};
+export type SparkLineResult = BaseStructuredResult & {
+    kind: "sparkline";
+    data: (number | null)[];
+    options?: SparkLineResultOptions;
+};
+export type SparkLineResultOptions = {
+    charttype?: "column" | "line" | "winloss";
+    color?: string;
+    markers?: boolean;
+    colorMarkers?: string;
+    colorFirst?: string;
+    colorLast?: string;
+    colorHigh?: string;
+    colorLow?: string;
+    colorNegative?: string;
+    first?: boolean;
+    last?: boolean;
+    high?: boolean;
+    low?: boolean;
+    negative?: boolean;
+    max?: number;
+    min?: number;
+    maxaxistype?: "individual" | "group" | "custom";
+    minaxistype?: "individual" | "group" | "custom";
+    emptycells?: "gap" | "zero" | "span";
+    rtl?: boolean;
+    lineweight?: number;
+    axis?: boolean;
+    dateaxis?: boolean;
+    displayhidden?: boolean;
+};
+export type ImageResult = BaseStructuredResult & {
+    kind: "image";
+    imageUrl: string;
+    width?: number;
+    height?: number;
+};
+export type CommonStructuredResult = HyperlinkResult | SparkLineResult | ImageResult;
+export type ExtensibleStructuredResult = BaseStructuredResult & {
+    [key: string]: any;
+};
+export type StructuredResult = CommonStructuredResult | ExtensibleStructuredResult;
+/**
+ * Utility type for values that can be undefined or null
+ */
+export type Maybe<T> = T | undefined | null;
+export type IterativeCalculationOptions = {
+    enabled: boolean;
+    maxIterations?: number;
+    maxChange?: number;
+};
+export type CellInterface = {
+    rowIndex: number;
+    columnIndex: number;
+};
+export type GridRange = {
+    startRowIndex: number;
+    endRowIndex: number;
+    startColumnIndex: number;
+    endColumnIndex: number;
+};
+export type SheetRange = GridRange & {
+    sheetId: number;
+};
+export type SheetCoordinate = CellInterface & {
+    sheetId: number;
+};
+export type SortOrder = "ASCENDING" | "DESCENDING";
+export declare enum Direction {
+    Up = "UP",
+    Down = "DOWN",
+    Left = "LEFT",
+    Right = "RIGHT"
+}
+export type AreaStyle = Record<string, unknown>;
+export type SelectionArea<T = AreaStyle> = {
+    range: GridRange;
+    inProgress?: boolean;
+    /**
+     * When user drags the fill handle
+     */
+    isFilling?: boolean;
+} & Partial<T>;
+export type ColorIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+export type ColorTheme = {
+    theme: ColorIndex;
+    tint?: number | null;
+};
+export type Color = string | ColorTheme;
+export type BorderStyle = "dotted" | "dashed" | "solid" | "thin" | "solid_medium" | "solid_thick" | "double" | "hair" | "mediumDashed" | "mediumDashDot" | "dashDot" | "dashDotDot" | "slantDashDot";
+export type Border = {
+    style: BorderStyle;
+    width: number;
+    color?: Color | null;
+};
+export type Borders = {
+    top?: Maybe<Border>;
+    bottom?: Maybe<Border>;
+    left?: Maybe<Border>;
+    right?: Maybe<Border>;
+    diagonalUp?: Maybe<Border>;
+    diagonalDown?: Maybe<Border>;
+};
+export type BaselineOffset = "superscript" | "subscript";
+export type TextFormat = {
+    color?: Color | null;
+    fontFamily?: string | null;
+    fontSize?: number | null;
+    bold?: boolean | null;
+    italic?: boolean | null;
+    strikethrough?: boolean | null;
+    underline?: boolean | null;
+    baselineOffset?: BaselineOffset | null;
+};
+export type NumberFormatType = "GENERAL" | "NUMBER" | "CURRENCY" | "ACCOUNTING" | "DATE" | "TIME" | "DATE_TIME" | "PERCENT" | "FRACTION" | "SCIENTIFIC" | "TEXT" | "SPECIAL";
+export type NumberFormat = {
+    type: NumberFormatType;
+    pattern?: Maybe<string>;
+};
+export type HorizontalAlign = "left" | "right" | "center";
+export type VerticalAlign = "top" | "middle" | "bottom";
+export type WrapStrategy = "overflow" | "wrap" | "clip";
+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 | string>;
+    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 | string>;
+    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";
+    }>;
+};
+/** CellXfs registry type for resolving style references */
+export type CellXfs = Map<string | number, CellFormat | undefined | null>;
+export type ErrorValue = {
+    type: "Error" | "Invalid";
+    name?: string;
+    message: string;
+};
+export type ExtendedValue = {
+    numberValue?: Maybe<number>;
+    stringValue?: Maybe<string>;
+    boolValue?: Maybe<boolean>;
+    formulaValue?: Maybe<string>;
+    errorValue?: Maybe<ErrorValue>;
+    nv?: Maybe<number>;
+    sv?: Maybe<string>;
+    bv?: Maybe<boolean>;
+    fv?: Maybe<string>;
+    ev?: Maybe<ErrorValue>;
+};
+export type StructuredValue<T extends StructuredResult = StructuredResult> = {
+    structuredValue?: Maybe<T>;
+};
+export type CustomFormulaResult = string | number | boolean | Date | undefined | null | object | ErrorValue;
+export type RowData<T extends CellData | null | undefined> = {
+    values?: T[];
+};
+export type RowDataWithValue<T extends CellData | null | undefined> = {
+    values: T[];
+};
+export type SheetData<T extends CellData> = Record<string | number, (RowData<T | null> | RowDataWithValue<T | null> | null)[]>;
+export type StyleReference = {
+    styleId?: Maybe<string>;
+    sid?: Maybe<string>;
+} & ({
+    styleId: string;
+    sid?: Maybe<string>;
+} | {
+    styleId?: Maybe<string>;
+    sid: string;
+});
+/**
+ * Mention type for referencing entities in text
+ */
+export type Mention = {
+    value: string;
+    label: string;
+};
+/**
+ * TextFormatRun represents formatted text segments in a cell
+ * Can be either a text node with formatting or a mention node
+ */
+export type TextFormatRun<Format extends TextFormat = TextFormat, M extends Mention = Mention> = {
+    startIndex: number;
+    endIndex: number;
+    format: Format;
+    nodeType: "text";
+} | {
+    startIndex: number;
+    endIndex: number;
+    nodeType: "mention";
+    mention: M;
+};
+export declare const CONDITION_TYPES: readonly ["NUMBER_GREATER", "NUMBER_GREATER_THAN_EQ", "NUMBER_LESS", "NUMBER_LESS_THAN_EQ", "NUMBER_GREATER_THAN_PREVIOUS", "NUMBER_GREATER_THAN_EQ_PREVIOUS", "NUMBER_LESS_THAN_PREVIOUS", "NUMBER_LESS_THAN_EQ_PREVIOUS", "NUMBER_ABOVE_AVERAGE", "NUMBER_BELOW_AVERAGE", "NUMBER_EQ", "NUMBER_NOT_EQ", "NUMBER_BETWEEN", "NUMBER_NOT_BETWEEN", "TEXT_CONTAINS", "TEXT_NOT_CONTAINS", "TEXT_STARTS_WITH", "TEXT_ENDS_WITH", "TEXT_EQ", "TEXT_IS_EMAIL", "TEXT_IS_URL", "DATE_EQ", "DATE_BEFORE", "DATE_AFTER", "DATE_ON_OR_BEFORE", "DATE_ON_OR_AFTER", "DATE_BETWEEN", "DATE_NOT_BETWEEN", "DATE_IS_VALID", "DATE_TODAY", "DATE_YESTERDAY", "DATE_TOMORROW", "DATE_LAST_7_DAYS", "DATE_LAST_WEEK", "DATE_THIS_WEEK", "DATE_NEXT_WEEK", "DATE_LAST_MONTH", "DATE_THIS_MONTH", "DATE_NEXT_MONTH", "ONE_OF_RANGE", "ONE_OF_LIST", "BLANK", "NOT_BLANK", "ERROR", "NOT_ERROR", "CUSTOM_FORMULA", "BOOLEAN", "TEXT_NOT_EQ", "DATE_NOT_EQ"];
+export type ConditionType = (typeof CONDITION_TYPES)[number];
+export type ConditionValue = {
+    userEnteredValue: string;
+};
+export type BooleanCondition = {
+    type?: Maybe<ConditionType>;
+    values?: Maybe<ConditionValue[]>;
+};
+export type DataValidationInputMessage = {
+    title?: Maybe<string>;
+    message?: Maybe<string>;
+};
+export type DataValidationRuleAlert = {
+    style: "stop" | "warning" | "information";
+    message?: Maybe<DataValidationInputMessage>;
+};
+export type DataValidationRuleRecord = DataValidationRule & {
+    id: string | number;
+    ranges: SheetRange[];
+};
+export type DataValidationRule = {
+    condition?: BooleanCondition;
+    inputMessage?: Maybe<DataValidationInputMessage>;
+    displayStyle?: Maybe<"arrow" | "plain">;
+    alert?: Maybe<DataValidationRuleAlert>;
+    allowBlank?: Maybe<boolean>;
+    /**
+     * Verbatim source-xlsx representation captured on import. When set, the
+     * xlsx exporter writes these fields directly instead of synthesizing from
+     * `condition` — this preserves the original `whole`/`decimal`/`time`/
+     * `textLength` type, the original operator, and the user's formula text
+     * (without `INDIRECT("RC",FALSE)` self-reference rewriting).
+     *
+     * Newly-created rules (from the UI) won't carry this field; the exporter
+     * falls back to `condition`-based synthesis for those.
+     */
+    xlsxSource?: Maybe<{
+        type: string;
+        operator?: string;
+        formula1?: string;
+        formula2?: string;
+    }>;
+};
+export type PivotTable = {
+    /**
+     * Name of the pivot table
+     */
+    name?: string;
+    /**
+     * Pivot table ID
+     */
+    pivotId: string | number;
+    /**
+     * Datasource of the pivot
+     */
+    source?: SheetRange;
+    /**
+     * Position of the
+     */
+    targetPosition: SheetCoordinate;
+    /**
+     * Current data range of pivot results
+     * Helps in clearing
+     */
+    pivotRange?: SheetRange;
+    rows: PivotGroup[];
+    columns: PivotGroup[];
+    values: PivotValue[];
+    filters?: Record<string, any>;
+    sortModel?: Array<{
+        field: string;
+        sort: "asc" | "desc";
+    }>;
+    /**
+     * Display toggles — Excel-equivalent. Default `true` if omitted so
+     * existing pivots keep showing totals.
+     */
+    showSubtotals?: boolean;
+    showRowGrandTotals?: boolean;
+    showColumnGrandTotals?: boolean;
+};
+export type PivotGroup = {
+    field: string;
+    displayName?: string;
+    expandedGroups?: string[][];
+    sourceColumnOffset?: number;
+    sortOrder?: Maybe<SortOrder>;
+    /**
+     * Excel-style field grouping. When set, the SOURCE CTE rewrites
+     * this column with a derived expression so all downstream pivot
+     * logic sees the grouped value transparently.
+     *
+     * Date grouping uses DuckDB `date_trunc('<period>', "<field>")`.
+     * Numeric grouping buckets into ranges of width `bucketSize`,
+     * optionally offset by `startAt`.
+     *
+     * Both shapes can be persisted to/from XLSX via the pivotCache
+     * fieldGroup element (Phase D1/D2).
+     */
+    grouping?: {
+        type: "date";
+        period: "year" | "quarter" | "month" | "week" | "day";
+    } | {
+        type: "numeric";
+        bucketSize: number;
+        startAt?: number;
+    };
+};
+export type PivotValue = {
+    field: string;
+    displayName?: string;
+    sourceColumnOffset?: number;
+    aggFunc: PivotValueSummarizeFunction;
+    /**
+     * Excel-style "Show Values As" post-aggregation transform.
+     * Applied AFTER the raw aggregate (sum/avg/etc) lands. Hosts get
+     * the raw values from DuckDB and we transform them in JS so the
+     * transform doesn't have to be re-expressed as SQL window
+     * functions for each agg.
+     *
+     * Currently supported modes:
+     *   - "pct_of_total":   value / sum-of-all-cells
+     *   - "pct_of_row":     value / sum-of-row
+     *   - "pct_of_column":  value / sum-of-column
+     *   - "running_total":  cumulative sum down each column
+     *   - "rank_desc":      1-based dense rank within column, largest first
+     *   - "rank_asc":       1-based dense rank within column, smallest first
+     * Omit (or set "as_is") for the raw aggregate.
+     */
+    showAs?: "as_is" | "pct_of_total" | "pct_of_row" | "pct_of_column" | "running_total" | "rank_desc" | "rank_asc";
+};
+export type PivotValueSummarizeFunction = "sum" | "count" | "counta" | "countunique" | "avg" | "min" | "max" | "median" | "var" | "varp" | "stddev" | "stddevp" | "product";
+/**
+ * CellData type represents the data structure for a spreadsheet cell
+ * @template T - The type of structured result (extends StructuredResult)
+ * @template M - The type of mention (defaults to Mention)
+ */
+export type CellData<T extends StructuredResult = StructuredResult, M extends Mention = Mention> = {
+    /**
+     * The value the user entered in the cell. e.g, 1234 , 'Hello' , or =NOW() Note: Dates, Times and DateTimes are represented as doubles in serial number format.
+     * errorValue: Captures data validation errors
+     * @deprecated use ue instead
+     */
+    userEnteredValue?: Maybe<ExtendedValue>;
+    ue?: Maybe<ExtendedValue>;
+    /**
+     * The effective value of the cell. For cells with formulas, this is the calculated value. For cells with literals, this is the same as the userEnteredValue. This field is read-only.
+     *
+     * errorValue: Capture errors from formula calculation
+     * @deprecated use ev instead
+     */
+    effectiveValue?: Maybe<ExtendedValue & StructuredValue<T>>;
+    ev?: Maybe<ExtendedValue & StructuredValue<T>>;
+    /**
+     * Conditional formatting results by rule id
+     */
+    conditionalFormattingResultById?: Maybe<Record<string, CustomFormulaResult>>;
+    /**
+     * Result of data validation formulas
+     */
+    dataValidationResult?: Maybe<CustomFormulaResult>;
+    /**
+     * The formatted value of the cell. This is the value as it's shown to the user. This field is read-only.
+     * @deprecated use fv instead
+     */
+    formattedValue?: Maybe<string>;
+    fv?: Maybe<string>;
+    /**
+     * Any note on the cell.
+     */
+    note?: Maybe<string>;
+    /**
+     * Comment thread id
+     */
+    commentThreadId?: Maybe<string | number>;
+    /**
+     * Citation id
+     */
+    citationId?: Maybe<Citation["id"]>;
+    /**
+     * Hyperlink URL or structured hyperlink value
+     */
+    hyperlink?: Maybe<string | HyperlinkValue>;
+    /**
+     * Cell-level protection flags. Only take effect when sheet protection
+     * is enabled — preserved here for xlsx round-trip fidelity.
+     *   - `locked`: when sheet is protected and `locked: true`, the cell
+     *     can't be edited. Excel's per-cell default is `locked: true`, so
+     *     this field is typically set to `false` to opt a cell OUT of
+     *     protection.
+     *   - `hidden`: when sheet is protected, the formula bar hides this
+     *     cell's formula.
+     */
+    protection?: Maybe<{
+        locked?: Maybe<boolean>;
+        hidden?: Maybe<boolean>;
+    }>;
+    /**
+     * Validation applied to a cell with specific DataValidationRule type
+     */
+    dataValidation?: Maybe<DataValidationRule> | DataValidationRuleRecord["id"];
+    /**
+     * Image url
+     */
+    imageUrl?: Maybe<string>;
+    /**
+     * Cell meta style
+     */
+    metaType?: Maybe<"people">;
+    /**
+     * The format the user entered for the cell. When writing, the new format will be merged with the existing format.
+     * @deprecated use uf instead
+     */
+    userEnteredFormat?: Maybe<CellFormat | StyleReference>;
+    uf?: Maybe<CellFormat | StyleReference>;
+    /**
+     * @deprecated Effective format is no longer persisted on `CellData`. The
+     * renderer derives it on the fly from `uf`, the cell value, and (for
+     * formula cells) precedent formats — see
+     * `useSheetProperties.getEffectiveFormat`. This field is retained only so
+     * older saved data continues to load; new writes should set `uf`.
+     */
+    effectiveFormat?: Maybe<CellFormat | StyleReference>;
+    /**
+     * @deprecated See `effectiveFormat` above. Retained for backwards
+     * compatibility with legacy persisted data only.
+     */
+    ef?: Maybe<CellFormat | StyleReference>;
+    /**
+     * Collapsible cells, grouping and pivot table
+     */
+    expandable?: Maybe<boolean>;
+    /**
+     * Collapsed state of a cell
+     */
+    expanded?: Maybe<boolean>;
+    /**
+     * Pivot category of the cell
+     */
+    groupKeys?: string[];
+    /**
+     * Version metadata for collaborative syncing or server reconciliation
+     */
+    version?: Maybe<number>;
+    /**
+     * Timestamp of the last authoritative update (ms since epoch)
+     */
+    updatedAt?: Maybe<number>;
+    /**
+     * Number of children
+     */
+    childrenCount?: number;
+    /**
+     * Pivot id attached to the cell
+     */
+    pivotId?: Maybe<PivotTable["pivotId"]>;
+    /**
+     * Shared strings key (always a string for Map-based storage)
+     */
+    ss?: string;
+    /**
+     * Array formula spill range in A1 notation (e.g. "G7:G7" single-cell,
+     * "B5:B20" multi-cell). Only set on the anchor cell of an array formula;
+     * spilled cells in the range carry no `af`. Maps to <f t="array" ref="..."/>
+     * on xlsx export and is captured from the same attribute on import.
+     */
+    af?: Maybe<string>;
+    /**
+     * Shared-formula provenance. xlsx encodes formula deduplication via
+     * `<f t="shared" si="N" ref="A1:A10">FORMULA</f>` on the leader cell
+     * and `<f t="shared" si="N"/>` on follower cells. The toolkit expands
+     * followers' formulas via `formulaToRelativeReference` on import so
+     * evaluation works, but the structural grouping is also captured here
+     * so the export can re-emit the `t="shared"` markers. The leader has
+     * both `si` and `ref` set; followers carry only `si`.
+     */
+    sf?: Maybe<{
+        si: number;
+        ref?: string;
+    }>;
+};
+export type FunctionParameter = {
+    title: string;
+    description: string;
+};
+export type CalculatorFunction = {
+    title: string;
+    description: string;
+    example?: string;
+    syntax: string;
+    datatype: string;
+    usage?: string[];
+    parameters: FunctionParameter[];
+};
+export type Citation = {
+    id: string;
+    range: SheetRange;
+    /** Citation URL string in the standard Athena citation format */
+    citation_string: string;
+    active?: boolean;
+    created_at?: string;
+    created_by?: string;
+    updated_at?: string;
+    updated_by?: string;
+};
+/**
+ * A single message within a {@link CommentThread}. The first message in a
+ * thread is the root comment; subsequent messages are replies.
+ */
+export type CommentMessage = {
+    id: string;
+    /** Plain-text body. Rich/markdown sources must be flattened to text. */
+    text: string;
+    /** Stable author identity (e.g. user id). Dedupes authors on export. */
+    authorId: string;
+    /** Human-readable author name shown in Excel's Comments pane. */
+    authorName: string;
+    /** ISO-8601 timestamp; emitted as the threaded comment's `dT`. */
+    createdAtISO?: string;
+};
+/**
+ * A cell comment thread. Placement is NOT carried here — the owning cell
+ * references the thread via {@link CellData.commentThreadId}, so `id` must
+ * match that value. Exported to XLSX as modern threaded comments.
+ */
+export type CommentThread = {
+    id: string;
+    messages: CommentMessage[];
+    resolved?: boolean;
+};
+//# sourceMappingURL=index.d.ts.map