@office-kit/xlsx 0.8.0

package/dist/worksheet/page-setup.d.ts

@@ -0,0 +1,173 @@
+export interface PrintOptions {
+    /** Center the printed sheet horizontally on the page. */
+    horizontalCentered?: boolean;
+    /** Center the printed sheet vertically on the page. */
+    verticalCentered?: boolean;
+    /** Print row + column headings (the A B C / 1 2 3 strips). */
+    headings?: boolean;
+    /** Print sheet gridlines. */
+    gridLines?: boolean;
+    /** Mirrors a quirky Excel companion flag for `gridLines`. */
+    gridLinesSet?: boolean;
+}
+/** Page margins in inches. ECMA-376 §18.3.1.62. All six fields are required when the element is present. */
+export interface PageMargins {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    header: number;
+    footer: number;
+}
+export type PageOrientation = 'default' | 'portrait' | 'landscape';
+export type PageOrder = 'downThenOver' | 'overThenDown';
+export type CellCommentMode = 'none' | 'asDisplayed' | 'atEnd';
+export type PrintErrorMode = 'displayed' | 'blank' | 'dash' | 'NA';
+export interface PageSetup {
+    paperSize?: number;
+    scale?: number;
+    firstPageNumber?: number;
+    fitToWidth?: number;
+    fitToHeight?: number;
+    pageOrder?: PageOrder;
+    orientation?: PageOrientation;
+    usePrinterDefaults?: boolean;
+    blackAndWhite?: boolean;
+    draft?: boolean;
+    cellComments?: CellCommentMode;
+    useFirstPageNumber?: boolean;
+    errors?: PrintErrorMode;
+    horizontalDpi?: number;
+    verticalDpi?: number;
+    copies?: number;
+    /** Optional `r:id` referencing an external printerSettings part — round-tripped verbatim. */
+    rId?: string;
+    /** Paper height (UniversalMeasure, e.g. "297mm"). */
+    paperHeight?: string;
+    /** Paper width (UniversalMeasure). */
+    paperWidth?: string;
+}
+export interface HeaderFooter {
+    differentFirst?: boolean;
+    differentOddEven?: boolean;
+    /** Mirror Excel's "scale header/footer with document" toggle. Default true. */
+    scaleWithDoc?: boolean;
+    /** Mirror Excel's "align header/footer with margins" toggle. Default true. */
+    alignWithMargins?: boolean;
+    /**
+     * Mini-format string. Excel uses `&L` / `&C` / `&R` to split the three
+     * sections, plus codes like `&P` (page number), `&N` (page count), `&F` (file
+     * name), `&A` (sheet name), `&D` / `&T` (date / time). We round-trip the
+     * literal text — no parsing into sections.
+     */
+    oddHeader?: string;
+    oddFooter?: string;
+    evenHeader?: string;
+    evenFooter?: string;
+    firstHeader?: string;
+    firstFooter?: string;
+}
+export declare const makePageMargins: (opts?: Partial<PageMargins>) => PageMargins;
+export declare const makePrintOptions: (opts?: PrintOptions) => PrintOptions;
+export declare const makePageSetup: (opts?: PageSetup) => PageSetup;
+export declare const makeHeaderFooter: (opts?: HeaderFooter) => HeaderFooter;
+/**
+ * One manual page break. `id` is the row (for rowBreaks) or column (for
+ * colBreaks) index where the break sits; `min`/`max` constrain the orthogonal
+ * range Excel honours; `man=true` means a user-placed break (default true).
+ * `pt` indicates a "pivot table" break — rare.
+ */
+export interface PageBreak {
+    id?: number;
+    min?: number;
+    max?: number;
+    man?: boolean;
+    pt?: boolean;
+}
+export declare const makePageBreak: (opts?: PageBreak) => PageBreak;
+import type { Worksheet } from './worksheet';
+/** Set page orientation on `ws.pageSetup` (allocates if missing). */
+export declare const setPageOrientation: (ws: Worksheet, orientation: PageOrientation) => void;
+/** Set paper size code (Excel uses ECMA-376 §3.3 paper-size enums; 1=Letter, 9=A4 etc.). */
+export declare const setPaperSize: (ws: Worksheet, paperSize: number) => void;
+/** Set the print scale percentage (10..400). */
+export declare const setPrintScale: (ws: Worksheet, scale: number) => void;
+/** Set fitToWidth + fitToHeight (Excel "Fit to N pages wide × M tall" UI). */
+export declare const setFitToPage: (ws: Worksheet, opts: {
+    width?: number;
+    height?: number;
+}) => void;
+/** Replace ws.pageMargins with the provided values (uses Excel defaults for missing axes). */
+export declare const setPageMargins: (ws: Worksheet, opts?: Partial<PageMargins>) => void;
+export type HeaderFooterSection = 'odd' | 'even' | 'first';
+/** Set the header text for a given section. Excel uses `&L` / `&C` / `&R` codes inside the string. */
+export declare const setHeader: (ws: Worksheet, section: HeaderFooterSection, text: string) => void;
+/** Set the footer text for a given section. */
+export declare const setFooter: (ws: Worksheet, section: HeaderFooterSection, text: string) => void;
+/**
+ * Excel's reserved header / footer code tokens. Drop these into the left /
+ * center / right text inputs of {@link buildHeaderFooterText} (or directly into
+ * a setHeader / setFooter string) to render dynamic values at print time.
+ */
+export declare const HEADER_FOOTER_CODES: Readonly<{
+    /** Current page number. */
+    pageNumber: "&P";
+    /** Total number of pages. */
+    pageCount: "&N";
+    /** Print date. */
+    date: "&D";
+    /** Print time. */
+    time: "&T";
+    /** File path + name. */
+    filePath: "&Z&F";
+    /** File name only. */
+    fileName: "&F";
+    /** Sheet name. */
+    sheetName: "&A";
+    /** Embedded image (Excel inserts via "Insert Picture" — `&G` is the placeholder). */
+    picture: "&G";
+}>;
+/**
+ * Build a header / footer string from optional left / center / right fragments
+ * using Excel's `&L` / `&C` / `&R` markers. An empty fragment is omitted (no
+ * marker emitted) so a center-only header doesn't leave a stray `&L` prefix.
+ * Returns `''` when all three fragments are undefined.
+ */
+export declare const buildHeaderFooterText: (parts: {
+    left?: string;
+    center?: string;
+    right?: string;
+}) => string;
+/**
+ * Set a header by left / center / right parts. `section` defaults to `'odd'`
+ * (the standard pages); pass `'first'` or `'even'` to target the alternate
+ * sections (Excel auto-flips the corresponding differentOddEven /
+ * differentFirst flag).
+ */
+export declare const setHeaderText: (ws: Worksheet, parts: {
+    left?: string;
+    center?: string;
+    right?: string;
+}, section?: HeaderFooterSection) => void;
+/** Same shape as {@link setHeaderText} but writes the corresponding footer slot. */
+export declare const setFooterText: (ws: Worksheet, parts: {
+    left?: string;
+    center?: string;
+    right?: string;
+}, section?: HeaderFooterSection) => void;
+/** Push a manual horizontal page break above the given row (1-based). Defaults to `man=true`. */
+export declare const addRowBreak: (ws: Worksheet, row: number) => PageBreak;
+/** Push a manual vertical page break to the left of the given column (1-based). Defaults to `man=true`. */
+export declare const addColBreak: (ws: Worksheet, col: number) => PageBreak;
+/** Toggle "Print gridlines". Mirrors Excel's "Page Layout → Sheet Options → Gridlines: Print". */
+export declare const setPrintGridLines: (ws: Worksheet, on: boolean) => void;
+/** Toggle "Print row and column headings" (the A B C / 1 2 3 strips on the printed page). */
+export declare const setPrintHeadings: (ws: Worksheet, on: boolean) => void;
+/**
+ * Toggle horizontal / vertical centering on the printed page. Pass either field
+ * to leave the other untouched.
+ */
+export declare const setPrintCentered: (ws: Worksheet, opts: {
+    horizontal?: boolean;
+    vertical?: boolean;
+}) => void;

