DocumentOp | @sheetwrite/core

Exhaustive serializable operation union for workbook mutations.

Package: @sheetwrite/core
Source: packages/core/src/types/document.ts#L313

Variants 27

{
  op: "set";
  addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →;
  value: CellValuetype CellValue =
  | { kind: "literal"; value: CellScalar }
  | { kind: "ref"; target: CellAddress }
  | { kind: "formula"; src: string };type CellValue =
  | { kind: "literal"; value: CellScalar }
  | { kind: "ref"; target: CellAddress }
  | { kind: "formula"; src: string };type CellValue =
  | {
      kind: "literal";
      value: CellScalar;
    }
  | {
      kind: "ref";
      target: CellAddress;
    }
  | {
      kind: "formula";
      src: string;
    };A cell's persisted input: a literal, a cross-reference, or a formula. References resolve through the store's reference graph; formulas resolve in the WASM calculation engine.API reference →;
  style?: CellStyleinterface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}Serializable formatting applied to a cell or used as a column default.API reference →;
}

{ op: "setRange"; range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →; cells: SnapshotCellinterface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}interface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}interface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}Serializable cell value and optional style inside a snapshot block.API reference →[] }

{ op: "setBlock"; range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →; block: PackedCellBlockinterface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<[offset: number, source: string]>;
  refs?: Array<[offset: number, target: CellAddress]>;
  styleTable?: CellStyle[];
  styleIds?: number[];
}interface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<[offset: number, source: string]>;
  refs?: Array<[offset: number, target: CellAddress]>;
  styleTable?: CellStyle[];
  styleIds?: number[];
}interface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<
    [
      offset: number,
      source: string,
    ]
  >;
  refs?: Array<
    [
      offset: number,
      target: CellAddress,
    ]
  >;
  styleTable?: CellStyle[];
  styleIds?: number[];
}Dense row-major mutation payload. Primitive arrays keep large paste/fill operations JSON-safe without allocating one operation object per cell. Formula/reference tuples are sparse exceptions keyed by row-major offset.API reference → }

{
  op: "setRangeStyle";
  range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
  style: Partial<CellStyleinterface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}Serializable formatting applied to a cell or used as a column default.API reference →> | null;
}

{
  op: "clearRange";
  range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
  contents?: boolean;
  style?: boolean;
}

{ op: "addRows"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; at: number; count: number }

{
  op: "removeRows";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  at: number;
  count: number;
}

{
  op: "moveRows";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  from: number;
  count: number;
  to: number;
}

{
  op: "addColumns";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  at: number;
  columns: Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[];
}

{
  op: "removeColumns";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  at: number;
  count: number;
}

{
  op: "moveColumns";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  from: number;
  count: number;
  to: number;
}

{
  op: "setColumn";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  col: number;
  patch: Partial<Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →>;
}

{
  op: "setRowMeta";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  row: number;
  meta: RowMetadatainterface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}Persistent display and grouping metadata for one document row.API reference → | null;
}

{ op: "addMerge"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; merge: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference → }

{ op: "removeMerge"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; merge: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference → }

{ op: "addSheet"; sheet: SheetSnapshotinterface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<[row: number, meta: RowMetadata]>;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  notes?: CellNote[];
  // … 5 more lines — see the API reference
}interface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<[row: number, meta: RowMetadata]>;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  notes?: CellNote[];
  // … 5 more lines — see the API reference
}interface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<
    [
      row: number,
      meta: RowMetadata,
    ]
  >;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  // … 11 more lines — see the API reference
}Serializable complete state for one workbook sheet.API reference → }

{ op: "removeSheet"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference → }

{ op: "renameSheet"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; name: string }

{ op: "moveSheet"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; to: number }

