@ai-matrx/office 0.3.1 → 0.4.0

package/dist/sheets.d.cts

@@ -0,0 +1,605 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { ServiceResult } from '@ai-matrx/records/core';
+
+/**
+ * The host ports of the Sheets model and io.
+ *
+ * The package owns the workbook service, the page-setup store and the import flow, but three things
+ * belong to the app that mounts them: the database client (a package owns no client), the
+ * organization a write acts in (the active-organization ladder is app state) and the file store that
+ * keeps a lossless copy of an imported file. The host states them once at start-up with
+ * `configureSheetsHost`. State sits on a `globalThis` slot so a dual-bundled copy of the package
+ * still sees one host. An unconfigured port THROWS naming itself (nothing fails silently).
+ */
+
+/** A Supabase client over any schema: the package cannot import the app's generated database types. */
+type SheetsSupabase = SupabaseClient<any, any, any>;
+interface SheetsHostPorts {
+    /** The app's database client (signed in as the person). */
+    getSupabase(): SheetsSupabase;
+    /** The organization a write acts in: the record's own when given, otherwise the active one. */
+    ensureOrgId(organizationId: string | null): Promise<string>;
+    /** Keep the original of an imported spreadsheet in the file store, in `folderPath`. */
+    uploadOriginalFile(file: File, options: {
+        folderPath: string;
+    }): Promise<{
+        fileId: string;
+    }>;
+}
+declare function configureSheetsHost(ports: SheetsHostPorts): void;
+declare function getSheetsHost(): SheetsHostPorts;
+
+/**
+ * The Office record rows: the workbook and document rows and their snapshots, exactly as the
+ * `workbench` schema returns them (moved from matrx-frontend `features/data-tables/types`, W1-G1a).
+ * Written out here because a package cannot import an app's generated database types; the app proves
+ * the two agree with a compile-time check against its generated `Database` type.
+ *
+ * `Json` columns are `unknown`: a reader narrows what it reads, nothing is assumed.
+ */
+type WorkbookSource = "created" | "imported_xlsx" | "imported_gsheet" | "imported_csv" | "linked_gsheet";
+/** `platform.shown_to`. */
+type ShownTo = "only_me" | "my_team" | "everyone" | "everyone_on_ai_matrx";
+/** `platform.visibility`. */
+type Visibility = "personal" | "internal" | "link" | "public";
+/** Origin of a snapshot. Free text in the database; this union is advisory. */
+type WorkbookSnapshotOrigin = "autosave" | "manual" | "imported" | "restored" | "named";
+/** A row of `workbench.udt_workbooks`. */
+interface Workbook$1 {
+    created_at: string;
+    created_by: string;
+    custom_fields: unknown;
+    deleted_at: string | null;
+    description: string | null;
+    id: string;
+    is_public: boolean;
+    metadata: unknown;
+    organization_id: string;
+    original_file_id: string | null;
+    project_id: string | null;
+    published_to_web: boolean;
+    published_to_web_at: string | null;
+    published_to_web_by: string | null;
+    shown_to: ShownTo | null;
+    source: WorkbookSource;
+    task_id: string | null;
+    updated_at: string;
+    updated_by: string | null;
+    user_id: string;
+    version: number;
+    visibility: Visibility;
+    workbook_name: string;
+}
+/** A row of `workbench.udt_workbook_snapshots`. */
+interface WorkbookSnapshot {
+    created_at: string;
+    created_by: string | null;
+    custom_fields: unknown;
+    id: string;
+    label: string | null;
+    metadata: unknown;
+    organization_id: string;
+    /** Free text in the database; "autosave" | "manual" | "imported" | "restored" by convention. */
+    origin: string;
+    snapshot: unknown;
+    workbook_id: string;
+}
+
+/** Honest, human label for `udt_workbooks.source`. */
+declare function workbookSourceLabel(source: string): string;
+type CreateWorkbookArgs = {
+    name: string;
+    description?: string | null;
+    /** Origin label for the workbook itself, mirrors `udt_workbooks.source`. */
+    source?: "created" | "imported_xlsx" | "imported_gsheet" | "imported_csv" | "linked_gsheet";
+    organizationId: string;
+    projectId?: string | null;
+    taskId?: string | null;
+    isPublic?: boolean;
+    /**
+     * cld_files.id of the source upload (XLSX / CSV blob). Set on the import
+     * flow so the lossless original is recoverable; FK is ON DELETE SET NULL,
+     * so deleting the file just nulls the link — the workbook survives.
+     */
+    originalFileId?: string | null;
+};
+declare function createWorkbook(args: CreateWorkbookArgs): Promise<ServiceResult<Workbook$1>>;
+declare function listAccessibleWorkbooks(): Promise<ServiceResult<Workbook$1[]>>;
+declare function getWorkbook(workbookId: string): Promise<ServiceResult<Workbook$1>>;
+declare function renameWorkbook(workbookId: string, name: string): Promise<ServiceResult<Workbook$1>>;
+/**
+ * Move the workbook into a project (or out of one with `null`). Sibling of
+ * `renameWorkbook`: the one named setter for `project_id`.
+ */
+declare function moveWorkbook(workbookId: string, projectId: string | null): Promise<ServiceResult<Workbook$1>>;
+/**
+ * Rewrite the workbook's description. Sibling of `renameWorkbook` — the two
+ * human-authored fields on `udt_workbooks` each get a named setter so callers
+ * never hand-roll a `.from("udt_workbooks").update(...)`. Pass `null` (or an
+ * empty string) to clear it.
+ *
+ * Written by the import flow at creation ("Imported from <file>") and, since
+ * the workbooks surface became agent-writable, by the `workbook_description`
+ * write target on `/workbooks/[id]`.
+ */
+declare function updateWorkbookDescription(workbookId: string, description: string | null): Promise<ServiceResult<Workbook$1>>;
+/**
+ * Soft delete — the workbook is tombstoned, not destroyed, and its snapshots stay
+ * with it. Every read path filters `deleted_at is null`. Pair with
+ * restoreWorkbook for undo.
+ */
+declare function deleteWorkbook(workbookId: string): Promise<ServiceResult<true>>;
+/**
+ * Archive (delete means archive: never a hard delete) — only for rolling back a workbook this very flow just created and
+ * failed to populate (see the import path in app/(core)/workbooks/page.tsx).
+ * Never use this for a user-initiated delete: that is deleteWorkbook, which
+ * tombstones and stays recoverable.
+ */
+declare function discardFailedWorkbook(workbookId: string): Promise<ServiceResult<true>>;
+declare function restoreWorkbook(workbookId: string): Promise<ServiceResult<true>>;
+/** Trash view: the caller's own archived workbooks (RLS decides what is readable). */
+declare function listTrashedWorkbooks(): Promise<ServiceResult<Workbook$1[]>>;
+/**
+ * An independent copy of a workbook: its own row in the original's organization
+ * and project, with the latest snapshot copied over. Editing the copy never
+ * touches the original.
+ */
+declare function copyWorkbook(workbookId: string, name?: string): Promise<ServiceResult<Workbook$1>>;
+/**
+ * Latest-snapshot fetch — what an opened workbook hydrates from. Returns
+ * `data: null` (success path) when the workbook has no snapshots yet (newly
+ * created, never saved). Distinguish "no snapshot" from "load error" by
+ * checking `result.data === null`.
+ */
+declare function getLatestSnapshot(workbookId: string): Promise<ServiceResult<WorkbookSnapshot | null>>;
+type SaveSnapshotArgs = {
+    workbookId: string;
+    snapshot: unknown;
+    label?: string | null;
+    origin?: WorkbookSnapshotOrigin;
+};
+declare function saveSnapshot(args: SaveSnapshotArgs): Promise<ServiceResult<WorkbookSnapshot>>;
+declare function listSnapshots(workbookId: string, limit?: number): Promise<ServiceResult<WorkbookSnapshot[]>>;
+
+/**
+ * features/workbooks/univer-snapshot-rows.ts
+ *
+ * Snapshot → rows: read a Univer `IWorkbookData` snapshot back out as a plain
+ * string grid. The missing half of the workbook round trip — `export-targets`
+ * pushes rows INTO a workbook; this reads the (possibly user-edited) values
+ * back OUT so features can offer "edit in the workbook, then import your
+ * changes". Values only (formulas come back as their cached value); first
+ * sheet by `sheetOrder` unless a sheet id is named. A number shown through a date format reads as
+ * its ISO date (a spreadsheet keeps dates as day serials). Reusable — do not fork a per-feature
+ * snapshot walker. Callers: the workbook's "Make this sheet a table" (features/workbooks/table-link).
+ */
+interface SnapshotRows {
+    sheetName: string;
+    /** Dense rectangular grid, trailing empty rows/columns trimmed. */
+    rows: string[][];
+    /** Rows pinned at the top of the sheet (Freeze rows), counted in `rows`. */
+    frozenRows: number;
+    /** Columns pinned at the left of the sheet (Freeze columns), counted in each row. */
+    frozenCols: number;
+}
+/** A zero-based, inclusive cell range (a selection). */
+interface CellRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+/** Sheet ids in tab order. */
+declare function univerSheetIds(snapshot: unknown): string[];
+/**
+ * Extract the first worksheet of a Univer workbook snapshot as a string grid.
+ * Returns null when the value is not snapshot-shaped or has no sheets.
+ * `skipHidden` leaves out hidden columns and rows: every read-only view (a share page, an agent's
+ * read) passes it, so the table link's hidden Record ID column never reaches a reader.
+ */
+declare function univerSnapshotToRows(snapshot: unknown, options?: {
+    sheetId?: string;
+    skipHidden?: boolean;
+    range?: CellRange;
+}): SnapshotRows | null;
+
+/**
+ * features/workbooks/snapshot-grid.ts
+ *
+ * Snapshot → a formatted, read-only grid model: what a spreadsheet VIEW needs and the plain-string
+ * `univer-snapshot-rows` does not carry — number/currency/date formats applied, checkbox cells
+ * (data-validation ranges of type checkbox), alignment, bold/italic, fill and text colour, column
+ * widths, merges, frozen rows/columns, hidden rows/columns and sheets. Pure (no DOM, no Univer
+ * runtime): the signed-out share page draws it. The number formatter is the thumbnail's
+ * (`formatCellValue`) so a tile, a share link and the editor read the same.
+ */
+interface GridCell {
+    text: string;
+    /** A checkbox cell (a data-validation checkbox range): `checked` says its state. */
+    checkbox?: {
+        checked: boolean;
+    } | undefined;
+    align: "left" | "center" | "right";
+    bold: boolean;
+    italic: boolean;
+    /** Font size in px (the snapshot stores points). */
+    fontPx: number;
+    bg?: string | undefined;
+    color?: string | undefined;
+    wrap: boolean;
+    rowSpan: number;
+    colSpan: number;
+    /** Covered by a merge that starts elsewhere: draw nothing. */
+    covered: boolean;
+}
+interface GridSheet {
+    id: string;
+    name: string;
+    /** Visible column indexes (hidden columns left out) with their pixel widths. */
+    columns: Array<{
+        index: number;
+        width: number;
+    }>;
+    rows: Array<{
+        index: number;
+        height: number;
+        cells: GridCell[];
+    }>;
+    /** How many leading VISIBLE rows / columns stay put while scrolling. */
+    frozenRows: number;
+    frozenColumns: number;
+    gridlines: boolean;
+    /** Rows beyond the cap were left out. */
+    truncatedFrom: number | null;
+}
+declare const GRID_MAX_ROWS = 500;
+declare const GRID_MAX_COLUMNS = 60;
+/** Every visible sheet that has something in it, in tab order. Empty and hidden sheets are left out. */
+declare function snapshotToGridSheets(snapshot: unknown): GridSheet[];
+
+/**
+ * snapshot → SVG: a faithful miniature of a Univer workbook's first sheet or a
+ * Univer document's first page — the gallery tile Google draws. Pure (no DOM,
+ * no Univer runtime), so it runs in the browser (thumbnail capture), in tests
+ * and in node. Reads only what a snapshot stores: cell values + styles +
+ * column widths + merges + conditional formats + checkboxes for sheets; the
+ * dataStream + text runs + paragraph styles + tables for documents.
+ */
+declare const THUMB_WIDTH = 320;
+declare const THUMB_HEIGHT = 414;
+type Rgb = {
+    rgb?: string | null;
+} | null | undefined;
+type CellStyle = {
+    bg?: Rgb;
+    cl?: Rgb;
+    bl?: number;
+    it?: number;
+    fs?: number;
+    ht?: number;
+    n?: {
+        pattern?: string;
+    } | null;
+    bd?: Record<string, unknown> | null;
+};
+type Cell = {
+    v?: unknown;
+    s?: string | CellStyle | null;
+    t?: number;
+    f?: string;
+};
+type Sheet = {
+    id?: string;
+    name?: string;
+    cellData?: Record<string, Record<string, Cell>>;
+    columnData?: Record<string, {
+        w?: number;
+        hd?: number;
+    }>;
+    rowData?: Record<string, {
+        h?: number;
+        hd?: number;
+    }>;
+    defaultColumnWidth?: number;
+    defaultRowHeight?: number;
+    mergeData?: Array<{
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    }>;
+    showGridlines?: number;
+    freeze?: {
+        ySplit?: number;
+        xSplit?: number;
+    };
+};
+type Workbook = {
+    sheetOrder?: string[];
+    sheets?: Record<string, Sheet>;
+    styles?: Record<string, CellStyle | null>;
+    resources?: Array<{
+        name?: string;
+        data?: string;
+    }>;
+};
+declare function formatCellValue(v: unknown, pattern?: string | null): string;
+type CfRule = {
+    rule?: {
+        type?: string;
+        subType?: string;
+        operator?: string;
+        value?: unknown;
+        style?: CellStyle;
+    };
+    ranges?: Array<{
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    }>;
+};
+declare function parseResource<T>(wb: Workbook, name: string): T | null;
+declare function cfMatch(rule: NonNullable<CfRule["rule"]>, v: unknown): boolean;
+declare function workbookPreviewSvg(snapshot: unknown): string;
+declare function documentPreviewSvg(snapshot: unknown): string;
+declare function snapshotPreviewSvg(kind: "workbook" | "document", snapshot: unknown): string;
+
+/**
+ * The ONE page geometry every Matrx cloud document is laid out with.
+ *
+ * Univer lays a document out inside `documentStyle.pageSize`. With no pageSize
+ * the docs renderer has no page box at all: text never wraps (it runs off the
+ * right edge) and the vertical extent is unbounded, so the docs viewport
+ * reports nothing to scroll — the wheel is swallowed and the page sits frozen
+ * at the top. Every writer of a Univer snapshot MUST stamp this style.
+ *
+ * Consumers: `DocumentEditor` (new empty doc), `markdown-to-univer-doc`
+ * (markdown import), and `sanitizeUniverDocSnapshot` (recovery for snapshots
+ * that reached storage without it — notably `origin='agent'` writes).
+ */
+
+/** Paper sizes the Page setup dialog offers, in 96-dpi pixels, portrait (width x height). */
+declare const PAPER_SIZES: {
+    readonly Letter: {
+        readonly width: 816;
+        readonly height: 1056;
+        readonly label: "Letter (8.5 x 11 in)";
+    };
+    readonly Legal: {
+        readonly width: 816;
+        readonly height: 1344;
+        readonly label: "Legal (8.5 x 14 in)";
+    };
+    readonly Tabloid: {
+        readonly width: 1056;
+        readonly height: 1632;
+        readonly label: "Tabloid (11 x 17 in)";
+    };
+    readonly Executive: {
+        readonly width: 696;
+        readonly height: 1008;
+        readonly label: "Executive (7.25 x 10.5 in)";
+    };
+    readonly Statement: {
+        readonly width: 528;
+        readonly height: 816;
+        readonly label: "Statement (5.5 x 8.5 in)";
+    };
+    readonly A3: {
+        readonly width: 1123;
+        readonly height: 1587;
+        readonly label: "A3 (11.69 x 16.54 in)";
+    };
+    readonly A4: {
+        readonly width: 794;
+        readonly height: 1124;
+        readonly label: "A4 (8.27 x 11.69 in)";
+    };
+    readonly A5: {
+        readonly width: 559;
+        readonly height: 794;
+        readonly label: "A5 (5.83 x 8.27 in)";
+    };
+};
+type PaperSizeName = keyof typeof PAPER_SIZES;
+
+/**
+ * A workbook's print settings — Google Sheets' File → Page setup / Print, as pure data and pure
+ * pagination (no React, no IO). They live on the workbook (`udt_workbooks.metadata.page_setup`),
+ * so Print, Download as PDF and the Page setup dialog all read the same values.
+ *
+ * Geometry is in 96-dpi CSS pixels, like the rest of the document stack (`PX_PER_INCH`).
+ */
+
+declare const SHEET_SCALES: readonly ["normal", "width", "height", "page"];
+type SheetScale = (typeof SHEET_SCALES)[number];
+declare const SHEET_MARGIN_PRESETS: readonly ["normal", "narrow", "wide", "custom"];
+type SheetMarginPreset = (typeof SHEET_MARGIN_PRESETS)[number];
+declare const SHEET_PRINT_SCOPES: readonly ["sheet", "workbook", "selection"];
+type SheetPrintScope = (typeof SHEET_PRINT_SCOPES)[number];
+type SheetPageOrder = "down-over" | "over-down";
+type SheetAlignH = "left" | "center" | "right";
+type SheetAlignV = "top" | "middle" | "bottom";
+interface SheetPageSetup {
+    paper: PaperSizeName;
+    orientation: "portrait" | "landscape";
+    scale: SheetScale;
+    margins: SheetMarginPreset;
+    /** Inches; read only when `margins` is "custom". */
+    customMargins: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    scope: SheetPrintScope;
+    gridlines: boolean;
+    repeatFrozenRows: boolean;
+    repeatFrozenColumns: boolean;
+    pageOrder: SheetPageOrder;
+    alignH: SheetAlignH;
+    alignV: SheetAlignV;
+}
+/** Google Sheets' defaults: Letter, portrait, 100%, normal margins, current sheet, gridlines on. */
+declare const DEFAULT_SHEET_PAGE_SETUP: SheetPageSetup;
+/** Google's three preset margins, in inches. */
+declare const MARGIN_PRESET_INCHES: Record<Exclude<SheetMarginPreset, "custom">, {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}>;
+/** Any stored value → a complete, valid setup. Unknown or broken parts fall back to the default. */
+declare function normalizeSheetPageSetup(raw: unknown): SheetPageSetup;
+/** The setup stored on a workbook's metadata (`metadata.page_setup`), complete and valid. */
+declare function pageSetupFromMetadata(metadata: unknown): SheetPageSetup;
+interface PrintGeometry {
+    /** Paper as printed (orientation applied), px. */
+    paperWidth: number;
+    paperHeight: number;
+    marginTop: number;
+    marginBottom: number;
+    marginLeft: number;
+    marginRight: number;
+    /** The printable box inside the margins, px. */
+    areaWidth: number;
+    areaHeight: number;
+}
+declare function printGeometry(setup: SheetPageSetup): PrintGeometry;
+declare const PRINT_ROW_HEIGHT = 22;
+/** Column widths (px) fitted to the text the column holds. */
+declare function printColumnWidths(rows: readonly (readonly string[])[]): number[];
+interface PrintPage {
+    /** Grid row indexes drawn on this page, in order (repeated frozen rows first). */
+    rows: number[];
+    /** Grid column indexes drawn on this page, in order (repeated frozen columns first). */
+    cols: number[];
+}
+interface PrintPlan {
+    scale: number;
+    geometry: PrintGeometry;
+    colWidths: number[];
+    pages: PrintPage[];
+}
+/** The pages one grid prints on under `setup`: scale, repeated frozen panes, and page order. */
+declare function planSheetPrint(rows: readonly (readonly string[])[], setup: SheetPageSetup, frozen?: {
+    rows: number;
+    cols: number;
+}): PrintPlan;
+
+type PageSetupResult = {
+    ok: true;
+    data: SheetPageSetup;
+} | {
+    ok: false;
+    error: string;
+};
+declare function readSheetPageSetup(workbookId: string): Promise<PageSetupResult>;
+declare function writeSheetPageSetup(workbookId: string, setup: SheetPageSetup): Promise<PageSetupResult>;
+
+/**
+ * The pages a workbook prints on: the snapshot's cells → paper-sized HTML pages that follow the
+ * workbook's print settings (`sheet-page-setup.ts`). Print and Download as PDF both draw these
+ * same pages, so what the browser prints is what the PDF holds.
+ */
+
+interface PrintSheet {
+    name: string;
+    rows: string[][];
+    frozenRows: number;
+    frozenCols: number;
+}
+/** The sheets the setup's "what to print" asks for (empty sheets left out). */
+declare function collectPrintSheets(snapshot: unknown, setup: SheetPageSetup, options: {
+    sheetId?: string;
+    selection?: CellRange | null;
+}): PrintSheet[];
+interface PrintDocument {
+    /** Every page, in print order. */
+    pagesHtml: string[];
+    pageWidth: number;
+    pageHeight: number;
+    /** `@page` size in inches, for the browser's print engine. */
+    pageSizeInches: {
+        width: number;
+        height: number;
+    };
+}
+/** All the printed pages of the chosen sheets under the setup (empty when there is nothing to print). */
+declare function buildPrintDocument(sheets: readonly PrintSheet[], setup: SheetPageSetup): PrintDocument | null;
+/** The whole printable web page: `@page` set to the paper, one section per page. */
+declare function printDocumentHtml(doc: PrintDocument, title: string): string;
+
+/**
+ * Outputs of a workbook: CSV/TSV/HTML downloads of the current sheet, and Print / PDF of what its page setup asks for.
+ * Both read the same string grid the rest of the workbook code reads
+ * (`univerSnapshotToRows`) — one source of what "the sheet" contains.
+ */
+
+declare function rowsToCsv(rows: readonly (readonly string[])[]): string;
+declare function downloadSheetAsCsv(snapshot: unknown, options: {
+    sheetId?: string;
+    filename: string;
+}): boolean;
+/** Tab-separated values of the current sheet (Google's .tsv download). */
+declare function downloadSheetAsTsv(snapshot: unknown, options: {
+    sheetId?: string;
+    filename: string;
+}): boolean;
+/** The current sheet as a standalone web page (Google's .html download). */
+declare function downloadSheetAsHtml(snapshot: unknown, options: {
+    sheetId?: string;
+    filename: string;
+}): boolean;
+/** What a print or PDF needs besides the snapshot: the workbook's page setup and the live selection. */
+interface SheetPrintOptions {
+    sheetId?: string;
+    title: string;
+    setup: SheetPageSetup;
+    /** The cells selected right now (used when the setup prints "selected cells"). */
+    selection?: CellRange | null;
+}
+/** Opens the browser print sheet for what the workbook's page setup asks to print (choose "Save as PDF" there). */
+declare function printSheet(snapshot: unknown, options: SheetPrintOptions): boolean;
+/** The sheet's grid as a markdown table (first row is the header row). */
+declare function rowsToMarkdownTable(rows: readonly (readonly string[])[]): string;
+/**
+ * Real PDF download of what the workbook's page setup prints: the same pages Print draws, each one
+ * captured and laid on a PDF page of the chosen paper size and orientation. Returns false when empty.
+ */
+declare function downloadSheetAsPdf(snapshot: unknown, options: SheetPrintOptions): Promise<boolean>;
+
+interface WorkbookLiveScope {
+    sheets: Array<{
+        id: string;
+        name: string;
+        index: number;
+    }>;
+    activeSheetId: string | null;
+    activeSheetName: string | null;
+    snapshot: Record<string, unknown> | null;
+    bootState: "booting" | "ready" | "load_error";
+    loadError: string | null;
+    saveStatus: string;
+    collab: {
+        enabled: boolean;
+        is_host: boolean;
+        self_uid: string;
+        remote_peers: number;
+    };
+}
+interface Registration {
+    workbookId: string;
+    read: () => WorkbookLiveScope | null;
+}
+/** Called by `WorkbookEditor` while mounted. Returns an unregister. */
+declare function registerWorkbookScopeSource(registration: Registration): () => void;
+/**
+ * Read the live editor state for `workbookId`. Returns null when no editor is
+ * mounted, when a different workbook is mounted, or when Univer has not
+ * booted yet — never a fabricated shape.
+ */
+declare function readWorkbookScopeSource(workbookId: string): WorkbookLiveScope | null;
+
+export { type CellRange, type CfRule, type CreateWorkbookArgs, DEFAULT_SHEET_PAGE_SETUP, GRID_MAX_COLUMNS, GRID_MAX_ROWS, type GridCell, type GridSheet, MARGIN_PRESET_INCHES, PRINT_ROW_HEIGHT, type PageSetupResult, type PrintDocument, type PrintGeometry, type PrintPage, type PrintPlan, type PrintSheet, SHEET_MARGIN_PRESETS, SHEET_PRINT_SCOPES, SHEET_SCALES, type SaveSnapshotArgs, type SheetAlignH, type SheetAlignV, type SheetMarginPreset, type SheetPageOrder, type SheetPageSetup, type SheetPrintOptions, type SheetPrintScope, type SheetScale, type SheetsHostPorts, type SheetsSupabase, type SnapshotRows, THUMB_HEIGHT, THUMB_WIDTH, type Workbook, type WorkbookLiveScope, buildPrintDocument, cfMatch, collectPrintSheets, configureSheetsHost, copyWorkbook, createWorkbook, deleteWorkbook, discardFailedWorkbook, documentPreviewSvg, downloadSheetAsCsv, downloadSheetAsHtml, downloadSheetAsPdf, downloadSheetAsTsv, formatCellValue, getLatestSnapshot, getSheetsHost, getWorkbook, listAccessibleWorkbooks, listSnapshots, listTrashedWorkbooks, moveWorkbook, normalizeSheetPageSetup, pageSetupFromMetadata, parseResource, planSheetPrint, printColumnWidths, printDocumentHtml, printGeometry, printSheet, readSheetPageSetup, readWorkbookScopeSource, registerWorkbookScopeSource, renameWorkbook, restoreWorkbook, rowsToCsv, rowsToMarkdownTable, saveSnapshot, snapshotPreviewSvg, snapshotToGridSheets, univerSheetIds, univerSnapshotToRows, updateWorkbookDescription, workbookPreviewSvg, workbookSourceLabel, writeSheetPageSetup };