package/dist/worksheet/phonetic.d.ts

@@ -0,0 +1,11 @@
+export type PhoneticType = 'halfwidthKatakana' | 'fullwidthKatakana' | 'Hiragana' | 'noConversion';
+export type PhoneticAlignment = 'noControl' | 'left' | 'center' | 'distributed';
+export interface WorksheetPhoneticProperties {
+    /** Font index in the workbook's stylesheet for the furigana glyphs. */
+    fontId?: number;
+    /** Conversion mode the IME should default to when adding furigana. */
+    type?: PhoneticType;
+    /** Horizontal alignment of the furigana strip relative to the base text. */
+    alignment?: PhoneticAlignment;
+}
+export declare const makeWorksheetPhoneticProperties: (opts?: WorksheetPhoneticProperties) => WorksheetPhoneticProperties;

package/dist/worksheet/properties.d.ts

@@ -0,0 +1,34 @@
+import type { Color } from '../styles/colors';
+export interface OutlineProperties {
+    applyStyles?: boolean;
+    /** "Summary rows below detail" — Excel default true. */
+    summaryBelow?: boolean;
+    /** "Summary columns to right of detail" — Excel default true. */
+    summaryRight?: boolean;
+    showOutlineSymbols?: boolean;
+}
+export interface PageSetupProperties {
+    autoPageBreaks?: boolean;
+    fitToPage?: boolean;
+}
+export interface SheetProperties {
+    /** VBA codeName for the sheet ("Sheet1" by default but localizable). */
+    codeName?: string;
+    enableFormatConditionsCalculation?: boolean;
+    /** Whether the sheet has an active filter set up. */
+    filterMode?: boolean;
+    /** Whether the sheet is published to a SharePoint Excel Services list. */
+    published?: boolean;
+    /** Sync* attrs control multi-sheet scroll synchronisation. */
+    syncHorizontal?: boolean;
+    syncRef?: string;
+    syncVertical?: boolean;
+    /** "Lotus 1-2-3 transition" toggles — almost never seen in modern files. */
+    transitionEvaluation?: boolean;
+    transitionEntry?: boolean;
+    /** Tab strip colour for this sheet (the coloured stripe at the bottom). */
+    tabColor?: Color;
+    outlinePr?: OutlineProperties;
+    pageSetUpPr?: PageSetupProperties;
+}
+export declare const makeSheetProperties: (opts?: SheetProperties) => SheetProperties;