{
  op: "setSheetMeta";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  patch: {
    frozenRows?: number;
    frozenCols?: number;
    conditionalFormats?: ConditionalFormatRuleinterface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}Ordered condition and style applied to a cell range.API reference →[];
    rowGroups?: RowGroupinterface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}A collapsible row group (data-row range, end-inclusive), Sheets-style.API reference →[];
    sortKeys?: SortKeyinterface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}One key of a multi-column sort, applied in array order (first = primary).API reference →[];
    filters?: Array<[col: number, filter: ColumnFiltertype ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | {
      kind: "values";
      values: readonly CellScalar[];
    }
  | {
      kind: "contains";
      text: string;
      matchCase?: boolean;
    }
  | {
      kind: "compare";
      op:
        | "gt"
        | "gte"
        | "lt"
        | "lte"
        | "eq"
        | "neq";
  // … 4 more lines — see the API reference
}One column's filter predicate. All active column filters AND together; matching is against the cell's resolved value (text or number).API reference →]>;
  };
}

{
  op: "setValidationRule";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  rule: DataValidationRuleinterface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}One stable, range-scoped data-entry rule. Blank cells are allowed unless disabled.API reference →;
}

{ op: "removeValidationRule"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; id: string }

{
  op: "setProtectedRange";
  sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  protectedRange: ProtectedRangeinterface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}Serializable client UX policy. A host resolver decides whether a local mutation may proceed.API reference →;
}

{ op: "removeProtectedRange"; sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →; id: string }

{ op: "setNote"; addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →; text: string | null }

{ op: "setNamedRange"; namedRange: NamedRangeSnapshotinterface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}interface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}interface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}Workbook-global or sheet-scoped named range used by formulas and persistence.API reference → }

{ op: "removeNamedRange"; name: string; scope?: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference → }

Declaration

View full TypeScript declaration

