@opengeni/artifact-tool 0.2.2

package/dist/spreadsheet.d.ts

@@ -0,0 +1,724 @@
+import { type CellAddress, type RangeAddress } from "./spreadsheet-address.js";
+import { type FormulaEvaluationLimits } from "./spreadsheet-formula.js";
+import type { CellData, CellFormat, CellValue, ConditionalFormatConfig, DataValidationConfig, FormulaResult, HelpOptions, InspectOptions, InspectResult, RenderSpreadsheetOptions, SpreadsheetChartConfig, SpreadsheetChartSeriesConfig, SpreadsheetChartType, SpreadsheetImageConfig, SpreadsheetSparklineAxisOptions, SpreadsheetSparklineMarkersOptions, SpreadsheetSparklineOptions, SpreadsheetSparklineType } from "./spreadsheet-types.js";
+import type { FileBlob } from "./file-blob.js";
+export { InvalidSpreadsheetImageError } from "./spreadsheet-image.js";
+declare const STORED_CELL_ENTRIES: unique symbol;
+declare const CONNECT_CHART_POINT_COUNTER: unique symbol;
+declare const RESERVE_WORKBOOK_RESOURCE: unique symbol;
+declare const RELEASE_WORKBOOK_RESOURCE: unique symbol;
+type Matrix<T> = T[][];
+type WorkbookChangeListener = (change: WorkbookChange) => void;
+export type WorkbookOptions = {
+    formulaLimits?: Partial<FormulaEvaluationLimits>;
+    recalculationLimits?: Partial<SpreadsheetRecalculationLimits>;
+};
+export type SpreadsheetRecalculationLimits = {
+    maxCellReads: number;
+    maxOperations: number;
+};
+export type RangeWritePayload = {
+    values: Matrix<CellValue>;
+    formulas?: never;
+    formulasR1C1?: never;
+} | {
+    values?: never;
+    formulas: Matrix<string | null>;
+    formulasR1C1?: never;
+} | {
+    values?: never;
+    formulas?: never;
+    formulasR1C1: Matrix<string | null>;
+};
+export type SparklineConfig = SpreadsheetSparklineOptions & {
+    type: SpreadsheetSparklineType;
+    targetRange: Range | string;
+    sourceData: Range | string;
+    dateAxisRange?: Range | string;
+};
+export type RangeSparklineConfig = SpreadsheetSparklineOptions & {
+    dateAxisRange?: Range | string;
+};
+export type WorkbookChange = {
+    revision: number;
+    sheetIds: readonly string[];
+    reason: "content" | "format" | "structure" | "drawing" | "comment" | "dimension";
+};
+export type SerializedWorkbook = {
+    version: 1;
+    worksheets: SerializedWorksheet[];
+    comments: SerializedCommentThread[];
+};
+/** Hard, non-relaxable resource limits for untrusted workbook snapshots. */
+export declare const SPREADSHEET_SNAPSHOT_LIMITS: Readonly<{
+    sheets: 1024;
+    cellsPerSheet: 1000000;
+    cellsTotal: 1000000;
+    mergesPerSheet: 100000;
+    mergesTotal: 100000;
+    dimensionOverridesPerSheet: 1000000;
+    dimensionOverridesTotal: 1000000;
+    tablesPerSheet: 1024;
+    tablesTotal: 10000;
+    chartsPerSheet: 1024;
+    chartsTotal: 10000;
+    chartSeriesTotal: 100000;
+    chartPointsTotal: 1000000;
+    sparklineGroupsPerSheet: 1024;
+    sparklineGroupsTotal: 10000;
+    sparklineCellsPerSheet: 100000;
+    sparklineCellsTotal: 100000;
+    sparklinePointsPerSheet: 1000000;
+    sparklinePointsTotal: 1000000;
+    dataValidationsPerSheet: 100000;
+    dataValidationsTotal: 100000;
+    conditionalFormatsPerSheet: 100000;
+    conditionalFormatsTotal: 100000;
+    configNodesTotal: 1000000;
+    imagesPerSheet: 10000;
+    imagesTotal: 10000;
+    imageBytesEach: number;
+    imageDataUrlBytesEach: number;
+    imageBytesTotal: number;
+    imageDataUrlBytesTotal: number;
+    commentThreads: 100000;
+    commentsPerThread: 1000;
+    commentsTotal: 500000;
+    dimensionValueMinimum: 1;
+    dimensionValue: 1000000;
+    imageOffsetPx: 1000000;
+    imageExtentPx: 1000000;
+    fontSize: 4096;
+    borderWeight: 4096;
+    stringBytesEach: number;
+    stringBytesTotal: number;
+}>;
+type WorkbookResource = "cells" | "merges" | "dimensionOverrides" | "tables" | "charts" | "chartSeries" | "chartPoints" | "sparklineGroups" | "sparklineCells" | "sparklinePoints" | "dataValidations" | "conditionalFormats" | "images" | "imageBytes" | "imageDataUrlBytes" | "commentThreads" | "comments";
+/** Aggregate fuel for one full Workbook.recalculate() transaction. */
+export declare const SPREADSHEET_RECALCULATION_LIMITS: Readonly<{
+    maxCellReads: 5000000;
+    maxOperations: 10000000;
+}>;
+type SerializedWorksheet = {
+    id: string;
+    name: string;
+    showGridLines: boolean;
+    freezePanes: {
+        rows: number;
+        columns: number;
+    };
+    cells: Array<{
+        row: number;
+        col: number;
+        value: SerializedCellValue;
+        formula: string | null;
+        format: CellFormat;
+    }>;
+    merges: RangeAddress[];
+    columnWidths: Array<[number, number]>;
+    rowHeights: Array<[number, number]>;
+    tables: SerializedTable[];
+    charts: SerializedChart[];
+    sparklines: SerializedSparklineGroup[];
+    dataValidations: SerializedDataValidation[];
+    conditionalFormattings: SerializedConditionalFormatting[];
+    images: SpreadsheetImageConfig[];
+};
+type SerializedCellValue = Exclude<CellValue, Date> | {
+    type: "date";
+    value: string;
+};
+type SerializedTable = {
+    id: string;
+    name: string;
+    range: RangeAddress;
+    hasHeaders: boolean;
+    style: string;
+    showHeaders: boolean;
+    showTotals: boolean;
+    showBandedColumns: boolean;
+    showFilterButton: boolean;
+};
+type SerializedChart = {
+    id: string;
+    name: string;
+    type: SpreadsheetChartType;
+    title: string;
+    hasLegend: boolean;
+    sourceRange: RangeAddress | null;
+    series: SpreadsheetChartSeriesConfig[];
+    position: {
+        from: RangeAddress;
+        to: RangeAddress;
+    } | null;
+};
+type SerializedRangeReference = {
+    sheetId: string;
+    address: RangeAddress;
+};
+type SerializedSparklineGroup = {
+    id: string;
+    type: SpreadsheetSparklineType;
+    targetRange: RangeAddress;
+    sourceData: SerializedRangeReference;
+    dateAxisRange: SerializedRangeReference | null;
+    lineWeight: number;
+    displayHidden: boolean;
+    displayEmptyCellsAs: 0 | 1 | 2;
+    seriesColor: string | null;
+    negativeColor: string | null;
+    axisColor: string | null;
+    markersColor: string | null;
+    firstMarkerColor: string | null;
+    lastMarkerColor: string | null;
+    highMarkerColor: string | null;
+    lowMarkerColor: string | null;
+    markers: Required<SpreadsheetSparklineMarkersOptions>;
+    axis: {
+        showAxis: boolean;
+        manualMin: number | null;
+        manualMax: number | null;
+        rightToLeft: boolean;
+    };
+};
+type SerializedDataValidation = {
+    range: RangeAddress;
+    config: DataValidationConfig;
+};
+type SerializedConditionalFormatting = {
+    range: RangeAddress;
+    ruleType: string;
+    config: ConditionalFormatConfig;
+};
+type SerializedCommentThread = {
+    id: string;
+    sheetId: string;
+    cell: CellAddress;
+    resolved: boolean;
+    comments: Array<{
+        author: string;
+        text: string;
+        createdAt: string;
+    }>;
+};
+/** Validate an untrusted snapshot completely without constructing or mutating a Workbook. */
+export declare function validateSerializedWorkbook(input: unknown): asserts input is SerializedWorkbook;
+/**
+ * Skill-compatible TypeScript reference workbook used by conformance tests,
+ * codecs, and local development. It is not selected as a production kernel
+ * fallback; production editing must use the native or Worker/WASM session.
+ */
+export declare class Workbook {
+    readonly worksheets: WorksheetCollection;
+    readonly comments: WorkbookComments;
+    private revisionValue;
+    private transactionDepth;
+    private changedSheets;
+    private pendingReason;
+    private readonly listeners;
+    private calculationRevision;
+    private readonly calculationCache;
+    private readonly calculationStack;
+    private readonly objects;
+    private nextObjectId;
+    private readonly resourceCounts;
+    readonly formulaLimits: Readonly<FormulaEvaluationLimits>;
+    readonly recalculationLimits: Readonly<SpreadsheetRecalculationLimits>;
+    private constructor();
+    static create(options?: WorkbookOptions): Workbook;
+    static fromCSV(csvText: string, options?: {
+        sheetName?: string;
+        delimiter?: string;
+    }): Promise<Workbook>;
+    get revision(): number;
+    transact<T>(callback: () => T): T;
+    onChange(listener: WorkbookChangeListener): () => void;
+    recalculate(): void;
+    trace(reference: string): {
+        root: string;
+        nodes: Array<Record<string, unknown>>;
+    };
+    inspect(options: InspectOptions): Promise<InspectResult>;
+    help(query: string, options?: HelpOptions): InspectResult;
+    render(options?: RenderSpreadsheetOptions): Promise<FileBlob>;
+    resolve(id: string): unknown;
+    toJSON(): SerializedWorkbook;
+    static fromJSON(input: unknown): Workbook;
+    valueAt(sheet: Worksheet, address: CellAddress): FormulaResult;
+    markChanged(sheetId: string, reason: WorkbookChange["reason"]): void;
+    allocateId(prefix: string, value: unknown): string;
+    registerId(id: string, value: unknown): void;
+    [RESERVE_WORKBOOK_RESOURCE](resource: WorkbookResource, count?: number): void;
+    [RELEASE_WORKBOOK_RESOURCE](resource: WorkbookResource, count?: number): void;
+    private evaluateCell;
+    private commit;
+}
+export declare class WorksheetCollection {
+    private readonly workbook;
+    readonly items: Worksheet[];
+    private activeIndex;
+    constructor(workbook: Workbook);
+    add(name: string): Worksheet;
+    getItem(nameOrId: string): Worksheet;
+    getOrAdd(name: string, options?: {
+        renameFirstIfOnlyNewSpreadsheet?: boolean;
+    }): Worksheet;
+    getItemAt(index: number): Worksheet;
+    getActiveWorksheet(): Worksheet;
+    setActiveWorksheet(sheet: Worksheet): void;
+    restore(serialized: SerializedWorksheet): Worksheet;
+}
+export declare class Worksheet {
+    readonly workbook: Workbook;
+    readonly id: string;
+    showGridLines: boolean;
+    readonly freezePanes: FreezePanes;
+    readonly tables: TableCollection;
+    readonly charts: ChartCollection;
+    readonly sparklineGroups: SparklineGroupCollection;
+    /** Skill-compatible alias. */
+    readonly sparklines: SparklineGroupCollection;
+    readonly shapes: ShapeCollection;
+    readonly images: ImageCollection;
+    readonly dataValidations: DataValidationCollection;
+    readonly conditionalFormattings: ConditionalFormattingCollection;
+    private readonly cells;
+    private readonly merges;
+    private readonly columnWidths;
+    private readonly rowHeights;
+    private nameValue;
+    constructor(workbook: Workbook, name: string, existingId?: string);
+    get name(): string;
+    set name(name: string);
+    getRange(address: string): Range;
+    getRangeByIndexes(startRow: number, startCol: number, rowCount: number, colCount: number): Range;
+    getCell(row: number, col: number): Range;
+    getUsedRange(valuesOnly?: boolean): Range | null;
+    mergeCells(address: string): void;
+    unmergeCells(address: string): void;
+    deleteAllDrawings(): void;
+    fromCSV(csvText: string, options?: {
+        sheetName?: string;
+        delimiter?: string;
+    }): Promise<void>;
+    cellData(row: number, col: number): Readonly<CellData>;
+    setCell(row: number, col: number, update: Partial<CellData>, reason: WorkbookChange["reason"]): void;
+    cellEntries(): IterableIterator<{
+        row: number;
+        col: number;
+        data: CellData;
+    }>;
+    [STORED_CELL_ENTRIES](): IterableIterator<[number, CellData]>;
+    usedRangeAddress(valuesOnly?: boolean): RangeAddress | null;
+    formulaCount(): number;
+    addMerge(address: RangeAddress): void;
+    removeMergesOverlapping(address: RangeAddress): void;
+    mergeRegions(): readonly RangeAddress[];
+    setColumnWidth(col: number, width: number): void;
+    columnWidth(col: number): number;
+    get defaultColumnWidth(): number;
+    columnWidthEntries(): IterableIterator<readonly [number, number]>;
+    setRowHeight(row: number, height: number): void;
+    rowHeight(row: number): number;
+    get defaultRowHeight(): number;
+    rowHeightEntries(): IterableIterator<readonly [number, number]>;
+    private assertDimensionCapacity;
+    serialize(): SerializedWorksheet;
+    restore(serialized: SerializedWorksheet): void;
+    restoreSparklines(serialized: readonly SerializedSparklineGroup[]): void;
+}
+export declare class Range {
+    readonly worksheet: Worksheet;
+    readonly address: RangeAddress;
+    readonly conditionalFormats: RangeConditionalFormats;
+    readonly sparklines: RangeSparklines;
+    constructor(worksheet: Worksheet, address: RangeAddress);
+    get values(): Matrix<FormulaResult>;
+    set values(values: Matrix<CellValue>);
+    get formulas(): Matrix<string | null>;
+    set formulas(formulas: Matrix<string | null>);
+    get formulasR1C1(): Matrix<string | null>;
+    set formulasR1C1(formulas: Matrix<string | null>);
+    get displayFormulas(): Matrix<string | null>;
+    get formulaInfos(): Matrix<Record<string, unknown> | null>;
+    get format(): RangeFormat;
+    set format(value: CellFormat);
+    get dataValidation(): DataValidationConfig | null;
+    set dataValidation(config: DataValidationConfig | null);
+    write(input: Matrix<CellValue> | RangeWritePayload): Range;
+    writeValues(values: Matrix<CellValue>): Range;
+    fillDown(): void;
+    fillRight(): void;
+    clear(options?: {
+        applyTo?: "contents" | "formats" | "all";
+    }): void;
+    copyFrom(source: Range, mode?: "values" | "formulas" | "all"): void;
+    copyTo(destination: Range, mode?: "values" | "formulas" | "all"): void;
+    offset(rowOffset: number, colOffset: number): Range;
+    resize(rowCount: number, colCount: number): Range;
+    getCurrentRegion(): Range;
+    getRow(index: number): Range;
+    getColumn(index: number): Range;
+    getRangeByIndexes(startRow: number, startCol: number, rowCount: number, colCount: number): Range;
+    getCell(row: number, col: number): Range;
+    merge(across?: boolean): void;
+    unmerge(): void;
+    setNumberFormat(format: string): void;
+    applyFormat(format: CellFormat): void;
+}
+export declare class RangeFormat {
+    private readonly range;
+    constructor(range: Range);
+    set fill(value: string | undefined);
+    set font(value: CellFormat["font"]);
+    set numberFormat(value: string | Matrix<string>);
+    set borders(value: CellFormat["borders"]);
+    set horizontalAlignment(value: CellFormat["horizontalAlignment"]);
+    set verticalAlignment(value: CellFormat["verticalAlignment"]);
+    set wrapText(value: boolean | undefined);
+    set columnWidth(value: number);
+    set columnWidthPx(value: number);
+    set rowHeight(value: number);
+    set rowHeightPx(value: number);
+    autofitColumns(): void;
+    autofitRows(): void;
+}
+export declare class FreezePanes {
+    private readonly worksheet;
+    private rows;
+    private columns;
+    constructor(worksheet: Worksheet);
+    freezeRows(count: number): void;
+    freezeColumns(count: number): void;
+    unfreeze(): void;
+    snapshot(): {
+        rows: number;
+        columns: number;
+    };
+    restore(value: {
+        rows: number;
+        columns: number;
+    }): void;
+}
+export declare class TableCollection {
+    private readonly worksheet;
+    readonly items: Table[];
+    constructor(worksheet: Worksheet);
+    add(range: string | Range, hasHeaders: boolean, name: string): Table;
+    remove(table: Table): void;
+    restore(serialized: SerializedTable): void;
+}
+export declare class Table {
+    private readonly worksheet;
+    readonly hasHeaders: boolean;
+    readonly id: string;
+    private rangeValue;
+    private nameValue;
+    private styleValue;
+    showHeaders: boolean;
+    showTotals: boolean;
+    showBandedColumns: boolean;
+    showFilterButton: boolean;
+    readonly rows: {
+        add: (index: number | null, rows: Matrix<CellValue>) => void;
+    };
+    constructor(worksheet: Worksheet, name: string, address: RangeAddress, hasHeaders: boolean, restore?: SerializedTable);
+    get name(): string;
+    set name(value: string);
+    get range(): Range;
+    set range(value: Range);
+    get style(): string;
+    set style(value: string);
+    getDataRows(): Range;
+    getHeaderRowRange(): Range;
+    delete(): void;
+    inspectRecord(): Record<string, unknown>;
+    serialize(): SerializedTable;
+    private addRows;
+}
+export declare class ChartCollection {
+    private readonly worksheet;
+    readonly items: SpreadsheetChart[];
+    constructor(worksheet: Worksheet);
+    add(type: SpreadsheetChartType, sourceOrConfig?: Range | SpreadsheetChartConfig): SpreadsheetChart;
+    getItemOrNullObject(name: string): SpreadsheetChart | null;
+    deleteAll(): void;
+    restore(serialized: SerializedChart): void;
+}
+export declare class SpreadsheetChart {
+    private readonly worksheet;
+    readonly id: string;
+    readonly name: string;
+    type: SpreadsheetChartType;
+    private titleValue;
+    hasLegend: boolean;
+    xAxis: Record<string, unknown>;
+    yAxis: Record<string, unknown>;
+    readonly titleTextStyle: Record<string, unknown>;
+    readonly series: ChartSeriesCollection;
+    sourceRange: Range | null;
+    private positionValue;
+    constructor(worksheet: Worksheet, type: SpreadsheetChartType, sourceOrConfig?: Range | SpreadsheetChartConfig | SerializedChart);
+    get title(): string;
+    set title(value: string);
+    get position(): {
+        from: RangeAddress;
+        to: RangeAddress;
+    } | null;
+    set position(value: {
+        from: RangeAddress;
+        to: RangeAddress;
+    } | null);
+    setPosition(from: string, to: string): void;
+    setData(range: Range): void;
+    inspectRecord(): Record<string, unknown>;
+    serialize(): SerializedChart;
+    private inferSeries;
+}
+export declare class ChartSeriesCollection {
+    private readonly workbook;
+    readonly items: SpreadsheetChartSeries[];
+    private attached;
+    constructor(workbook: Workbook);
+    add(name: string, config?: Partial<SpreadsheetChartSeriesConfig>): SpreadsheetChartSeries;
+    clear(): void;
+    attach(): void;
+    detach(): void;
+    private adjustPoints;
+}
+export declare class SpreadsheetChartSeries {
+    private nameValue;
+    private formulaValue;
+    private categoryFormulaValue;
+    private valuesValue;
+    private categoriesValue;
+    private fillValue;
+    private onPointCountChange;
+    constructor(name: string, config?: Partial<SpreadsheetChartSeriesConfig>);
+    get name(): string;
+    set name(value: string);
+    get formula(): string | undefined;
+    set formula(value: string | undefined);
+    get categoryFormula(): string | undefined;
+    set categoryFormula(value: string | undefined);
+    get values(): number[] | undefined;
+    set values(value: number[] | undefined);
+    get categories(): Array<string | number> | undefined;
+    set categories(value: Array<string | number> | undefined);
+    get fill(): string | undefined;
+    set fill(value: string | undefined);
+    get pointCount(): number;
+    [CONNECT_CHART_POINT_COUNTER](counter: (delta: number) => void): void;
+    toJSON(): SpreadsheetChartSeriesConfig;
+}
+export declare class ShapeCollection {
+    private readonly worksheet;
+    readonly items: SpreadsheetShape[];
+    constructor(worksheet: Worksheet);
+    add(_config: Record<string, unknown>): SpreadsheetShape;
+    deleteAll(): void;
+}
+export declare class SpreadsheetShape {
+    readonly worksheet: Worksheet;
+    readonly config: Record<string, unknown>;
+    readonly id: string;
+    constructor(worksheet: Worksheet, config: Record<string, unknown>);
+}
+export declare class ImageCollection {
+    private readonly worksheet;
+    readonly items: SpreadsheetImage[];
+    constructor(worksheet: Worksheet);
+    add(config: SpreadsheetImageConfig): SpreadsheetImage;
+    deleteAll(): void;
+}
+export declare class SpreadsheetImage {
+    private readonly worksheet;
+    readonly config: SpreadsheetImageConfig;
+    readonly id: string;
+    constructor(worksheet: Worksheet, config: SpreadsheetImageConfig);
+    inspectRecord(): Record<string, unknown>;
+}
+export declare class DataValidationCollection {
+    private readonly worksheet;
+    private readonly entries;
+    constructor(worksheet: Worksheet);
+    add(input: {
+        range: string;
+        rule: Record<string, unknown>;
+    }): void;
+    get(range: RangeAddress): DataValidationConfig | null;
+    remove(range: RangeAddress): void;
+    all(): readonly {
+        range: RangeAddress;
+        config: DataValidationConfig;
+    }[];
+    serialize(): SerializedDataValidation[];
+    restore(entries: readonly SerializedDataValidation[]): void;
+}
+export declare class ConditionalFormattingCollection {
+    private readonly worksheet;
+    private readonly entries;
+    constructor(worksheet: Worksheet);
+    add(range: RangeAddress, ruleType: string, config: ConditionalFormatConfig): void;
+    clear(range?: RangeAddress): void;
+    all(): readonly {
+        range: RangeAddress;
+        ruleType: string;
+        config: ConditionalFormatConfig;
+    }[];
+    serialize(): SerializedConditionalFormatting[];
+    restore(entries: readonly SerializedConditionalFormatting[]): void;
+}
+export declare class RangeConditionalFormats {
+    private readonly range;
+    constructor(range: Range);
+    add(ruleType: string, config: ConditionalFormatConfig): void;
+    addCustom(expression: string, format: ConditionalFormatConfig): void;
+    deleteAll(): void;
+    clear(): void;
+}
+export declare class RangeSparklines {
+    private readonly range;
+    constructor(range: Range);
+    add(type: SpreadsheetSparklineType, sourceRange: Range | string, config?: RangeSparklineConfig): SparklineGroup;
+    deleteAll(): void;
+    clear(): void;
+}
+export declare class SparklineGroupCollection {
+    private readonly worksheet;
+    readonly items: SparklineGroup[];
+    private targetCellCount;
+    private sourcePointCount;
+    constructor(worksheet: Worksheet);
+    add(config: SparklineConfig): SparklineGroup;
+    deleteAll(): void;
+    removeInRange(range: RangeAddress): void;
+    remove(group: SparklineGroup): void;
+    restore(serialized: SerializedSparklineGroup): void;
+    private insert;
+}
+type NormalizedSparklineGroup = {
+    existingId?: string;
+    type: SpreadsheetSparklineType;
+    targetRange: Range;
+    sourceData: Range;
+    dateAxisRange: Range | null;
+    lineWeight: number;
+    displayHidden: boolean;
+    displayEmptyCellsAs: 0 | 1 | 2;
+    seriesColor: string | null;
+    negativeColor: string | null;
+    axisColor: string | null;
+    markersColor: string | null;
+    firstMarkerColor: string | null;
+    lastMarkerColor: string | null;
+    highMarkerColor: string | null;
+    lowMarkerColor: string | null;
+    markers: Readonly<Required<SpreadsheetSparklineMarkersOptions>>;
+    axis: Readonly<{
+        showAxis: boolean;
+        manualMin: number | null;
+        manualMax: number | null;
+        rightToLeft: boolean;
+    }>;
+};
+export declare class SparklineGroup {
+    private readonly collection;
+    private readonly worksheet;
+    readonly id: string;
+    readonly targetRange: Range;
+    readonly sourceData: Range;
+    readonly dateAxisRange: Range | null;
+    readonly resourceUsage: Readonly<{
+        targetCells: number;
+        readPoints: number;
+        pointsPerSparkline: number;
+    }>;
+    private typeValue;
+    private lineWeightValue;
+    private displayHiddenValue;
+    private displayEmptyCellsAsValue;
+    private seriesColorValue;
+    private negativeColorValue;
+    private axisColorValue;
+    private markersColorValue;
+    private firstMarkerColorValue;
+    private lastMarkerColorValue;
+    private highMarkerColorValue;
+    private lowMarkerColorValue;
+    private markersValue;
+    private axisValue;
+    constructor(collection: SparklineGroupCollection, worksheet: Worksheet, state: NormalizedSparklineGroup, usage: {
+        targetCells: number;
+        readPoints: number;
+        pointsPerSparkline: number;
+    });
+    get type(): SpreadsheetSparklineType;
+    set type(value: SpreadsheetSparklineType);
+    get lineWeight(): number;
+    set lineWeight(value: number);
+    get displayHidden(): boolean;
+    set displayHidden(value: boolean);
+    get displayEmptyCellsAs(): 0 | 1 | 2;
+    set displayEmptyCellsAs(value: 0 | 1 | 2);
+    get seriesColor(): string | undefined;
+    set seriesColor(value: string | undefined);
+    get negativeColor(): string | undefined;
+    set negativeColor(value: string | undefined);
+    get axisColor(): string | undefined;
+    set axisColor(value: string | undefined);
+    get markersColor(): string | undefined;
+    set markersColor(value: string | undefined);
+    get firstMarkerColor(): string | undefined;
+    set firstMarkerColor(value: string | undefined);
+    get lastMarkerColor(): string | undefined;
+    set lastMarkerColor(value: string | undefined);
+    get highMarkerColor(): string | undefined;
+    set highMarkerColor(value: string | undefined);
+    get lowMarkerColor(): string | undefined;
+    set lowMarkerColor(value: string | undefined);
+    get markers(): Readonly<Required<SpreadsheetSparklineMarkersOptions>>;
+    set markers(value: SpreadsheetSparklineMarkersOptions);
+    get axis(): Readonly<SpreadsheetSparklineAxisOptions>;
+    set axis(value: SpreadsheetSparklineAxisOptions);
+    delete(): void;
+    valuesForTargetCell(row: number, col: number): readonly (number | null)[];
+    dateAxisValues(): readonly (number | null)[] | null;
+    inspectRecord(): Record<string, unknown>;
+    serialize(): SerializedSparklineGroup;
+    private numericValueAt;
+    private setColor;
+    private changed;
+}
+export declare class WorkbookComments {
+    private readonly workbook;
+    readonly items: CommentThread[];
+    private displayName;
+    constructor(workbook: Workbook);
+    setSelf(input: {
+        displayName: string;
+    }): void;
+    addThread(target: {
+        cell: Range;
+    }, text: string): CommentThread;
+    restore(serialized: SerializedCommentThread): void;
+}
+export declare class CommentThread {
+    private readonly workbook;
+    private readonly worksheet;
+    readonly id: string;
+    private resolvedValue;
+    readonly comments: Array<{
+        author: string;
+        text: string;
+        createdAt: string;
+    }>;
+    private readonly cell;
+    constructor(workbook: Workbook, worksheet: Worksheet, cell: CellAddress, author: string, text: string, existingId?: string);
+    addReply(text: string): void;
+    resolve(): void;
+    reopen(): void;
+    inspectRecord(): Record<string, unknown>;
+    serialize(): SerializedCommentThread;
+    static restore(workbook: Workbook, worksheet: Worksheet, serialized: SerializedCommentThread): CommentThread;
+}