package/dist/worksheet/protected-ranges.d.ts

@@ -0,0 +1,19 @@
+import type { MultiCellRange } from './cell-range';
+export interface ProtectedRange {
+    /** Range to expose for editing while the sheet is protected. */
+    sqref: MultiCellRange;
+    /** Display name shown in the dialog. */
+    name: string;
+    /** Legacy 16-bit hex password. */
+    password?: string;
+    /** Optional security descriptor (Windows ACL string). */
+    securityDescriptor?: string;
+    algorithmName?: string;
+    hashValue?: string;
+    saltValue?: string;
+    spinCount?: number;
+}
+export declare const makeProtectedRange: (opts: Partial<ProtectedRange> & {
+    sqref: MultiCellRange;
+    name: string;
+}) => ProtectedRange;

package/dist/worksheet/protection.d.ts

@@ -0,0 +1,44 @@
+export interface SheetProtection {
+    /** Master toggle — when true the sheet is protected. */
+    sheet?: boolean;
+    /** Allow operations on drawing objects when sheet is protected. */
+    objects?: boolean;
+    /** Allow operations on scenarios when sheet is protected. */
+    scenarios?: boolean;
+    formatCells?: boolean;
+    formatColumns?: boolean;
+    formatRows?: boolean;
+    insertColumns?: boolean;
+    insertRows?: boolean;
+    insertHyperlinks?: boolean;
+    deleteColumns?: boolean;
+    deleteRows?: boolean;
+    selectLockedCells?: boolean;
+    selectUnlockedCells?: boolean;
+    sort?: boolean;
+    autoFilter?: boolean;
+    pivotTables?: boolean;
+    /** Base-64 salt for the password hash. */
+    saltValue?: string;
+    /** Number of hash iterations. */
+    spinCount?: number;
+    /** Hash algorithm name, e.g. "SHA-512". */
+    algorithmName?: string;
+    /** Base-64 hashed password. */
+    hashValue?: string;
+}
+export declare const makeSheetProtection: (opts?: SheetProtection) => SheetProtection;
+import type { Worksheet } from './worksheet';
+/**
+ * Lock a worksheet with Excel's "Protect Sheet" defaults. Pass `overrides` to
+ * allow specific actions while otherwise locked (e.g. `{ sort: true,
+ * autoFilter: true }` for "allow sort + filter on locked sheet"). Password-hash
+ * fields can be supplied as a quad (algorithmName / hashValue / saltValue /
+ * spinCount); plaintext passwords are out of scope until the D-tier hashing
+ * helper lands.
+ */
+export declare const protectSheet: (ws: Worksheet, overrides?: Partial<SheetProtection>) => SheetProtection;
+/** Drop the typed sheet-protection record. */
+export declare const unprotectSheet: (ws: Worksheet) => void;
+/** Quick-lock helper that mirrors Excel's "Allow users to edit ranges → Protect Sheet" defaults. */
+export declare const isSheetProtected: (ws: Worksheet) => boolean;