export type DocumentOp =
  | {
      op: "set";
      addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →;
      value: CellValuetype CellValue =
  | { kind: "literal"; value: CellScalar }
  | { kind: "ref"; target: CellAddress }
  | { kind: "formula"; src: string };type CellValue =
  | { kind: "literal"; value: CellScalar }
  | { kind: "ref"; target: CellAddress }
  | { kind: "formula"; src: string };type CellValue =
  | {
      kind: "literal";
      value: CellScalar;
    }
  | {
      kind: "ref";
      target: CellAddress;
    }
  | {
      kind: "formula";
      src: string;
    };A cell's persisted input: a literal, a cross-reference, or a formula. References resolve through the store's reference graph; formulas resolve in the WASM calculation engine.API reference →;
      style?: CellStyleinterface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}Serializable formatting applied to a cell or used as a column default.API reference →;
    }
  | {
      op: "setRange";
      range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
      cells: SnapshotCellinterface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}interface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}interface SnapshotCell {
  rowOffset: number;
  colOffset: number;
  value: CellValue;
  style?: CellStyle;
}Serializable cell value and optional style inside a snapshot block.API reference →[];
    }
  | {
      op: "setBlock";
      range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
      block: PackedCellBlockinterface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<[offset: number, source: string]>;
  refs?: Array<[offset: number, target: CellAddress]>;
  styleTable?: CellStyle[];
  styleIds?: number[];
}interface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<[offset: number, source: string]>;
  refs?: Array<[offset: number, target: CellAddress]>;
  styleTable?: CellStyle[];
  styleIds?: number[];
}interface PackedCellBlock {
  rowCount: number;
  colCount: number;
  values: CellScalar[];
  formulas?: Array<
    [
      offset: number,
      source: string,
    ]
  >;
  refs?: Array<
    [
      offset: number,
      target: CellAddress,
    ]
  >;
  styleTable?: CellStyle[];
  styleIds?: number[];
}Dense row-major mutation payload. Primitive arrays keep large paste/fill operations JSON-safe without allocating one operation object per cell. Formula/reference tuples are sparse exceptions keyed by row-major offset.API reference →;
    }
  | {
      op: "setRangeStyle";
      range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
      style: Partial<CellStyleinterface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}interface CellStyle {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean;
  fontSize?: number;
  color?: string;
  backgroundColor?: string;
  align?: CellAlign;
  wrap?: boolean;
  border?: CellBorders;
}Serializable formatting applied to a cell or used as a column default.API reference →> | null;
    }
  | {
      op: "clearRange";
      range: Rangeinterface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: { row: number; col: number };
  end: { row: number; col: number };
}interface Range {
  sheet: SheetId;
  start: {
    row: number;
    col: number;
  };
  end: {
    row: number;
    col: number;
  };
}Inclusive rectangular cell range on a stable sheet ID.API reference →;
      contents?: boolean;
      style?: boolean;
    }
  | {
      op: "addRows";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      at: number;
      count: number;
    }
  | {
      op: "removeRows";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      at: number;
      count: number;
    }
  | {
      op: "moveRows";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      from: number;
      count: number;
      to: number;
    }
  | {
      op: "addColumns";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      at: number;
      columns: Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[];
    }
  | {
      op: "removeColumns";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      at: number;
      count: number;
    }
  | {
      op: "moveColumns";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      from: number;
      count: number;
      to: number;
    }
  | {
      op: "setColumn";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      col: number;
      patch: Partial<Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →>;
    }
  | {
      op: "setRowMeta";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      row: number;
      meta: RowMetadatainterface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}Persistent display and grouping metadata for one document row.API reference → | null;
    }
  | {
      op: "addMerge";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      merge: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference →;
    }
  | {
      op: "removeMerge";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      merge: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference →;
    }
  | {
      op: "addSheet";
      sheet: SheetSnapshotinterface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<[row: number, meta: RowMetadata]>;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  notes?: CellNote[];
  // … 5 more lines — see the API reference
}interface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<[row: number, meta: RowMetadata]>;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  notes?: CellNote[];
  // … 5 more lines — see the API reference
}interface SheetSnapshot {
  id: SheetId;
  name: string;
  order: number;
  visibility?: SheetVisibility;
  rowCount: number;
  columns: Column[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<
    [
      row: number,
      meta: RowMetadata,
    ]
  >;
  merges?: MergeRange[];
  conditionalFormats?: ConditionalFormatRule[];
  validationRules?: DataValidationRule[];
  protectedRanges?: ProtectedRange[];
  // … 11 more lines — see the API reference
}Serializable complete state for one workbook sheet.API reference →;
    }
  | {
      op: "removeSheet";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
    }
  | {
      op: "renameSheet";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      name: string;
    }
  | {
      op: "moveSheet";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      to: number;
    }
  | {
      op: "setSheetMeta";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      patch: {
        frozenRows?: number;
        frozenCols?: number;
        conditionalFormats?: ConditionalFormatRuleinterface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}Ordered condition and style applied to a cell range.API reference →[];
        rowGroups?: RowGroupinterface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}A collapsible row group (data-row range, end-inclusive), Sheets-style.API reference →[];
        sortKeys?: SortKeyinterface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}One key of a multi-column sort, applied in array order (first = primary).API reference →[];
        filters?: Array<[col: number, filter: ColumnFiltertype ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | {
      kind: "values";
      values: readonly CellScalar[];
    }
  | {
      kind: "contains";
      text: string;
      matchCase?: boolean;
    }
  | {
      kind: "compare";
      op:
        | "gt"
        | "gte"
        | "lt"
        | "lte"
        | "eq"
        | "neq";
  // … 4 more lines — see the API reference
}One column's filter predicate. All active column filters AND together; matching is against the cell's resolved value (text or number).API reference →]>;
      };
    }
  | {
      op: "setValidationRule";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      rule: DataValidationRuleinterface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}One stable, range-scoped data-entry rule. Blank cells are allowed unless disabled.API reference →;
    }
  | {
      op: "removeValidationRule";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      id: string;
    }
  | {
      op: "setProtectedRange";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      protectedRange: ProtectedRangeinterface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}Serializable client UX policy. A host resolver decides whether a local mutation may proceed.API reference →;
    }
  | {
      op: "removeProtectedRange";
      sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
      id: string;
    }
  | {
      op: "setNote";
      addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →;
      text: string | null;
    }
  | {
      op: "setNamedRange";
      namedRange: NamedRangeSnapshotinterface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}interface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}interface NamedRangeSnapshot {
  name: string;
  scope?: SheetId;
  range: Range;
}Workbook-global or sheet-scoped named range used by formulas and persistence.API reference →;
    }
  | {
      op: "removeNamedRange";
      name: string;
      scope?: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
    };