package/dist/worksheet/reader.d.ts

@@ -0,0 +1,38 @@
+import type { Drawing } from '../drawing/drawing';
+import type { Relationships } from '../packaging/relationships';
+import { type XmlNode } from '../xml/tree';
+import type { LegacyComment } from './comments';
+import type { HeaderFooter, PageMargins, PageSetup } from './page-setup';
+import type { WebPublishItem } from './web-publish';
+import type { TableDefinition } from './table';
+import { type Worksheet } from './worksheet';
+/** Inputs the worksheet reader needs from the surrounding workbook context. */
+export interface WorksheetReadContext {
+    /** Resolved shared-strings table. Pass `[]` when no sst is present. */
+    sharedStrings: ReadonlyArray<string>;
+    /** This worksheet's `_rels/sheetN.xml.rels`. Used to resolve external hyperlink targets and table parts. */
+    rels?: Relationships;
+    /** Resolves a worksheet-rels rId pointing at xl/tables/tableN.xml into a parsed TableDefinition. */
+    loadTable?: (relId: string) => TableDefinition | undefined;
+    /**
+     * Loader for comments parts (rels Type=…/comments). Called once per matching
+     * rel; the reader appends every returned LegacyComment onto
+     * `ws.legacyComments`.
+     */
+    loadComments?: (relId: string) => ReadonlyArray<LegacyComment> | undefined;
+    /**
+     * Loader for the worksheet's drawing part. Called once when the worksheet
+     * inline carries `<drawing r:id="...">`.
+     */
+    loadDrawing?: (relId: string) => Drawing | undefined;
+}
+/**
+ * Parse a `xl/worksheets/sheetN.xml` payload into a fully-populated Worksheet.
+ * The returned worksheet's `title` matches the `title` argument; the XML
+ * doesn't carry the sheet name (it lives in `workbook.xml`).
+ */
+export declare function parseWorksheetXml(bytes: Uint8Array | string, title: string, ctx: WorksheetReadContext): Worksheet;
+export declare const parseWebPublishItem: (node: XmlNode) => WebPublishItem | undefined;
+export declare const parsePageMargins: (node: XmlNode) => PageMargins | undefined;
+export declare const parsePageSetup: (node: XmlNode) => PageSetup | undefined;
+export declare const parseHeaderFooter: (node: XmlNode) => HeaderFooter | undefined;

package/dist/worksheet/scenarios.d.ts

@@ -0,0 +1,36 @@
+import type { MultiCellRange } from './cell-range';
+/** One <inputCells> entry — a single (cell, override-value) pair. */
+export interface ScenarioInputCell {
+    /** Single-cell ref, e.g. "B5". */
+    ref: string;
+    /** Stored as a string on the wire (Excel uses int / float / text format codes via numFmtId). */
+    val: string;
+    /** Mark this entry as deleted in the scenario history. */
+    deleted?: boolean;
+    /** Marks an undone change in the scenario history. */
+    undone?: boolean;
+    /** Number-format index used to display the override. */
+    numFmtId?: number;
+}
+export interface Scenario {
+    name: string;
+    inputCells: ScenarioInputCell[];
+    /** When true, Excel disables editing the scenario unless the workbook protection password is supplied. */
+    locked?: boolean;
+    /** Hide the scenario from the picker dialog. */
+    hidden?: boolean;
+    user?: string;
+    comment?: string;
+}
+export interface ScenarioList {
+    scenarios: Scenario[];
+    /** Index of the currently active scenario. */
+    current?: number;
+    /** Index of the scenario shown by default. */
+    show?: number;
+    /** Range that the scenarios change (output cells). */
+    sqref?: MultiCellRange;
+}
+export declare const makeScenarioInputCell: (opts: ScenarioInputCell) => ScenarioInputCell;
+export declare const makeScenario: (opts: Scenario) => Scenario;
+export declare const makeScenarioList: (opts?: Partial<ScenarioList>) => ScenarioList;

package/dist/worksheet/smart-tags.d.ts

@@ -0,0 +1,23 @@
+export interface CellSmartTagProperty {
+    key: string;
+    val: string;
+}
+export interface CellSmartTag {
+    /** 0-based index into the workbook's smartTagTypes list. */
+    type: number;
+    properties: CellSmartTagProperty[];
+    deleted?: boolean;
+    xmlBased?: boolean;
+}
+export interface CellSmartTags {
+    /** Single-cell ref ("A1"). */
+    ref: string;
+    tags: CellSmartTag[];
+}
+export declare const makeCellSmartTagProperty: (key: string, val: string) => CellSmartTagProperty;
+export declare const makeCellSmartTag: (opts: Partial<CellSmartTag> & {
+    type: number;
+}) => CellSmartTag;
+export declare const makeCellSmartTags: (opts: Partial<CellSmartTags> & {
+    ref: string;
+}) => CellSmartTags;

package/dist/worksheet/sort-state.d.ts

@@ -0,0 +1,28 @@
+export type SortBy = 'value' | 'cellColor' | 'fontColor' | 'icon';
+export type SortMethod = 'stroke' | 'pinYin';
+export type SortIconSet = '3Arrows' | '3ArrowsGray' | '3Flags' | '3TrafficLights1' | '3TrafficLights2' | '3Signs' | '3Symbols' | '3Symbols2' | '4Arrows' | '4ArrowsGray' | '4RedToBlack' | '4Rating' | '4TrafficLights' | '5Arrows' | '5ArrowsGray' | '5Rating' | '5Quarters';
+export interface SortCondition {
+    /** Column or row that drives this sort key. */
+    ref: string;
+    descending?: boolean;
+    sortBy?: SortBy;
+    /** Reference to a custom-list defined name. */
+    customList?: string;
+    /** Differential-style index (`<dxf>` slot in the stylesheet). */
+    dxfId?: number;
+    iconSet?: SortIconSet;
+    iconId?: number;
+}
+export interface SortState {
+    /** Range the sort applies to (`A1:D20`). */
+    ref: string;
+    conditions: SortCondition[];
+    /** Sort columns instead of rows (rare). */
+    columnSort?: boolean;
+    caseSensitive?: boolean;
+    sortMethod?: SortMethod;
+}
+export declare const makeSortCondition: (opts: SortCondition) => SortCondition;
+export declare const makeSortState: (opts: Partial<SortState> & {
+    ref: string;
+}) => SortState;

package/dist/worksheet/table-xml.d.ts

@@ -0,0 +1,5 @@
+import type { TableDefinition } from './table';
+/** Parse a `xl/tables/tableN.xml` payload. */
+export declare function parseTableXml(bytes: Uint8Array | string): TableDefinition;
+/** Serialise a TableDefinition to its `xl/tables/tableN.xml` bytes. */
+export declare function tableToBytes(table: TableDefinition): Uint8Array;

package/dist/worksheet/table.d.ts

@@ -0,0 +1,80 @@
+import type { Workbook } from '../workbook/workbook';
+import type { AutoFilter } from './auto-filter';
+import type { Worksheet } from './worksheet';
+export interface TableColumn {
+    /** 1-based column id (per-table). */
+    id: number;
+    /** Header name. */
+    name: string;
+    /** Totals-row aggregation function. */
+    totalsRowFunction?: 'sum' | 'min' | 'max' | 'count' | 'countNums' | 'average' | 'stdDev' | 'var' | 'custom';
+    /** Override label for the totals row. */
+    totalsRowLabel?: string;
+    /** Custom totals-row formula text. */
+    totalsRowFormula?: string;
+    /** Calculated-column formula. */
+    calculatedColumnFormula?: string;
+}
+export interface TableStyleInfo {
+    /** Built-in style name (TableStyleMedium2, etc) or custom. */
+    name?: string;
+    showFirstColumn?: boolean;
+    showLastColumn?: boolean;
+    showRowStripes?: boolean;
+    showColumnStripes?: boolean;
+}
+export interface TableDefinition {
+    /** Workbook-unique id (`<table id="N">`). */
+    id: number;
+    /** Workbook-unique displayName — Excel surfaces this in formulas. */
+    displayName: string;
+    /** Optional friendly name; usually matches `displayName`. */
+    name?: string;
+    /** Range covered by the table, e.g. "A1:E10". */
+    ref: string;
+    /** Number of header rows. Defaults to 1; 0 means a header-less table. */
+    headerRowCount?: number;
+    /** Number of totals rows. */
+    totalsRowCount?: number;
+    /** Whether the totals row is currently visible. */
+    totalsRowShown?: boolean;
+    styleInfo?: TableStyleInfo;
+    columns: TableColumn[];
+    autoFilter?: AutoFilter;
+    /** Worksheet-rels rId — populated on read; the writer assigns its own. */
+    rId?: string;
+}
+export declare function makeTableColumn(opts: {
+    id: number;
+    name: string;
+}): TableColumn;
+export declare function makeTableDefinition(opts: {
+    id: number;
+    displayName: string;
+    ref: string;
+    name?: string;
+    columns?: TableColumn[];
+    headerRowCount?: number;
+    totalsRowCount?: number;
+    totalsRowShown?: boolean;
+    styleInfo?: TableStyleInfo;
+    autoFilter?: AutoFilter;
+}): TableDefinition;
+/**
+ * High-level wrapper that builds a TableDefinition + pushes it onto `ws.tables`
+ * in one call. Auto-assigns the workbook-unique `id`, derives `displayName`
+ * from the supplied `name`, and constructs `TableColumn` records (1-based ids)
+ * from a string-array shorthand.
+ */
+export declare const addExcelTable: (wb: Workbook, ws: Worksheet, opts: {
+    name: string;
+    ref: string;
+    columns: ReadonlyArray<string | TableColumn>;
+    style?: string;
+    styleInfo?: TableStyleInfo;
+    headerRowCount?: number;
+    totalsRowCount?: number;
+    totalsRowShown?: boolean;
+    autoFilter?: AutoFilter;
+    displayName?: string;
+}) => TableDefinition;

package/dist/worksheet/views.d.ts

@@ -0,0 +1,47 @@
+export type PaneType = 'bottomRight' | 'topRight' | 'bottomLeft' | 'topLeft';
+export type PaneState = 'split' | 'frozen' | 'frozenSplit';
+export type SheetViewMode = 'normal' | 'pageBreakPreview' | 'pageLayout';
+export interface Pane {
+    /** Column-axis split. Number of columns frozen on the left. */
+    xSplit?: number;
+    /** Row-axis split. Number of rows frozen on top. */
+    ySplit?: number;
+    /** First visible cell of the bottom-right pane. */
+    topLeftCell?: string;
+    /** Which pane is active when the sheet is opened. Defaults to `bottomRight` for full freezes. */
+    activePane?: PaneType;
+    state: PaneState;
+}
+export interface Selection {
+    pane?: PaneType;
+    activeCell?: string;
+    sqref?: string;
+}
+export interface SheetView {
+    /** Index into the parent workbook's bookViews list. Defaults to 0. */
+    workbookViewId: number;
+    tabSelected?: boolean;
+    showGridLines?: boolean;
+    showRowColHeaders?: boolean;
+    showFormulas?: boolean;
+    showZeros?: boolean;
+    rightToLeft?: boolean;
+    view?: SheetViewMode;
+    topLeftCell?: string;
+    zoomScale?: number;
+    zoomScaleNormal?: number;
+    pane?: Pane;
+    selection?: Selection;
+}
+/** Build a SheetView with sensible defaults. */
+export declare function makeSheetView(opts?: Partial<SheetView>): SheetView;
+/**
+ * Build a frozen Pane from a top-left coordinate. Per Excel semantics:
+ * - "B2" → freeze 1 row + 1 col → xSplit=1, ySplit=1, activePane='bottomRight'
+ * - "A2" → freeze 1 row only → ySplit=1, activePane='bottomLeft'
+ * - "B1" → freeze 1 col only → xSplit=1, activePane='topRight'
+ * - "A1" → no freeze; throws (caller should clear `ws.views[].pane`).
+ */
+export declare function makeFreezePane(topLeftRef: string): Pane;
+/** Inverse of {@link makeFreezePane}. Returns the top-left ref of the bottomRight pane, or undefined. */
+export declare function freezePaneRef(view: SheetView): string | undefined;

package/dist/worksheet/web-publish.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One <customProperty>. The `rId` points at a Custom XML part registered in the
+ * worksheet rels (e.g. for SharePoint sync metadata).
+ */
+export interface WorksheetCustomProperty {
+    name: string;
+    /** Worksheet-rels rId pointing at the Custom XML part backing this entry. */
+    rId?: string;
+}
+export interface WebPublishItem {
+    id: number;
+    divId: string;
+    sourceType: 'sheet' | 'printArea' | 'autoFilter' | 'range' | 'chart' | 'pivotTable' | 'query' | 'label';
+    sourceRef?: string;
+    sourceObject?: string;
+    destinationFile: string;
+    title?: string;
+    autoRepublish?: boolean;
+}
+export declare const makeWorksheetCustomProperty: (opts: WorksheetCustomProperty) => WorksheetCustomProperty;
+export declare const makeWebPublishItem: (opts: WebPublishItem) => WebPublishItem;